/[svn]/linuxsampler/trunk/src/engines/gig/Engine.cpp
ViewVC logotype

Diff of /linuxsampler/trunk/src/engines/gig/Engine.cpp

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

revision 781 by schoenebeck, Mon Sep 26 10:17:00 2005 UTC revision 1748 by persson, Sun Jun 22 14:46:46 2008 UTC
# Line 2  Line 2 
2   *                                                                         *   *                                                                         *
3   *   LinuxSampler - modular, streaming capable sampler                     *   *   LinuxSampler - modular, streaming capable sampler                     *
4   *                                                                         *   *                                                                         *
5   *   Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck   *   *   Copyright (C) 2003,2004 by Benno Senoner and Christian Schoenebeck    *
6   *   Copyright (C) 2005 Christian Schoenebeck                              *   *   Copyright (C) 2005-2008 Christian Schoenebeck                         *
7   *                                                                         *   *                                                                         *
8   *   This program is free software; you can redistribute it and/or modify  *   *   This program is free software; you can redistribute it and/or modify  *
9   *   it under the terms of the GNU General Public License as published by  *   *   it under the terms of the GNU General Public License as published by  *
# Line 29  Line 29 
29    
30  #include "Engine.h"  #include "Engine.h"
31    
32    #include "../../common/global_private.h"
33    
34  namespace LinuxSampler { namespace gig {  namespace LinuxSampler { namespace gig {
35    
36      InstrumentResourceManager Engine::instruments;      InstrumentResourceManager Engine::instruments;
# Line 51  namespace LinuxSampler { namespace gig { Line 53  namespace LinuxSampler { namespace gig {
53          if (engines.count(pDevice)) {          if (engines.count(pDevice)) {
54              dmsg(4,("Using existing gig::Engine.\n"));              dmsg(4,("Using existing gig::Engine.\n"));
55              pEngine = engines[pDevice];              pEngine = engines[pDevice];
56    
57                // Disable the engine while the new engine channel is
58                // added and initialized. The engine will be enabled again
59                // in EngineChannel::Connect.
60                pEngine->DisableAndLock();
61          } else { // create a new engine (and disk thread) instance for the given audio output device          } else { // create a new engine (and disk thread) instance for the given audio output device
62              dmsg(4,("Creating new gig::Engine.\n"));              dmsg(4,("Creating new gig::Engine.\n"));
63              pEngine = (Engine*) EngineFactory::Create("gig");              pEngine = (Engine*) EngineFactory::Create("gig");
# Line 67  namespace LinuxSampler { namespace gig { Line 74  namespace LinuxSampler { namespace gig {
74    
75      /**      /**
76       * Once an engine channel is disconnected from an audio output device,       * Once an engine channel is disconnected from an audio output device,
77       * it wil immediately call this method to unregister itself from the       * it will immediately call this method to unregister itself from the
78       * engine instance and if that engine instance is not used by any other       * engine instance and if that engine instance is not used by any other
79       * engine channel anymore, then that engine instance will be destroyed.       * engine channel anymore, then that engine instance will be destroyed.
80       *       *
# Line 93  namespace LinuxSampler { namespace gig { Line 100  namespace LinuxSampler { namespace gig {
100      /**      /**
101       * Constructor       * Constructor
102       */       */
103      Engine::Engine() {      Engine::Engine() : SuspendedRegions(128) {
104          pAudioOutputDevice = NULL;          pAudioOutputDevice = NULL;
105          pDiskThread        = NULL;          pDiskThread        = NULL;
106          pEventGenerator    = NULL;          pEventGenerator    = NULL;
107          pSysexBuffer       = new RingBuffer<uint8_t>(CONFIG_SYSEX_BUFFER_SIZE, 0);          pSysexBuffer       = new RingBuffer<uint8_t,false>(CONFIG_SYSEX_BUFFER_SIZE, 0);
108          pEventQueue        = new RingBuffer<Event>(CONFIG_MAX_EVENTS_PER_FRAGMENT, 0);          pEventQueue        = new RingBuffer<Event,false>(CONFIG_MAX_EVENTS_PER_FRAGMENT, 0);
109          pEventPool         = new Pool<Event>(CONFIG_MAX_EVENTS_PER_FRAGMENT);          pEventPool         = new Pool<Event>(CONFIG_MAX_EVENTS_PER_FRAGMENT);
110          pVoicePool         = new Pool<Voice>(CONFIG_MAX_VOICES);          pVoicePool         = new Pool<Voice>(CONFIG_MAX_VOICES);
111            pDimRegionPool[0]  = new Pool< ::gig::DimensionRegion*>(CONFIG_MAX_VOICES);
112            pDimRegionPool[1]  = new Pool< ::gig::DimensionRegion*>(CONFIG_MAX_VOICES);
113          pVoiceStealingQueue = new RTList<Event>(pEventPool);          pVoiceStealingQueue = new RTList<Event>(pEventPool);
114          pGlobalEvents      = new RTList<Event>(pEventPool);          pGlobalEvents      = new RTList<Event>(pEventPool);
115    
116          for (RTList<Voice>::Iterator iterVoice = pVoicePool->allocAppend(); iterVoice == pVoicePool->last(); iterVoice = pVoicePool->allocAppend()) {          for (RTList<Voice>::Iterator iterVoice = pVoicePool->allocAppend(); iterVoice == pVoicePool->last(); iterVoice = pVoicePool->allocAppend()) {
117              iterVoice->SetEngine(this);              iterVoice->SetEngine(this);
118          }          }
# Line 110  namespace LinuxSampler { namespace gig { Line 120  namespace LinuxSampler { namespace gig {
120    
121          ResetInternal();          ResetInternal();
122          ResetScaleTuning();          ResetScaleTuning();
123            ResetSuspendedRegions();
124      }      }
125    
126      /**      /**
127       * Destructor       * Destructor
128       */       */
129      Engine::~Engine() {      Engine::~Engine() {
130            MidiInputPort::RemoveSysexListener(this);
131          if (pDiskThread) {          if (pDiskThread) {
132              dmsg(1,("Stopping disk thread..."));              dmsg(1,("Stopping disk thread..."));
133              pDiskThread->StopThread();              pDiskThread->StopThread();
# Line 131  namespace LinuxSampler { namespace gig { Line 143  namespace LinuxSampler { namespace gig {
143          if (pEventGenerator) delete pEventGenerator;          if (pEventGenerator) delete pEventGenerator;
144          if (pVoiceStealingQueue) delete pVoiceStealingQueue;          if (pVoiceStealingQueue) delete pVoiceStealingQueue;
145          if (pSysexBuffer) delete pSysexBuffer;          if (pSysexBuffer) delete pSysexBuffer;
146          EngineFactory::Destroy(this);          if (pGlobalEvents) delete pGlobalEvents;
147            if (pDimRegionPool[0]) delete pDimRegionPool[0];
148            if (pDimRegionPool[1]) delete pDimRegionPool[1];
149            ResetSuspendedRegions();
150            Unregister();
151      }      }
152    
153      void Engine::Enable() {      void Engine::Enable() {
# Line 140  namespace LinuxSampler { namespace gig { Line 156  namespace LinuxSampler { namespace gig {
156          dmsg(3,("gig::Engine: enabled (val=%d)\n", EngineDisabled.GetUnsafe()));          dmsg(3,("gig::Engine: enabled (val=%d)\n", EngineDisabled.GetUnsafe()));
157      }      }
158    
159        /**
160         * Temporarily stop the engine to not do anything. The engine will just be
161         * frozen during that time, that means after enabling it again it will
162         * continue where it was, with all its voices and playback state it had at
163         * the point of disabling. Notice that the engine's (audio) thread will
164         * continue to run, it just remains in an inactive loop during that time.
165         *
166         * If you need to be sure that all voices and disk streams are killed as
167         * well, use @c SuspendAll() instead.
168         *
169         * @see Enable(), SuspendAll()
170         */
171      void Engine::Disable() {      void Engine::Disable() {
172          dmsg(3,("gig::Engine: disabling\n"));          dmsg(3,("gig::Engine: disabling\n"));
173          bool* pWasDisabled = EngineDisabled.PushAndUnlock(true, 2); // wait max. 2s          bool* pWasDisabled = EngineDisabled.PushAndUnlock(true, 2); // wait max. 2s
# Line 153  namespace LinuxSampler { namespace gig { Line 181  namespace LinuxSampler { namespace gig {
181      }      }
182    
183      /**      /**
184         * Similar to @c Disable() but this method additionally kills all voices
185         * and disk streams and blocks until all voices and disk streams are actually
186         * killed / deleted.
187         *
188         * @e Note: only the original calling thread is able to re-enable the
189         * engine afterwards by calling @c ResumeAll() later on!
190         */
191        void Engine::SuspendAll() {
192            dmsg(2,("gig::Engine: Suspending all ...\n"));
193            // stop the engine, so we can safely modify the engine's
194            // data structures from this foreign thread
195            DisableAndLock();
196            // we could also use the respective class member variable here,
197            // but this is probably safer and cleaner
198            int iPendingStreamDeletions = 0;
199            // kill all voices on all engine channels the *die hard* way
200            for (int iChannel = 0; iChannel < engineChannels.size(); iChannel++) {
201                EngineChannel* pEngineChannel = engineChannels[iChannel];
202                RTList<uint>::Iterator iuiKey = pEngineChannel->pActiveKeys->first();
203                RTList<uint>::Iterator end    = pEngineChannel->pActiveKeys->end();
204                for (; iuiKey != end; ++iuiKey) { // iterate through all active keys
205                    midi_key_info_t* pKey = &pEngineChannel->pMIDIKeyInfo[*iuiKey];
206                    RTList<Voice>::Iterator itVoice = pKey->pActiveVoices->first();
207                    RTList<Voice>::Iterator itVoicesEnd = pKey->pActiveVoices->end();
208                    for (; itVoice != itVoicesEnd; ++itVoice) { // iterate through all voices on this key
209                        // request a notification from disk thread side for stream deletion
210                        const Stream::Handle hStream = itVoice->KillImmediately(true);
211                        if (hStream != Stream::INVALID_HANDLE) { // voice actually used a stream
212                            iPendingStreamDeletions++;
213                        }
214                    }
215                }
216            }
217            // wait until all streams were actually deleted by the disk thread
218            while (iPendingStreamDeletions) {
219                while (
220                    iPendingStreamDeletions &&
221                    pDiskThread->AskForDeletedStream() != Stream::INVALID_HANDLE
222                ) iPendingStreamDeletions--;
223                if (!iPendingStreamDeletions) break;
224                usleep(10000); // sleep for 10ms
225            }
226            dmsg(2,("gig::Engine: Everything suspended.\n"));
227        }
228    
229        /**
230         * At the moment same as calling @c Enable() directly, but this might
231         * change in future, so better call this method as counterpart to
232         * @c SuspendAll() instead of @c Enable() !
233         */
234        void Engine::ResumeAll() {
235            Enable();
236        }
237    
238        /**
239         * Order the engine to stop rendering audio for the given region.
240         * Additionally this method will block until all voices and their disk
241         * streams associated with that region are actually killed / deleted, so
242         * one can i.e. safely modify the region with an instrument editor after
243         * returning from this method.
244         *
245         * @param pRegion - region the engine shall stop using
246         */
247        void Engine::Suspend(::gig::Region* pRegion) {
248            dmsg(2,("gig::Engine: Suspending Region %x ...\n",pRegion));
249            SuspendedRegionsMutex.Lock();
250            SuspensionChangeOngoing.Set(true);
251            pPendingRegionSuspension = pRegion;
252            SuspensionChangeOngoing.WaitAndUnlockIf(true);
253            SuspendedRegionsMutex.Unlock();
254            dmsg(2,("gig::Engine: Region %x suspended.",pRegion));
255        }
256    
257        /**
258         * Orders the engine to resume playing back the given region, previously
259         * suspended with @c Suspend() .
260         *
261         * @param pRegion - region the engine shall be allowed to use again
262         */
263        void Engine::Resume(::gig::Region* pRegion) {
264            dmsg(2,("gig::Engine: Resuming Region %x ...\n",pRegion));
265            SuspendedRegionsMutex.Lock();
266            SuspensionChangeOngoing.Set(true);
267            pPendingRegionResumption = pRegion;
268            SuspensionChangeOngoing.WaitAndUnlockIf(true);
269            SuspendedRegionsMutex.Unlock();
270            dmsg(2,("gig::Engine: Region %x resumed.\n",pRegion));
271        }
272    
273        /**
274       *  Reset all voices and disk thread and clear input event queue and all       *  Reset all voices and disk thread and clear input event queue and all
275       *  control and status variables.       *  control and status variables.
276       */       */
# Line 165  namespace LinuxSampler { namespace gig { Line 283  namespace LinuxSampler { namespace gig {
283    
284      /**      /**
285       *  Reset all voices and disk thread and clear input event queue and all       *  Reset all voices and disk thread and clear input event queue and all
286       *  control and status variables. This method is not thread safe!       *  control and status variables. This method is protected by a mutex.
287       */       */
288      void Engine::ResetInternal() {      void Engine::ResetInternal() {
289            ResetInternalMutex.Lock();
290    
291            // make sure that the engine does not get any sysex messages
292            // while it's reseting
293            bool sysexDisabled = MidiInputPort::RemoveSysexListener(this);
294          ActiveVoiceCount    = 0;          ActiveVoiceCount    = 0;
295          ActiveVoiceCountMax = 0;          ActiveVoiceCountMax = 0;
296    
# Line 191  namespace LinuxSampler { namespace gig { Line 314  namespace LinuxSampler { namespace gig {
314          // delete all input events          // delete all input events
315          pEventQueue->init();          pEventQueue->init();
316          pSysexBuffer->init();          pSysexBuffer->init();
317            if (sysexDisabled) MidiInputPort::AddSysexListener(this);
318            ResetInternalMutex.Unlock();
319      }      }
320    
321      /**      /**
# Line 200  namespace LinuxSampler { namespace gig { Line 325  namespace LinuxSampler { namespace gig {
325          memset(&ScaleTuning[0], 0x00, 12);          memset(&ScaleTuning[0], 0x00, 12);
326      }      }
327    
328        void Engine::ResetSuspendedRegions() {
329            SuspendedRegions.clear();
330            iPendingStreamDeletions = 0;
331            pPendingRegionSuspension = pPendingRegionResumption = NULL;
332            SuspensionChangeOngoing.Set(false);
333        }
334    
335      /**      /**
336       * Connect this engine instance with the given audio output device.       * Connect this engine instance with the given audio output device.
337       * This method will be called when an Engine instance is created.       * This method will be called when an Engine instance is created.
# Line 220  namespace LinuxSampler { namespace gig { Line 352  namespace LinuxSampler { namespace gig {
352          }          }
353          catch (AudioOutputException e) {          catch (AudioOutputException e) {
354              String msg = "Audio output device unable to provide 2 audio channels, cause: " + e.Message();              String msg = "Audio output device unable to provide 2 audio channels, cause: " + e.Message();
355              throw LinuxSamplerException(msg);              throw Exception(msg);
356          }          }
357    
358          this->MaxSamplesPerCycle = pAudioOutputDevice->MaxSamplesPerCycle();          this->MaxSamplesPerCycle = pAudioOutputDevice->MaxSamplesPerCycle();
359          this->SampleRate         = pAudioOutputDevice->SampleRate();          this->SampleRate         = pAudioOutputDevice->SampleRate();
360    
361          // FIXME: audio drivers with varying fragment sizes might be a problem here          MinFadeOutSamples = int(double(SampleRate) * CONFIG_EG_MIN_RELEASE_TIME) - 1;
362          MaxFadeOutPos = MaxSamplesPerCycle - int(double(SampleRate) * CONFIG_EG_MIN_RELEASE_TIME) - 1;          if (MaxSamplesPerCycle < MinFadeOutSamples) {
         if (MaxFadeOutPos < 0) {  
363              std::cerr << "gig::Engine: WARNING, CONFIG_EG_MIN_RELEASE_TIME "              std::cerr << "gig::Engine: WARNING, CONFIG_EG_MIN_RELEASE_TIME "
364                        << "too big for current audio fragment size & sampling rate! "                        << "too big for current audio fragment size & sampling rate! "
365                        << "May lead to click sounds if voice stealing chimes in!\n" << std::flush;                        << "May lead to click sounds if voice stealing chimes in!\n" << std::flush;
366              // force volume ramp downs at the beginning of each fragment              // force volume ramp downs at the beginning of each fragment
367              MaxFadeOutPos = 0;              MinFadeOutSamples = MaxSamplesPerCycle;
368              // lower minimum release time              // lower minimum release time
369              const float minReleaseTime = (float) MaxSamplesPerCycle / (float) SampleRate;              const float minReleaseTime = (float) MaxSamplesPerCycle / (float) SampleRate;
370              for (RTList<Voice>::Iterator iterVoice = pVoicePool->allocAppend(); iterVoice == pVoicePool->last(); iterVoice = pVoicePool->allocAppend()) {              for (RTList<Voice>::Iterator iterVoice = pVoicePool->allocAppend(); iterVoice == pVoicePool->last(); iterVoice = pVoicePool->allocAppend()) {
# Line 249  namespace LinuxSampler { namespace gig { Line 380  namespace LinuxSampler { namespace gig {
380              delete this->pDiskThread;              delete this->pDiskThread;
381              dmsg(1,("OK\n"));              dmsg(1,("OK\n"));
382          }          }
383          this->pDiskThread = new DiskThread(((pAudioOut->MaxSamplesPerCycle() << CONFIG_MAX_PITCH) << 1) + 6); //FIXME: assuming stereo          this->pDiskThread = new DiskThread(((pAudioOut->MaxSamplesPerCycle() << CONFIG_MAX_PITCH) << 1) + 6, //FIXME: assuming stereo
384                                               &instruments);
385          if (!pDiskThread) {          if (!pDiskThread) {
386              dmsg(0,("gig::Engine  new diskthread = NULL\n"));              dmsg(0,("gig::Engine  new diskthread = NULL\n"));
387              exit(EXIT_FAILURE);              exit(EXIT_FAILURE);
# Line 278  namespace LinuxSampler { namespace gig { Line 410  namespace LinuxSampler { namespace gig {
410      }      }
411    
412      /**      /**
413         * Called by the engine's (audio) thread once per cycle to process requests
414         * from the outer world to suspend or resume a given @c gig::Region .
415         */
416        void Engine::ProcessSuspensionsChanges() {
417            // process request for suspending one region
418            if (pPendingRegionSuspension) {
419                // kill all voices on all engine channels that use this region
420                for (int iChannel = 0; iChannel < engineChannels.size(); iChannel++) {
421                    EngineChannel* pEngineChannel = engineChannels[iChannel];
422                    RTList<uint>::Iterator iuiKey = pEngineChannel->pActiveKeys->first();
423                    RTList<uint>::Iterator end    = pEngineChannel->pActiveKeys->end();
424                    for (; iuiKey != end; ++iuiKey) { // iterate through all active keys
425                        midi_key_info_t* pKey = &pEngineChannel->pMIDIKeyInfo[*iuiKey];
426                        RTList<Voice>::Iterator itVoice = pKey->pActiveVoices->first();
427                        // if current key is not associated with this region, skip this key
428                        if (itVoice->pDimRgn->GetParent() != pPendingRegionSuspension) continue;
429                        RTList<Voice>::Iterator itVoicesEnd = pKey->pActiveVoices->end();
430                        for (; itVoice != itVoicesEnd; ++itVoice) { // iterate through all voices on this key
431                            // request a notification from disk thread side for stream deletion
432                            const Stream::Handle hStream = itVoice->KillImmediately(true);
433                            if (hStream != Stream::INVALID_HANDLE) { // voice actually used a stream
434                                iPendingStreamDeletions++;
435                            }
436                        }
437                    }
438                }
439                // make sure the region is not yet on the list
440                bool bAlreadySuspended = false;
441                RTList< ::gig::Region*>::Iterator iter = SuspendedRegions.first();
442                RTList< ::gig::Region*>::Iterator end  = SuspendedRegions.end();
443                for (; iter != end; ++iter) { // iterate through all suspended regions
444                    if (*iter == pPendingRegionSuspension) { // found
445                        bAlreadySuspended = true;
446                        dmsg(1,("gig::Engine: attempt to suspend an already suspended region !!!\n"));
447                        break;
448                    }
449                }
450                if (!bAlreadySuspended) {
451                    // put the region on the list of suspended regions
452                    RTList< ::gig::Region*>::Iterator iter = SuspendedRegions.allocAppend();
453                    if (iter) {
454                        *iter = pPendingRegionSuspension;
455                    } else std::cerr << "gig::Engine: Could not suspend Region, list is full. This is a bug!!!\n" << std::flush;
456                }
457                // free request slot for next caller (and to make sure that
458                // we're not going to process the same request in the next cycle)
459                pPendingRegionSuspension = NULL;
460                // if no disk stream deletions are pending, awaken other side, as
461                // we're done in this case
462                if (!iPendingStreamDeletions) SuspensionChangeOngoing.Set(false);
463            }
464    
465            // process request for resuming one region
466            if (pPendingRegionResumption) {
467                // remove region from the list of suspended regions
468                RTList< ::gig::Region*>::Iterator iter = SuspendedRegions.first();
469                RTList< ::gig::Region*>::Iterator end  = SuspendedRegions.end();
470                for (; iter != end; ++iter) { // iterate through all suspended regions
471                    if (*iter == pPendingRegionResumption) { // found
472                        SuspendedRegions.free(iter);
473                        break; // done
474                    }
475                }
476                // free request slot for next caller
477                pPendingRegionResumption = NULL;
478                // awake other side as we're done
479                SuspensionChangeOngoing.Set(false);
480            }
481        }
482    
483        /**
484         * Called by the engine's (audio) thread once per cycle to check if
485         * streams of voices that were killed due to suspension request have
486         * finally really been deleted by the disk thread.
487         */
488        void Engine::ProcessPendingStreamDeletions() {
489            if (!iPendingStreamDeletions) return;
490            //TODO: or shall we better store a list with stream handles instead of a scalar amount of streams to be deleted? might be safer
491            while (
492                iPendingStreamDeletions &&
493                pDiskThread->AskForDeletedStream() != Stream::INVALID_HANDLE
494            ) iPendingStreamDeletions--;
495            // just for safety ...
496            while (pDiskThread->AskForDeletedStream() != Stream::INVALID_HANDLE);
497            // now that all disk streams are deleted, awake other side as
498            // we're finally done with suspending the requested region
499            if (!iPendingStreamDeletions) SuspensionChangeOngoing.Set(false);
500        }
501    
502        /**
503         * Returns @c true if the given region is currently set to be suspended
504         * from being used, @c false otherwise.
505         */
506        bool Engine::RegionSuspended(::gig::Region* pRegion) {
507            if (SuspendedRegions.isEmpty()) return false;
508            //TODO: or shall we use a sorted container instead of the RTList? might be faster ... or trivial ;-)
509            RTList< ::gig::Region*>::Iterator iter = SuspendedRegions.first();
510            RTList< ::gig::Region*>::Iterator end  = SuspendedRegions.end();
511            for (; iter != end; ++iter)  // iterate through all suspended regions
512                if (*iter == pRegion) return true;
513            return false;
514        }
515    
516        /**
517       * Clear all engine global event lists.       * Clear all engine global event lists.
518       */       */
519      void Engine::ClearEventLists() {      void Engine::ClearEventLists() {
# Line 298  namespace LinuxSampler { namespace gig { Line 534  namespace LinuxSampler { namespace gig {
534       *                  current audio cycle       *                  current audio cycle
535       */       */
536      void Engine::ImportEvents(uint Samples) {      void Engine::ImportEvents(uint Samples) {
537          RingBuffer<Event>::NonVolatileReader eventQueueReader = pEventQueue->get_non_volatile_reader();          RingBuffer<Event,false>::NonVolatileReader eventQueueReader = pEventQueue->get_non_volatile_reader();
538          Event* pEvent;          Event* pEvent;
539          while (true) {          while (true) {
540              // get next event from input event queue              // get next event from input event queue
# Line 321  namespace LinuxSampler { namespace gig { Line 557  namespace LinuxSampler { namespace gig {
557      }      }
558    
559      /**      /**
560       *  Let this engine proceed to render the given amount of sample points. The       * Let this engine proceed to render the given amount of sample points.
561       *  calculated audio data of all voices of this engine will be placed into       * The engine will iterate through all engine channels and render audio
562       *  the engine's audio sum buffer which has to be copied and eventually be       * for each engine channel independently. The calculated audio data of
563       *  converted to the appropriate value range by the audio output class (e.g.       * all voices of each engine channel will be placed into the audio sum
564       *  AlsaIO or JackIO) right after.       * buffers of the respective audio output device, connected to the
565         * respective engine channel.
566       *       *
567       *  @param Samples - number of sample points to be rendered       *  @param Samples - number of sample points to be rendered
568       *  @returns       0 on success       *  @returns       0 on success
569       */       */
570      int Engine::RenderAudio(uint Samples) {      int Engine::RenderAudio(uint Samples) {
571          dmsg(5,("RenderAudio(Samples=%d)\n", Samples));          dmsg(8,("RenderAudio(Samples=%d)\n", Samples));
572    
573          // return if engine disabled          // return if engine disabled
574          if (EngineDisabled.Pop()) {          if (EngineDisabled.Pop()) {
# Line 339  namespace LinuxSampler { namespace gig { Line 576  namespace LinuxSampler { namespace gig {
576              return 0;              return 0;
577          }          }
578    
579            // process requests for suspending / resuming regions (i.e. to avoid
580            // crashes while these regions are modified by an instrument editor)
581            ProcessSuspensionsChanges();
582    
583          // update time of start and end of this audio fragment (as events' time stamps relate to this)          // update time of start and end of this audio fragment (as events' time stamps relate to this)
584          pEventGenerator->UpdateFragmentTime(Samples);          pEventGenerator->UpdateFragmentTime(Samples);
585    
# Line 368  namespace LinuxSampler { namespace gig { Line 609  namespace LinuxSampler { namespace gig {
609          // reset internal voice counter (just for statistic of active voices)          // reset internal voice counter (just for statistic of active voices)
610          ActiveVoiceCountTemp = 0;          ActiveVoiceCountTemp = 0;
611    
612            // handle instrument change commands
613            bool instrumentChanged = false;
614            for (int i = 0; i < engineChannels.size(); i++) {
615                EngineChannel* pEngineChannel = engineChannels[i];
616    
617                // as we're going to (carefully) write some status to the
618                // synchronized struct, we cast away the const
619                EngineChannel::instrument_change_command_t& cmd =
620                    const_cast<EngineChannel::instrument_change_command_t&>(pEngineChannel->InstrumentChangeCommandReader.Lock());
621    
622                pEngineChannel->pDimRegionsInUse = cmd.pDimRegionsInUse;
623                pEngineChannel->pDimRegionsInUse->clear();
624    
625                if (cmd.bChangeInstrument) {
626                    // change instrument
627                    dmsg(5,("Engine: instrument change command received\n"));
628                    cmd.bChangeInstrument = false;
629                    pEngineChannel->pInstrument = cmd.pInstrument;
630                    instrumentChanged = true;
631    
632                    // Iterate through all active voices and mark them as
633                    // "orphans", which means that the dimension regions
634                    // and samples they use should be released to the
635                    // instrument resource manager when the voices die.
636                    int i = 0;
637                    RTList<uint>::Iterator iuiKey = pEngineChannel->pActiveKeys->first();
638                    RTList<uint>::Iterator end    = pEngineChannel->pActiveKeys->end();
639                    while (iuiKey != end) { // iterate through all active keys
640                        midi_key_info_t* pKey = &pEngineChannel->pMIDIKeyInfo[*iuiKey];
641                        ++iuiKey;
642    
643                        RTList<Voice>::Iterator itVoice     = pKey->pActiveVoices->first();
644                        RTList<Voice>::Iterator itVoicesEnd = pKey->pActiveVoices->end();
645                        for (; itVoice != itVoicesEnd; ++itVoice) { // iterate through all voices on this key
646                            itVoice->Orphan = true;
647                        }
648                    }
649                }
650            }
651            if (instrumentChanged) {
652                //TODO: this is a lazy solution ATM and not safe in case somebody is currently editing the instrument we're currently switching to (we should store all suspended regions on instrument manager side and when switching to another instrument copy that list to the engine's local list of suspensions
653                ResetSuspendedRegions();
654            }
655    
656          // handle events on all engine channels          // handle events on all engine channels
657          for (int i = 0; i < engineChannels.size(); i++) {          for (int i = 0; i < engineChannels.size(); i++) {
             if (!engineChannels[i]->pInstrument) continue; // ignore if no instrument loaded  
658              ProcessEvents(engineChannels[i], Samples);              ProcessEvents(engineChannels[i], Samples);
659          }          }
660    
661          // render all 'normal', active voices on all engine channels          // render all 'normal', active voices on all engine channels
662          for (int i = 0; i < engineChannels.size(); i++) {          for (int i = 0; i < engineChannels.size(); i++) {
             if (!engineChannels[i]->pInstrument) continue; // ignore if no instrument loaded  
663              RenderActiveVoices(engineChannels[i], Samples);              RenderActiveVoices(engineChannels[i], Samples);
664          }          }
665    
666          // now that all ordinary voices on ALL engine channels are rendered, render new stolen voices          // now that all ordinary voices on ALL engine channels are rendered, render new stolen voices
667          RenderStolenVoices(Samples);          RenderStolenVoices(Samples);
668    
669            // handle audio routing for engine channels with FX sends
670            for (int i = 0; i < engineChannels.size(); i++) {
671                if (engineChannels[i]->fxSends.empty()) continue; // ignore if no FX sends
672                RouteAudio(engineChannels[i], Samples);
673            }
674    
675          // handle cleanup on all engine channels for the next audio fragment          // handle cleanup on all engine channels for the next audio fragment
676          for (int i = 0; i < engineChannels.size(); i++) {          for (int i = 0; i < engineChannels.size(); i++) {
             if (!engineChannels[i]->pInstrument) continue; // ignore if no instrument loaded  
677              PostProcess(engineChannels[i]);              PostProcess(engineChannels[i]);
678          }          }
679    
# Line 400  namespace LinuxSampler { namespace gig { Line 688  namespace LinuxSampler { namespace gig {
688          ActiveVoiceCount = ActiveVoiceCountTemp;          ActiveVoiceCount = ActiveVoiceCountTemp;
689          if (ActiveVoiceCount > ActiveVoiceCountMax) ActiveVoiceCountMax = ActiveVoiceCount;          if (ActiveVoiceCount > ActiveVoiceCountMax) ActiveVoiceCountMax = ActiveVoiceCount;
690    
691            // in case regions were previously suspended and we killed voices
692            // with disk streams due to that, check if those streams have finally
693            // been deleted by the disk thread
694            if (iPendingStreamDeletions) ProcessPendingStreamDeletions();
695    
696            for (int i = 0; i < engineChannels.size(); i++) {
697                engineChannels[i]->InstrumentChangeCommandReader.Unlock();
698            }
699          FrameTime += Samples;          FrameTime += Samples;
700    
701          return 0;          return 0;
# Line 467  namespace LinuxSampler { namespace gig { Line 763  namespace LinuxSampler { namespace gig {
763          if (pEngineChannel->GetMute()) return; // skip if sampler channel is muted          if (pEngineChannel->GetMute()) return; // skip if sampler channel is muted
764          #endif          #endif
765    
766            uint voiceCount = 0;
767            uint streamCount = 0;
768          RTList<uint>::Iterator iuiKey = pEngineChannel->pActiveKeys->first();          RTList<uint>::Iterator iuiKey = pEngineChannel->pActiveKeys->first();
769          RTList<uint>::Iterator end    = pEngineChannel->pActiveKeys->end();          RTList<uint>::Iterator end    = pEngineChannel->pActiveKeys->end();
770          while (iuiKey != end) { // iterate through all active keys          while (iuiKey != end) { // iterate through all active keys
# Line 478  namespace LinuxSampler { namespace gig { Line 776  namespace LinuxSampler { namespace gig {
776              for (; itVoice != itVoicesEnd; ++itVoice) { // iterate through all voices on this key              for (; itVoice != itVoicesEnd; ++itVoice) { // iterate through all voices on this key
777                  // now render current voice                  // now render current voice
778                  itVoice->Render(Samples);                  itVoice->Render(Samples);
779                  if (itVoice->IsActive()) ActiveVoiceCountTemp++; // still active                  if (itVoice->IsActive()) { // still active
780                  else { // voice reached end, is now inactive                      if (!itVoice->Orphan) {
781                            *(pEngineChannel->pDimRegionsInUse->allocAppend()) = itVoice->pDimRgn;
782                        }
783                        ActiveVoiceCountTemp++;
784                        voiceCount++;
785    
786                        if (itVoice->PlaybackState == Voice::playback_state_disk) {
787                            if ((itVoice->DiskStreamRef).State == Stream::state_active) streamCount++;
788                        }
789                    }  else { // voice reached end, is now inactive
790                      FreeVoice(pEngineChannel, itVoice); // remove voice from the list of active voices                      FreeVoice(pEngineChannel, itVoice); // remove voice from the list of active voices
791                  }                  }
792              }              }
793          }          }
794    
795            pEngineChannel->SetVoiceCount(voiceCount);
796            pEngineChannel->SetDiskStreamCount(streamCount);
797      }      }
798    
799      /**      /**
# Line 504  namespace LinuxSampler { namespace gig { Line 814  namespace LinuxSampler { namespace gig {
814          RTList<Event>::Iterator end               = pVoiceStealingQueue->end();          RTList<Event>::Iterator end               = pVoiceStealingQueue->end();
815          for (; itVoiceStealEvent != end; ++itVoiceStealEvent) {          for (; itVoiceStealEvent != end; ++itVoiceStealEvent) {
816              EngineChannel* pEngineChannel = (EngineChannel*) itVoiceStealEvent->pEngineChannel;              EngineChannel* pEngineChannel = (EngineChannel*) itVoiceStealEvent->pEngineChannel;
817                if (!pEngineChannel->pInstrument) continue; // ignore if no instrument loaded
818              Pool<Voice>::Iterator itNewVoice =              Pool<Voice>::Iterator itNewVoice =
819                  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);
820              if (itNewVoice) {              if (itNewVoice) {
821                  itNewVoice->Render(Samples);                  itNewVoice->Render(Samples);
822                  if (itNewVoice->IsActive()) ActiveVoiceCountTemp++; // still active                  if (itNewVoice->IsActive()) { // still active
823                  else { // voice reached end, is now inactive                      *(pEngineChannel->pDimRegionsInUse->allocAppend()) = itNewVoice->pDimRgn;
824                        ActiveVoiceCountTemp++;
825                        pEngineChannel->SetVoiceCount(pEngineChannel->GetVoiceCount() + 1);
826    
827                        if (itNewVoice->PlaybackState == Voice::playback_state_disk) {
828                            if (itNewVoice->DiskStreamRef.State == Stream::state_active) {
829                                pEngineChannel->SetDiskStreamCount(pEngineChannel->GetDiskStreamCount() + 1);
830                            }
831                        }
832                    } else { // voice reached end, is now inactive
833                      FreeVoice(pEngineChannel, itNewVoice); // remove voice from the list of active voices                      FreeVoice(pEngineChannel, itNewVoice); // remove voice from the list of active voices
834                  }                  }
835              }              }
# Line 523  namespace LinuxSampler { namespace gig { Line 843  namespace LinuxSampler { namespace gig {
843      }      }
844    
845      /**      /**
846         * Will be called in case the respective engine channel sports FX send
847         * channels. In this particular case, engine channel local buffers are
848         * used to render and mix all voices to. This method is responsible for
849         * copying the audio data from those local buffers to the master audio
850         * output channels as well as to the FX send audio output channels with
851         * their respective FX send levels.
852         *
853         * @param pEngineChannel - engine channel from which audio should be
854         *                         routed
855         * @param Samples        - amount of sample points to be routed in
856         *                         this audio fragment cycle
857         */
858        void Engine::RouteAudio(EngineChannel* pEngineChannel, uint Samples) {
859            // route dry signal
860            {
861                AudioChannel* pDstL = pAudioOutputDevice->Channel(pEngineChannel->AudioDeviceChannelLeft);
862                AudioChannel* pDstR = pAudioOutputDevice->Channel(pEngineChannel->AudioDeviceChannelRight);
863                pEngineChannel->pChannelLeft->MixTo(pDstL, Samples);
864                pEngineChannel->pChannelRight->MixTo(pDstR, Samples);
865            }
866            // route FX send signal
867            {
868                for (int iFxSend = 0; iFxSend < pEngineChannel->GetFxSendCount(); iFxSend++) {
869                    FxSend* pFxSend = pEngineChannel->GetFxSend(iFxSend);
870                    for (int iChan = 0; iChan < 2; ++iChan) {
871                        AudioChannel* pSource =
872                            (iChan)
873                                ? pEngineChannel->pChannelRight
874                                : pEngineChannel->pChannelLeft;
875                        const int iDstChan = pFxSend->DestinationChannel(iChan);
876                        if (iDstChan < 0) {
877                            dmsg(1,("Engine::RouteAudio() Error: invalid FX send (%s) destination channel (%d->%d)", ((iChan) ? "R" : "L"), iChan, iDstChan));
878                            goto channel_cleanup;
879                        }
880                        AudioChannel* pDstChan = NULL;
881                        if (pFxSend->DestinationMasterEffectChain() >= 0) { // fx send routed to an internal master effect
882                            EffectChain* pEffectChain =
883                                pAudioOutputDevice->MasterEffectChain(
884                                    pFxSend->DestinationMasterEffectChain()
885                                );
886                            if (!pEffectChain) {
887                                dmsg(1,("Engine::RouteAudio() Error: invalid FX send (%s) destination effect chain %d", ((iChan) ? "R" : "L"), pFxSend->DestinationMasterEffectChain()));
888                                goto channel_cleanup;
889                            }
890                            Effect* pEffect =
891                                pEffectChain->GetEffect(
892                                    pFxSend->DestinationMasterEffect()
893                                );
894                            if (!pEffect) {
895                                dmsg(1,("Engine::RouteAudio() Error: invalid FX send (%s) destination effect %d of effect chain %d", ((iChan) ? "R" : "L"), pFxSend->DestinationMasterEffect(), pFxSend->DestinationMasterEffectChain()));
896                                goto channel_cleanup;
897                            }
898                            pDstChan = pEffect->InputChannel(iDstChan);
899                        } else { // FX send routed directly to an audio output channel
900                            pDstChan = pAudioOutputDevice->Channel(iDstChan);
901                        }
902                        if (!pDstChan) {
903                            dmsg(1,("Engine::RouteAudio() Error: invalid FX send (%s) destination channel (%d->%d)", ((iChan) ? "R" : "L"), iChan, iDstChan));
904                            goto channel_cleanup;
905                        }
906                        pSource->MixTo(pDstChan, Samples, pFxSend->Level());
907                    }
908                }
909            }
910            channel_cleanup:
911            // reset buffers with silence (zero out) for the next audio cycle
912            pEngineChannel->pChannelLeft->Clear();
913            pEngineChannel->pChannelRight->Clear();
914        }
915    
916        /**
917       * Free all keys which have turned inactive in this audio fragment, from       * Free all keys which have turned inactive in this audio fragment, from
918       * the list of active keys and clear all event lists on that engine       * the list of active keys and clear all event lists on that engine
919       * channel.       * channel.
# Line 599  namespace LinuxSampler { namespace gig { Line 990  namespace LinuxSampler { namespace gig {
990          if (pEngineChannel->GetMute()) return; // skip if sampler channel is muted          if (pEngineChannel->GetMute()) return; // skip if sampler channel is muted
991          #endif          #endif
992    
993            if (!pEngineChannel->pInstrument) return; // ignore if no instrument loaded
994    
995            //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
996            itNoteOnEvent->Param.Note.Key += pEngineChannel->GlobalTranspose;
997    
998          const int key = itNoteOnEvent->Param.Note.Key;          const int key = itNoteOnEvent->Param.Note.Key;
999            midi_key_info_t* pKey = &pEngineChannel->pMIDIKeyInfo[key];
1000    
1001            // move note on event to the key's own event list
1002            RTList<Event>::Iterator itNoteOnEventOnKeyList = itNoteOnEvent.moveToEndOf(pKey->pEvents);
1003    
1004            // if Solo Mode then kill all already active voices
1005            if (pEngineChannel->SoloMode) {
1006                Pool<uint>::Iterator itYoungestKey = pEngineChannel->pActiveKeys->last();
1007                if (itYoungestKey) {
1008                    const int iYoungestKey = *itYoungestKey;
1009                    const midi_key_info_t* pOtherKey = &pEngineChannel->pMIDIKeyInfo[iYoungestKey];
1010                    if (pOtherKey->Active) {
1011                        // get final portamento position of currently active voice
1012                        if (pEngineChannel->PortamentoMode) {
1013                            RTList<Voice>::Iterator itVoice = pOtherKey->pActiveVoices->last();
1014                            if (itVoice) itVoice->UpdatePortamentoPos(itNoteOnEventOnKeyList);
1015                        }
1016                        // kill all voices on the (other) key
1017                        RTList<Voice>::Iterator itVoiceToBeKilled = pOtherKey->pActiveVoices->first();
1018                        RTList<Voice>::Iterator end               = pOtherKey->pActiveVoices->end();
1019                        for (; itVoiceToBeKilled != end; ++itVoiceToBeKilled) {
1020                            if (itVoiceToBeKilled->Type != Voice::type_release_trigger)
1021                                itVoiceToBeKilled->Kill(itNoteOnEventOnKeyList);
1022                        }
1023                    }
1024                }
1025                // set this key as 'currently active solo key'
1026                pEngineChannel->SoloKey = key;
1027            }
1028    
1029          // Change key dimension value if key is in keyswitching area          // Change key dimension value if key is in keyswitching area
1030          {          {
1031              const ::gig::Instrument* pInstrument = pEngineChannel->pInstrument;              const ::gig::Instrument* pInstrument = pEngineChannel->pInstrument;
1032              if (key >= pInstrument->DimensionKeyRange.low && key <= pInstrument->DimensionKeyRange.high)              if (key >= pInstrument->DimensionKeyRange.low && key <= pInstrument->DimensionKeyRange.high)
1033                  pEngineChannel->CurrentKeyDimension = ((key - pInstrument->DimensionKeyRange.low) * 128) /                  pEngineChannel->CurrentKeyDimension = float(key - pInstrument->DimensionKeyRange.low) /
1034                      (pInstrument->DimensionKeyRange.high - pInstrument->DimensionKeyRange.low + 1);                      (pInstrument->DimensionKeyRange.high - pInstrument->DimensionKeyRange.low + 1);
1035          }          }
1036    
         midi_key_info_t* pKey = &pEngineChannel->pMIDIKeyInfo[key];  
   
1037          pKey->KeyPressed = true; // the MIDI key was now pressed down          pKey->KeyPressed = true; // the MIDI key was now pressed down
1038          pKey->Velocity   = itNoteOnEvent->Param.Note.Velocity;          pKey->Velocity   = itNoteOnEventOnKeyList->Param.Note.Velocity;
1039          pKey->NoteOnTime = FrameTime + itNoteOnEvent->FragmentPos(); // will be used to calculate note length          pKey->NoteOnTime = FrameTime + itNoteOnEventOnKeyList->FragmentPos(); // will be used to calculate note length
1040    
1041          // cancel release process of voices on this key if needed          // cancel release process of voices on this key if needed
1042          if (pKey->Active && !pEngineChannel->SustainPedal) {          if (pKey->Active && !pEngineChannel->SustainPedal) {
1043              RTList<Event>::Iterator itCancelReleaseEvent = pKey->pEvents->allocAppend();              RTList<Event>::Iterator itCancelReleaseEvent = pKey->pEvents->allocAppend();
1044              if (itCancelReleaseEvent) {              if (itCancelReleaseEvent) {
1045                  *itCancelReleaseEvent = *itNoteOnEvent;                  // copy event                  *itCancelReleaseEvent = *itNoteOnEventOnKeyList;         // copy event
1046                  itCancelReleaseEvent->Type = Event::type_cancel_release; // transform event type                  itCancelReleaseEvent->Type = Event::type_cancel_release; // transform event type
1047              }              }
1048              else dmsg(1,("Event pool emtpy!\n"));              else dmsg(1,("Event pool emtpy!\n"));
1049          }          }
1050    
         // move note on event to the key's own event list  
         RTList<Event>::Iterator itNoteOnEventOnKeyList = itNoteOnEvent.moveToEndOf(pKey->pEvents);  
   
1051          // allocate and trigger new voice(s) for the key          // allocate and trigger new voice(s) for the key
1052          {          {
1053              // first, get total amount of required voices (dependant on amount of layers)              // first, get total amount of required voices (dependant on amount of layers)
1054              ::gig::Region* pRegion = pEngineChannel->pInstrument->GetRegion(itNoteOnEventOnKeyList->Param.Note.Key);              ::gig::Region* pRegion = pEngineChannel->pInstrument->GetRegion(itNoteOnEventOnKeyList->Param.Note.Key);
1055              if (pRegion) {              if (pRegion && !RegionSuspended(pRegion)) {
1056                  int voicesRequired = pRegion->Layers;                  int voicesRequired = pRegion->Layers;
1057                  // now launch the required amount of voices                  // now launch the required amount of voices
1058                  for (int i = 0; i < voicesRequired; i++)                  for (int i = 0; i < voicesRequired; i++)
# Line 644  namespace LinuxSampler { namespace gig { Line 1064  namespace LinuxSampler { namespace gig {
1064          if (!pKey->Active && !pKey->VoiceTheftsQueued)          if (!pKey->Active && !pKey->VoiceTheftsQueued)
1065              pKey->pEvents->free(itNoteOnEventOnKeyList);              pKey->pEvents->free(itNoteOnEventOnKeyList);
1066    
1067            if (!pEngineChannel->SoloMode || pEngineChannel->PortamentoPos < 0.0f) pEngineChannel->PortamentoPos = (float) key;
1068          pKey->RoundRobinIndex++;          pKey->RoundRobinIndex++;
1069      }      }
1070    
# Line 661  namespace LinuxSampler { namespace gig { Line 1082  namespace LinuxSampler { namespace gig {
1082          if (pEngineChannel->GetMute()) return; // skip if sampler channel is muted          if (pEngineChannel->GetMute()) return; // skip if sampler channel is muted
1083          #endif          #endif
1084    
1085          midi_key_info_t* pKey = &pEngineChannel->pMIDIKeyInfo[itNoteOffEvent->Param.Note.Key];          //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
1086            itNoteOffEvent->Param.Note.Key += pEngineChannel->GlobalTranspose;
1087    
1088            const int iKey = itNoteOffEvent->Param.Note.Key;
1089            midi_key_info_t* pKey = &pEngineChannel->pMIDIKeyInfo[iKey];
1090          pKey->KeyPressed = false; // the MIDI key was now released          pKey->KeyPressed = false; // the MIDI key was now released
1091    
1092          // release voices on this key if needed          // move event to the key's own event list
1093          if (pKey->Active && ShouldReleaseVoice(pEngineChannel, itNoteOffEvent->Param.Note.Key)) {          RTList<Event>::Iterator itNoteOffEventOnKeyList = itNoteOffEvent.moveToEndOf(pKey->pEvents);
1094              itNoteOffEvent->Type = Event::type_release; // transform event type  
1095            bool bShouldRelease = pKey->Active && ShouldReleaseVoice(pEngineChannel, itNoteOffEventOnKeyList->Param.Note.Key);
1096    
1097            // in case Solo Mode is enabled, kill all voices on this key and respawn a voice on the highest pressed key (if any)
1098            if (pEngineChannel->SoloMode && pEngineChannel->pInstrument) { //TODO: this feels like too much code just for handling solo mode :P
1099                bool bOtherKeysPressed = false;
1100                if (iKey == pEngineChannel->SoloKey) {
1101                    pEngineChannel->SoloKey = -1;
1102                    // if there's still a key pressed down, respawn a voice (group) on the highest key
1103                    for (int i = 127; i > 0; i--) {
1104                        midi_key_info_t* pOtherKey = &pEngineChannel->pMIDIKeyInfo[i];
1105                        if (pOtherKey->KeyPressed) {
1106                            bOtherKeysPressed = true;
1107                            // make the other key the new 'currently active solo key'
1108                            pEngineChannel->SoloKey = i;
1109                            // get final portamento position of currently active voice
1110                            if (pEngineChannel->PortamentoMode) {
1111                                RTList<Voice>::Iterator itVoice = pKey->pActiveVoices->first();
1112                                if (itVoice) itVoice->UpdatePortamentoPos(itNoteOffEventOnKeyList);
1113                            }
1114                            // create a pseudo note on event
1115                            RTList<Event>::Iterator itPseudoNoteOnEvent = pOtherKey->pEvents->allocAppend();
1116                            if (itPseudoNoteOnEvent) {
1117                                // copy event
1118                                *itPseudoNoteOnEvent = *itNoteOffEventOnKeyList;
1119                                // transform event to a note on event
1120                                itPseudoNoteOnEvent->Type                = Event::type_note_on;
1121                                itPseudoNoteOnEvent->Param.Note.Key      = i;
1122                                itPseudoNoteOnEvent->Param.Note.Velocity = pOtherKey->Velocity;
1123                                // allocate and trigger new voice(s) for the other key
1124                                {
1125                                    // first, get total amount of required voices (dependant on amount of layers)
1126                                    ::gig::Region* pRegion = pEngineChannel->pInstrument->GetRegion(i);
1127                                    if (pRegion) {
1128                                        int voicesRequired = pRegion->Layers;
1129                                        // now launch the required amount of voices
1130                                        for (int iLayer = 0; iLayer < voicesRequired; iLayer++)
1131                                            LaunchVoice(pEngineChannel, itPseudoNoteOnEvent, iLayer, false, true, false);
1132                                    }
1133                                }
1134                                // if neither a voice was spawned or postponed then remove note on event from key again
1135                                if (!pOtherKey->Active && !pOtherKey->VoiceTheftsQueued)
1136                                    pOtherKey->pEvents->free(itPseudoNoteOnEvent);
1137    
1138                            } else dmsg(1,("Could not respawn voice, no free event left\n"));
1139                            break; // done
1140                        }
1141                    }
1142                }
1143                if (bOtherKeysPressed) {
1144                    if (pKey->Active) { // kill all voices on this key
1145                        bShouldRelease = false; // no need to release, as we kill it here
1146                        RTList<Voice>::Iterator itVoiceToBeKilled = pKey->pActiveVoices->first();
1147                        RTList<Voice>::Iterator end               = pKey->pActiveVoices->end();
1148                        for (; itVoiceToBeKilled != end; ++itVoiceToBeKilled) {
1149                            if (itVoiceToBeKilled->Type != Voice::type_release_trigger)
1150                                itVoiceToBeKilled->Kill(itNoteOffEventOnKeyList);
1151                        }
1152                    }
1153                } else pEngineChannel->PortamentoPos = -1.0f;
1154            }
1155    
1156              // move event to the key's own event list          // if no solo mode (the usual case) or if solo mode and no other key pressed, then release voices on this key if needed
1157              RTList<Event>::Iterator itNoteOffEventOnKeyList = itNoteOffEvent.moveToEndOf(pKey->pEvents);          if (bShouldRelease) {
1158                itNoteOffEventOnKeyList->Type = Event::type_release; // transform event type
1159    
1160              // spawn release triggered voice(s) if needed              // spawn release triggered voice(s) if needed
1161              if (pKey->ReleaseTrigger) {              if (pKey->ReleaseTrigger && pEngineChannel->pInstrument) {
1162                  // first, get total amount of required voices (dependant on amount of layers)                  // first, get total amount of required voices (dependant on amount of layers)
1163                  ::gig::Region* pRegion = pEngineChannel->pInstrument->GetRegion(itNoteOffEventOnKeyList->Param.Note.Key);                  ::gig::Region* pRegion = pEngineChannel->pInstrument->GetRegion(itNoteOffEventOnKeyList->Param.Note.Key);
1164                  if (pRegion) {                  if (pRegion) {
# Line 687  namespace LinuxSampler { namespace gig { Line 1173  namespace LinuxSampler { namespace gig {
1173                  }                  }
1174                  pKey->ReleaseTrigger = false;                  pKey->ReleaseTrigger = false;
1175              }              }
   
             // if neither a voice was spawned or postponed then remove note off event from key again  
             if (!pKey->Active && !pKey->VoiceTheftsQueued)  
                 pKey->pEvents->free(itNoteOffEventOnKeyList);  
1176          }          }
1177    
1178            // if neither a voice was spawned or postponed on this key then remove note off event from key again
1179            if (!pKey->Active && !pKey->VoiceTheftsQueued)
1180                pKey->pEvents->free(itNoteOffEventOnKeyList);
1181      }      }
1182    
1183      /**      /**
# Line 775  namespace LinuxSampler { namespace gig { Line 1261  namespace LinuxSampler { namespace gig {
1261                      DimValues[i] = itNoteOnEvent->Param.Note.Velocity;                      DimValues[i] = itNoteOnEvent->Param.Note.Velocity;
1262                      break;                      break;
1263                  case ::gig::dimension_channelaftertouch:                  case ::gig::dimension_channelaftertouch:
1264                      DimValues[i] = 0; //TODO: we currently ignore this dimension                      DimValues[i] = pEngineChannel->ControllerTable[128];
1265                      break;                      break;
1266                  case ::gig::dimension_releasetrigger:                  case ::gig::dimension_releasetrigger:
1267                      VoiceType = (ReleaseTriggerVoice) ? Voice::type_release_trigger : (!iLayer) ? Voice::type_release_trigger_required : Voice::type_normal;                      VoiceType = (ReleaseTriggerVoice) ? Voice::type_release_trigger : (!iLayer) ? Voice::type_release_trigger_required : Voice::type_normal;
1268                      DimValues[i] = (uint) ReleaseTriggerVoice;                      DimValues[i] = (uint) ReleaseTriggerVoice;
1269                      break;                      break;
1270                  case ::gig::dimension_keyboard:                  case ::gig::dimension_keyboard:
1271                      DimValues[i] = (uint) pEngineChannel->CurrentKeyDimension;                      DimValues[i] = (uint) (pEngineChannel->CurrentKeyDimension * pRegion->pDimensionDefinitions[i].zones);
1272                      break;                      break;
1273                  case ::gig::dimension_roundrobin:                  case ::gig::dimension_roundrobin:
1274                      DimValues[i] = (uint) pEngineChannel->pMIDIKeyInfo[MIDIKey].RoundRobinIndex; // incremented for each note on                      DimValues[i] = (uint) pEngineChannel->pMIDIKeyInfo[MIDIKey].RoundRobinIndex; // incremented for each note on
# Line 867  namespace LinuxSampler { namespace gig { Line 1353  namespace LinuxSampler { namespace gig {
1353                      std::cerr << "gig::Engine::LaunchVoice() Error: Unknown dimension\n" << std::flush;                      std::cerr << "gig::Engine::LaunchVoice() Error: Unknown dimension\n" << std::flush;
1354              }              }
1355          }          }
1356    
1357            // return if this is a release triggered voice and there is no
1358            // releasetrigger dimension (could happen if an instrument
1359            // change has occured between note on and off)
1360            if (ReleaseTriggerVoice && VoiceType != Voice::type_release_trigger) return Pool<Voice>::Iterator();
1361    
1362          ::gig::DimensionRegion* pDimRgn = pRegion->GetDimensionRegionByValue(DimValues);          ::gig::DimensionRegion* pDimRgn = pRegion->GetDimensionRegionByValue(DimValues);
1363    
1364          // no need to continue if sample is silent          // no need to continue if sample is silent
# Line 1096  namespace LinuxSampler { namespace gig { Line 1588  namespace LinuxSampler { namespace gig {
1588    
1589              uint keygroup = itVoice->KeyGroup;              uint keygroup = itVoice->KeyGroup;
1590    
1591                // if the sample and dimension region belong to an
1592                // instrument that is unloaded, tell the disk thread to
1593                // release them
1594                if (itVoice->Orphan) {
1595                    pDiskThread->OrderDeletionOfDimreg(itVoice->pDimRgn);
1596                }
1597    
1598              // free the voice object              // free the voice object
1599              pVoicePool->free(itVoice);              pVoicePool->free(itVoice);
1600    
# Line 1137  namespace LinuxSampler { namespace gig { Line 1636  namespace LinuxSampler { namespace gig {
1636      void Engine::ProcessControlChange(EngineChannel* pEngineChannel, Pool<Event>::Iterator& itControlChangeEvent) {      void Engine::ProcessControlChange(EngineChannel* pEngineChannel, Pool<Event>::Iterator& itControlChangeEvent) {
1637          dmsg(4,("Engine::ContinuousController cc=%d v=%d\n", itControlChangeEvent->Param.CC.Controller, itControlChangeEvent->Param.CC.Value));          dmsg(4,("Engine::ContinuousController cc=%d v=%d\n", itControlChangeEvent->Param.CC.Controller, itControlChangeEvent->Param.CC.Value));
1638    
1639            // handle the "control triggered" MIDI rule: a control change
1640            // event can trigger a new note on or note off event
1641            if (pEngineChannel->pInstrument) {
1642    
1643                ::gig::MidiRule* rule;
1644                for (int i = 0 ; (rule = pEngineChannel->pInstrument->GetMidiRule(i)) ; i++) {
1645    
1646                    if (::gig::MidiRuleCtrlTrigger* ctrlTrigger =
1647                        dynamic_cast< ::gig::MidiRuleCtrlTrigger*>(rule)) {
1648                        if (itControlChangeEvent->Param.CC.Controller ==
1649                            ctrlTrigger->ControllerNumber) {
1650    
1651                            uint8_t oldCCValue = pEngineChannel->ControllerTable[
1652                                itControlChangeEvent->Param.CC.Controller];
1653                            uint8_t newCCValue = itControlChangeEvent->Param.CC.Value;
1654    
1655                            for (int i = 0 ; i < ctrlTrigger->Triggers ; i++) {
1656                                ::gig::MidiRuleCtrlTrigger::trigger_t* pTrigger =
1657                                      &ctrlTrigger->pTriggers[i];
1658    
1659                                // check if the controller has passed the
1660                                // trigger point in the right direction
1661                                if ((pTrigger->Descending &&
1662                                     oldCCValue > pTrigger->TriggerPoint &&
1663                                     newCCValue <= pTrigger->TriggerPoint) ||
1664                                    (!pTrigger->Descending &&
1665                                     oldCCValue < pTrigger->TriggerPoint &&
1666                                     newCCValue >= pTrigger->TriggerPoint)) {
1667    
1668                                    RTList<Event>::Iterator itNewEvent = pGlobalEvents->allocAppend();
1669                                    if (itNewEvent) {
1670                                        *itNewEvent = *itControlChangeEvent;
1671                                        itNewEvent->Param.Note.Key = pTrigger->Key;
1672    
1673                                        if (pTrigger->NoteOff || pTrigger->Velocity == 0) {
1674                                            itNewEvent->Type = Event::type_note_off;
1675                                            itNewEvent->Param.Note.Velocity = 100;
1676    
1677                                            ProcessNoteOff(pEngineChannel, itNewEvent);
1678                                        } else {
1679                                            itNewEvent->Type = Event::type_note_on;
1680                                            //TODO: if Velocity is 255, the triggered velocity should
1681                                            // depend on how fast the controller is moving
1682                                            itNewEvent->Param.Note.Velocity =
1683                                                pTrigger->Velocity == 255 ? 100 :
1684                                                pTrigger->Velocity;
1685    
1686                                            ProcessNoteOn(pEngineChannel, itNewEvent);
1687                                        }
1688                                    }
1689                                    else dmsg(1,("Event pool emtpy!\n"));
1690                                }
1691                            }
1692                        }
1693                    }
1694                }
1695            }
1696    
1697          // update controller value in the engine channel's controller table          // update controller value in the engine channel's controller table
1698          pEngineChannel->ControllerTable[itControlChangeEvent->Param.CC.Controller] = itControlChangeEvent->Param.CC.Value;          pEngineChannel->ControllerTable[itControlChangeEvent->Param.CC.Controller] = itControlChangeEvent->Param.CC.Value;
1699    
1700            // handle hard coded MIDI controllers
1701          switch (itControlChangeEvent->Param.CC.Controller) {          switch (itControlChangeEvent->Param.CC.Controller) {
1702                case 5: { // portamento time
1703                    pEngineChannel->PortamentoTime = (float) itControlChangeEvent->Param.CC.Value / 127.0f * (float) CONFIG_PORTAMENTO_TIME_MAX + (float) CONFIG_PORTAMENTO_TIME_MIN;
1704                    break;
1705                }
1706                case 6: { // data entry (currently only used for RPN controllers)
1707                    if (pEngineChannel->GetMidiRpnController() == 2) { // coarse tuning in half tones
1708                        int transpose = (int) itControlChangeEvent->Param.CC.Value - 64;
1709                        // limit to +- two octaves for now
1710                        transpose = RTMath::Min(transpose,  24);
1711                        transpose = RTMath::Max(transpose, -24);
1712                        pEngineChannel->GlobalTranspose = transpose;
1713                        // workaround, so we won't have hanging notes
1714                        ReleaseAllVoices(pEngineChannel, itControlChangeEvent);
1715                    }
1716                    // to avoid other MIDI CC #6 messages to be misenterpreted as RPN controller data
1717                    pEngineChannel->ResetMidiRpnController();
1718                    break;
1719                }
1720              case 7: { // volume              case 7: { // volume
1721                  //TODO: not sample accurate yet                  //TODO: not sample accurate yet
1722                  pEngineChannel->GlobalVolume = (float) itControlChangeEvent->Param.CC.Value / 127.0f *  CONFIG_GLOBAL_ATTENUATION;                  pEngineChannel->MidiVolume = VolumeCurve[itControlChangeEvent->Param.CC.Value];
1723                  pEngineChannel->bStatusChanged = true; // engine channel status has changed, so set notify flag                  pEngineChannel->bStatusChanged = true; // engine channel status has changed, so set notify flag
1724                  break;                  break;
1725              }              }
1726              case 10: { // panpot              case 10: { // panpot
1727                  //TODO: not sample accurate yet                  //TODO: not sample accurate yet
1728                  const int pan = (int) itControlChangeEvent->Param.CC.Value - 64;                  pEngineChannel->GlobalPanLeft  = PanCurve[128 - itControlChangeEvent->Param.CC.Value];
1729                  pEngineChannel->GlobalPanLeft  = 1.0f - float(RTMath::Max(pan, 0)) /  63.0f;                  pEngineChannel->GlobalPanRight = PanCurve[itControlChangeEvent->Param.CC.Value];
1730                  pEngineChannel->GlobalPanRight = 1.0f - float(RTMath::Min(pan, 0)) / -64.0f;                  pEngineChannel->iLastPanRequest = itControlChangeEvent->Param.CC.Value;
1731                  break;                  break;
1732              }              }
1733              case 64: { // sustain              case 64: { // sustain
# Line 1201  namespace LinuxSampler { namespace gig { Line 1777  namespace LinuxSampler { namespace gig {
1777                  }                  }
1778                  break;                  break;
1779              }              }
1780                case 65: { // portamento on / off
1781                    const bool bPortamento = itControlChangeEvent->Param.CC.Value >= 64;
1782                    if (bPortamento != pEngineChannel->PortamentoMode)
1783                        KillAllVoices(pEngineChannel, itControlChangeEvent);
1784                    pEngineChannel->PortamentoMode = bPortamento;
1785                    break;
1786                }
1787              case 66: { // sostenuto              case 66: { // sostenuto
1788                  if (itControlChangeEvent->Param.CC.Value >= 64 && !pEngineChannel->SostenutoPedal) {                  if (itControlChangeEvent->Param.CC.Value >= 64 && !pEngineChannel->SostenutoPedal) {
1789                      dmsg(4,("SOSTENUTO (CENTER) PEDAL DOWN\n"));                      dmsg(4,("SOSTENUTO (CENTER) PEDAL DOWN\n"));
# Line 1241  namespace LinuxSampler { namespace gig { Line 1824  namespace LinuxSampler { namespace gig {
1824                  }                  }
1825                  break;                  break;
1826              }              }
1827                case 100: { // RPN controller LSB
1828                    pEngineChannel->SetMidiRpnControllerLsb(itControlChangeEvent->Param.CC.Value);
1829                    break;
1830                }
1831                case 101: { // RPN controller MSB
1832                    pEngineChannel->SetMidiRpnControllerMsb(itControlChangeEvent->Param.CC.Value);
1833                    break;
1834                }
1835    
1836    
1837              // Channel Mode Messages              // Channel Mode Messages
# Line 1254  namespace LinuxSampler { namespace gig { Line 1845  namespace LinuxSampler { namespace gig {
1845                  break;                  break;
1846              }              }
1847              case 123: { // all notes off              case 123: { // all notes off
1848                    #if CONFIG_PROCESS_ALL_NOTES_OFF
1849                  ReleaseAllVoices(pEngineChannel, itControlChangeEvent);                  ReleaseAllVoices(pEngineChannel, itControlChangeEvent);
1850                    #endif // CONFIG_PROCESS_ALL_NOTES_OFF
1851                    break;
1852                }
1853                case 126: { // mono mode on
1854                    if (!pEngineChannel->SoloMode)
1855                        KillAllVoices(pEngineChannel, itControlChangeEvent);
1856                    pEngineChannel->SoloMode = true;
1857                    break;
1858                }
1859                case 127: { // poly mode on
1860                    if (pEngineChannel->SoloMode)
1861                        KillAllVoices(pEngineChannel, itControlChangeEvent);
1862                    pEngineChannel->SoloMode = false;
1863                  break;                  break;
1864              }              }
1865          }          }
1866    
1867            // handle FX send controllers
1868            if (!pEngineChannel->fxSends.empty()) {
1869                for (int iFxSend = 0; iFxSend < pEngineChannel->GetFxSendCount(); iFxSend++) {
1870                    FxSend* pFxSend = pEngineChannel->GetFxSend(iFxSend);
1871                    if (pFxSend->MidiController() == itControlChangeEvent->Param.CC.Controller) {
1872                        pFxSend->SetLevel(itControlChangeEvent->Param.CC.Value);
1873                        pFxSend->SetInfoChanged(true);
1874                    }
1875                }
1876            }
1877      }      }
1878    
1879      /**      /**
# Line 1266  namespace LinuxSampler { namespace gig { Line 1882  namespace LinuxSampler { namespace gig {
1882       *  @param itSysexEvent - sysex data size and time stamp of the sysex event       *  @param itSysexEvent - sysex data size and time stamp of the sysex event
1883       */       */
1884      void Engine::ProcessSysex(Pool<Event>::Iterator& itSysexEvent) {      void Engine::ProcessSysex(Pool<Event>::Iterator& itSysexEvent) {
1885          RingBuffer<uint8_t>::NonVolatileReader reader = pSysexBuffer->get_non_volatile_reader();          RingBuffer<uint8_t,false>::NonVolatileReader reader = pSysexBuffer->get_non_volatile_reader();
1886    
1887          uint8_t exclusive_status, id;          uint8_t exclusive_status, id;
1888          if (!reader.pop(&exclusive_status)) goto free_sysex_data;          if (!reader.pop(&exclusive_status)) goto free_sysex_data;
# Line 1274  namespace LinuxSampler { namespace gig { Line 1890  namespace LinuxSampler { namespace gig {
1890          if (exclusive_status != 0xF0)       goto free_sysex_data;          if (exclusive_status != 0xF0)       goto free_sysex_data;
1891    
1892          switch (id) {          switch (id) {
1893                case 0x7f: { // (Realtime) Universal Sysex (GM Standard)
1894                    uint8_t sysex_channel, sub_id1, sub_id2, val_msb, val_lsb;;
1895                    if (!reader.pop(&sysex_channel)) goto free_sysex_data;
1896                    if (!reader.pop(&sub_id1)) goto free_sysex_data;
1897                    if (!reader.pop(&sub_id2)) goto free_sysex_data;
1898                    if (!reader.pop(&val_lsb)) goto free_sysex_data;
1899                    if (!reader.pop(&val_msb)) goto free_sysex_data;
1900                    //TODO: for now we simply ignore the sysex channel, seldom used anyway
1901                    switch (sub_id1) {
1902                        case 0x04: // Device Control
1903                            switch (sub_id2) {
1904                                case 0x01: // Master Volume
1905                                    GLOBAL_VOLUME =
1906                                        double((uint(val_msb)<<7) | uint(val_lsb)) / 16383.0;
1907                                    break;
1908                            }
1909                            break;
1910                    }
1911                    break;
1912                }
1913              case 0x41: { // Roland              case 0x41: { // Roland
1914                  dmsg(3,("Roland Sysex\n"));                  dmsg(3,("Roland Sysex\n"));
1915                  uint8_t device_id, model_id, cmd_id;                  uint8_t device_id, model_id, cmd_id;
# Line 1285  namespace LinuxSampler { namespace gig { Line 1921  namespace LinuxSampler { namespace gig {
1921    
1922                  // command address                  // command address
1923                  uint8_t addr[3]; // 2 byte addr MSB, followed by 1 byte addr LSB)                  uint8_t addr[3]; // 2 byte addr MSB, followed by 1 byte addr LSB)
1924                  const RingBuffer<uint8_t>::NonVolatileReader checksum_reader = reader; // so we can calculate the check sum later                  const RingBuffer<uint8_t,false>::NonVolatileReader checksum_reader = reader; // so we can calculate the check sum later
1925                  if (reader.read(&addr[0], 3) != 3) goto free_sysex_data;                  if (reader.read(&addr[0], 3) != 3) goto free_sysex_data;
1926                  if (addr[0] == 0x40 && addr[1] == 0x00) { // System Parameters                  if (addr[0] == 0x40 && addr[1] == 0x00) { // System Parameters
1927                      dmsg(3,("\tSystem Parameter\n"));                      dmsg(3,("\tSystem Parameter\n"));
# Line 1332  namespace LinuxSampler { namespace gig { Line 1968  namespace LinuxSampler { namespace gig {
1968       *                     question       *                     question
1969       * @param DataSize   - size of the GS message data (in bytes)       * @param DataSize   - size of the GS message data (in bytes)
1970       */       */
1971      uint8_t Engine::GSCheckSum(const RingBuffer<uint8_t>::NonVolatileReader AddrReader, uint DataSize) {      uint8_t Engine::GSCheckSum(const RingBuffer<uint8_t,false>::NonVolatileReader AddrReader, uint DataSize) {
1972          RingBuffer<uint8_t>::NonVolatileReader reader = AddrReader;          RingBuffer<uint8_t,false>::NonVolatileReader reader = AddrReader;
1973          uint bytes = 3 /*addr*/ + DataSize;          uint bytes = 3 /*addr*/ + DataSize;
1974          uint8_t addr_and_data[bytes];          uint8_t addr_and_data[bytes];
1975          reader.read(&addr_and_data[0], bytes);          reader.read(&addr_and_data[0], bytes);
# Line 1448  namespace LinuxSampler { namespace gig { Line 2084  namespace LinuxSampler { namespace gig {
2084      }      }
2085    
2086      String Engine::Description() {      String Engine::Description() {
2087          return "Gigasampler Engine";          return "Gigasampler Format Engine";
2088      }      }
2089    
2090      String Engine::Version() {      String Engine::Version() {
2091          String s = "$Revision: 1.56 $";          String s = "$Revision: 1.93 $";
2092          return s.substr(11, s.size() - 13); // cut dollar signs, spaces and CVS macro keyword          return s.substr(11, s.size() - 13); // cut dollar signs, spaces and CVS macro keyword
2093      }      }
2094    
2095        InstrumentManager* Engine::GetInstrumentManager() {
2096            return &instruments;
2097        }
2098    
2099        // static constant initializers
2100        const Engine::FloatTable Engine::VolumeCurve(InitVolumeCurve());
2101        const Engine::FloatTable Engine::PanCurve(InitPanCurve());
2102        const Engine::FloatTable Engine::CrossfadeCurve(InitCrossfadeCurve());
2103    
2104        float* Engine::InitVolumeCurve() {
2105            // line-segment approximation
2106            const float segments[] = {
2107                0, 0, 2, 0.0046, 16, 0.016, 31, 0.051, 45, 0.115, 54.5, 0.2,
2108                64.5, 0.39, 74, 0.74, 92, 1.03, 114, 1.94, 119.2, 2.2, 127, 2.2
2109            };
2110            return InitCurve(segments);
2111        }
2112    
2113        float* Engine::InitPanCurve() {
2114            // line-segment approximation
2115            const float segments[] = {
2116                0, 0, 1, 0,
2117                2, 0.05, 31.5, 0.7, 51, 0.851, 74.5, 1.12,
2118                127, 1.41, 128, 1.41
2119            };
2120            return InitCurve(segments, 129);
2121        }
2122    
2123        float* Engine::InitCrossfadeCurve() {
2124            // line-segment approximation
2125            const float segments[] = {
2126                0, 0, 1, 0.03, 10, 0.1, 51, 0.58, 127, 1
2127            };
2128            return InitCurve(segments);
2129        }
2130    
2131        float* Engine::InitCurve(const float* segments, int size) {
2132            float* y = new float[size];
2133            for (int x = 0 ; x < size ; x++) {
2134                if (x > segments[2]) segments += 2;
2135                y[x] = segments[1] + (x - segments[0]) *
2136                    (segments[3] - segments[1]) / (segments[2] - segments[0]);
2137            }
2138            return y;
2139        }
2140    
2141  }} // namespace LinuxSampler::gig  }} // namespace LinuxSampler::gig
Legend:
Removed from v.781  
changed lines
  Added in v.1748
  ViewVC Help
Powered by ViewVC