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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 2612 - (hide annotations) (download) (as text)
Tue Jun 10 13:32:16 2014 UTC (9 years, 9 months ago) by schoenebeck
File MIME type: text/x-c++hdr
File size: 88084 byte(s)
* Fixed crashes when exiting the sampler.
* Bumped version (1.0.0.svn47).

1 iliev 2012 /***************************************************************************
2     * *
3     * LinuxSampler - modular, streaming capable sampler *
4     * *
5     * Copyright (C) 2003,2004 by Benno Senoner and Christian Schoenebeck *
6 persson 2055 * Copyright (C) 2005-2008 Christian Schoenebeck *
7 persson 2427 * Copyright (C) 2009-2013 Christian Schoenebeck and Grigor Iliev *
8 iliev 2012 * *
9     * This program is free software; you can redistribute it and/or modify *
10     * it under the terms of the GNU General Public License as published by *
11     * the Free Software Foundation; either version 2 of the License, or *
12     * (at your option) any later version. *
13     * *
14     * This program is distributed in the hope that it will be useful, *
15     * but WITHOUT ANY WARRANTY; without even the implied warranty of *
16     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
17     * GNU General Public License for more details. *
18     * *
19     * You should have received a copy of the GNU General Public License *
20     * along with this program; if not, write to the Free Software *
21     * Foundation, Inc., 59 Temple Place, Suite 330, Boston, *
22     * MA 02111-1307 USA *
23     ***************************************************************************/
24    
25     #ifndef __LS_ENGINEBASE_H__
26     #define __LS_ENGINEBASE_H__
27    
28     #include "AbstractEngine.h"
29     #include "EngineChannelBase.h"
30     #include "common/DiskThreadBase.h"
31     #include "common/MidiKeyboardManager.h"
32     #include "InstrumentManager.h"
33     #include "../common/global_private.h"
34    
35    
36     namespace LinuxSampler {
37    
38     class AbstractEngineChannel;
39    
40     template <
41     class V /* Voice */,
42     class RR /* Root Region */,
43     class R /* Region */,
44     class D /* Disk Thread */,
45     class IM /* Instrument Manager */,
46     class I /* Instrument */
47     >
48     class EngineBase: public AbstractEngine, public RegionPools<R>, public VoicePool<V> {
49    
50     public:
51     typedef typename RTList<V>::Iterator VoiceIterator;
52     typedef typename Pool<V>::Iterator PoolVoiceIterator;
53     typedef typename RTList<RR*>::Iterator RootRegionIterator;
54     typedef typename MidiKeyboardManager<V>::MidiKey MidiKey;
55    
56     EngineBase() : SuspendedRegions(128) {
57     pDiskThread = NULL;
58     pVoicePool = new Pool<V>(GLOBAL_MAX_VOICES);
59     pRegionPool[0] = new Pool<R*>(GLOBAL_MAX_VOICES);
60     pRegionPool[1] = new Pool<R*>(GLOBAL_MAX_VOICES);
61     pVoiceStealingQueue = new RTList<Event>(pEventPool);
62     iMaxDiskStreams = GLOBAL_MAX_STREAMS;
63    
64     for (VoiceIterator iterVoice = pVoicePool->allocAppend(); iterVoice == pVoicePool->last(); iterVoice = pVoicePool->allocAppend()) {
65     iterVoice->SetEngine(this);
66     }
67     pVoicePool->clear();
68    
69     ResetInternal();
70     ResetScaleTuning();
71     ResetSuspendedRegions();
72     }
73    
74     virtual ~EngineBase() {
75     if (pDiskThread) {
76     dmsg(1,("Stopping disk thread..."));
77     pDiskThread->StopThread();
78     delete pDiskThread;
79     dmsg(1,("OK\n"));
80     }
81    
82     if (pVoicePool) {
83     pVoicePool->clear();
84     delete pVoicePool;
85     }
86    
87     if (pVoiceStealingQueue) delete pVoiceStealingQueue;
88    
89     if (pRegionPool[0]) delete pRegionPool[0];
90     if (pRegionPool[1]) delete pRegionPool[1];
91     ResetSuspendedRegions();
92     }
93    
94     // implementation of abstract methods derived from class 'LinuxSampler::Engine'
95    
96     /**
97     * Let this engine proceed to render the given amount of sample points.
98     * The engine will iterate through all engine channels and render audio
99     * for each engine channel independently. The calculated audio data of
100     * all voices of each engine channel will be placed into the audio sum
101     * buffers of the respective audio output device, connected to the
102     * respective engine channel.
103     *
104     * @param Samples - number of sample points to be rendered
105     * @returns 0 on success
106     */
107 schoenebeck 2434 virtual int RenderAudio(uint Samples) OVERRIDE {
108 iliev 2012 dmsg(8,("RenderAudio(Samples=%d)\n", Samples));
109    
110     // return if engine disabled
111     if (EngineDisabled.Pop()) {
112     dmsg(5,("EngineBase: engine disabled (val=%d)\n",EngineDisabled.GetUnsafe()));
113     EngineDisabled.RttDone();
114     return 0;
115     }
116    
117     // process requests for suspending / resuming regions (i.e. to avoid
118     // crashes while these regions are modified by an instrument editor)
119     ProcessSuspensionsChanges();
120    
121     // update time of start and end of this audio fragment (as events' time stamps relate to this)
122     pEventGenerator->UpdateFragmentTime(Samples);
123    
124     // We only allow the given maximum number of voices to be spawned
125     // in each audio fragment. All subsequent request for spawning new
126     // voices in the same audio fragment will be ignored.
127     VoiceSpawnsLeft = MaxVoices();
128    
129     // get all events from the engine's global input event queue which belong to the current fragment
130     // (these are usually just SysEx messages)
131     ImportEvents(Samples);
132    
133     // process engine global events (these are currently only MIDI System Exclusive messages)
134     {
135     RTList<Event>::Iterator itEvent = pGlobalEvents->first();
136     RTList<Event>::Iterator end = pGlobalEvents->end();
137     for (; itEvent != end; ++itEvent) {
138     switch (itEvent->Type) {
139     case Event::type_sysex:
140     dmsg(5,("Engine: Sysex received\n"));
141     ProcessSysex(itEvent);
142     break;
143     }
144     }
145     }
146 schoenebeck 2448
147     // In case scale tuning has been changed, recalculate pitch for
148     // all active voices.
149     ProcessScaleTuningChange();
150 iliev 2012
151     // reset internal voice counter (just for statistic of active voices)
152     ActiveVoiceCountTemp = 0;
153    
154     HandleInstrumentChanges();
155    
156     // handle events on all engine channels
157     for (int i = 0; i < engineChannels.size(); i++) {
158     ProcessEvents(engineChannels[i], Samples);
159     }
160    
161     // render all 'normal', active voices on all engine channels
162     for (int i = 0; i < engineChannels.size(); i++) {
163     RenderActiveVoices(engineChannels[i], Samples);
164     }
165    
166     // now that all ordinary voices on ALL engine channels are rendered, render new stolen voices
167     RenderStolenVoices(Samples);
168    
169     // handle audio routing for engine channels with FX sends
170     for (int i = 0; i < engineChannels.size(); i++) {
171     AbstractEngineChannel* pChannel = static_cast<AbstractEngineChannel*>(engineChannels[i]);
172     if (pChannel->fxSends.empty()) continue; // ignore if no FX sends
173     RouteAudio(engineChannels[i], Samples);
174     }
175    
176     // handle cleanup on all engine channels for the next audio fragment
177     for (int i = 0; i < engineChannels.size(); i++) {
178     PostProcess(engineChannels[i]);
179     }
180    
181    
182     // empty the engine's event list for the next audio fragment
183     ClearEventLists();
184    
185     // reset voice stealing for the next audio fragment
186     pVoiceStealingQueue->clear();
187    
188     // just some statistics about this engine instance
189     SetVoiceCount(ActiveVoiceCountTemp);
190     if (VoiceCount() > ActiveVoiceCountMax) ActiveVoiceCountMax = VoiceCount();
191    
192     // in case regions were previously suspended and we killed voices
193     // with disk streams due to that, check if those streams have finally
194     // been deleted by the disk thread
195     if (iPendingStreamDeletions) ProcessPendingStreamDeletions();
196    
197 persson 2162 // Release the instrument change command. (This has to
198     // be done after all voices have been rendered and not
199     // in HandleInstrumentChanges, as the RegionsInUse
200     // list has been built up by the voice renderers.)
201     for (int i = 0; i < engineChannels.size(); i++) {
202     EngineChannelBase<V, R, I>* channel =
203     static_cast<EngineChannelBase<V, R, I>*>(engineChannels[i]);
204     channel->InstrumentChangeCommandReader.Unlock();
205     }
206 iliev 2012 FrameTime += Samples;
207    
208     EngineDisabled.RttDone();
209     return 0;
210     }
211    
212 schoenebeck 2434 virtual int MaxVoices() OVERRIDE { return pVoicePool->poolSize(); }
213 iliev 2012
214 schoenebeck 2434 virtual void SetMaxVoices(int iVoices) throw (Exception) OVERRIDE {
215 iliev 2012 if (iVoices < 1)
216     throw Exception("Maximum voices for an engine cannot be set lower than 1");
217    
218     SuspendAll();
219    
220     // NOTE: we need to clear pRegionsInUse before deleting pDimRegionPool,
221     // otherwise memory corruption will occur if there are active voices (see bug #118)
222     for (int iChannel = 0; iChannel < engineChannels.size(); iChannel++) {
223     EngineChannelBase<V, R, I>* pChannel = static_cast<EngineChannelBase<V, R, I>*>(engineChannels[iChannel]);
224     pChannel->ClearRegionsInUse();
225     }
226    
227     if (pRegionPool[0]) delete pRegionPool[0];
228     if (pRegionPool[1]) delete pRegionPool[1];
229    
230     pRegionPool[0] = new Pool<R*>(iVoices);
231     pRegionPool[1] = new Pool<R*>(iVoices);
232    
233     for (int iChannel = 0; iChannel < engineChannels.size(); iChannel++) {
234     EngineChannelBase<V, R, I>* pChannel = static_cast<EngineChannelBase<V, R, I>*>(engineChannels[iChannel]);
235     pChannel->ResetRegionsInUse(pRegionPool);
236     }
237    
238     try {
239     pVoicePool->resizePool(iVoices);
240     } catch (...) {
241     throw Exception("FATAL: Could not resize voice pool!");
242     }
243    
244     for (VoiceIterator iterVoice = pVoicePool->allocAppend(); iterVoice == pVoicePool->last(); iterVoice = pVoicePool->allocAppend()) {
245     iterVoice->SetEngine(this);
246     iterVoice->pDiskThread = this->pDiskThread;
247     }
248     pVoicePool->clear();
249    
250 iliev 2244 PostSetMaxVoices(iVoices);
251 iliev 2012 ResumeAll();
252     }
253 iliev 2244
254     /** Called after the new max number of voices is set and before resuming the engine. */
255     virtual void PostSetMaxVoices(int iVoices) { }
256 iliev 2012
257 schoenebeck 2434 virtual uint DiskStreamCount() OVERRIDE { return (pDiskThread) ? pDiskThread->GetActiveStreamCount() : 0; }
258     virtual uint DiskStreamCountMax() OVERRIDE { return (pDiskThread) ? pDiskThread->ActiveStreamCountMax : 0; }
259     virtual int MaxDiskStreams() OVERRIDE { return iMaxDiskStreams; }
260 iliev 2012
261 schoenebeck 2434 virtual void SetMaxDiskStreams(int iStreams) throw (Exception) OVERRIDE {
262 iliev 2012 if (iStreams < 0)
263     throw Exception("Maximum disk streams for an engine cannot be set lower than 0");
264    
265     SuspendAll();
266    
267     iMaxDiskStreams = iStreams;
268    
269     // reconnect to audio output device, because that will automatically
270     // recreate the disk thread with the required amount of streams
271     if (pAudioOutputDevice) Connect(pAudioOutputDevice);
272    
273     ResumeAll();
274     }
275    
276 schoenebeck 2434 virtual String DiskStreamBufferFillBytes() OVERRIDE { return (pDiskThread) ? pDiskThread->GetBufferFillBytes() : ""; }
277     virtual String DiskStreamBufferFillPercentage() OVERRIDE { return (pDiskThread) ? pDiskThread->GetBufferFillPercentage() : ""; }
278     virtual InstrumentManager* GetInstrumentManager() OVERRIDE { return &instruments; }
279 iliev 2012
280     /**
281     * Connect this engine instance with the given audio output device.
282     * This method will be called when an Engine instance is created.
283     * All of the engine's data structures which are dependant to the used
284     * audio output device / driver will be (re)allocated and / or
285     * adjusted appropriately.
286     *
287     * @param pAudioOut - audio output device to connect to
288     */
289 schoenebeck 2434 virtual void Connect(AudioOutputDevice* pAudioOut) OVERRIDE {
290 iliev 2012 // caution: don't ignore if connecting to the same device here,
291     // because otherwise SetMaxDiskStreams() implementation won't work anymore!
292    
293     pAudioOutputDevice = pAudioOut;
294    
295     ResetInternal();
296    
297     // inform audio driver for the need of two channels
298     try {
299     pAudioOutputDevice->AcquireChannels(2); // default stereo
300     }
301     catch (AudioOutputException e) {
302     String msg = "Audio output device unable to provide 2 audio channels, cause: " + e.Message();
303     throw Exception(msg);
304     }
305    
306     this->MaxSamplesPerCycle = pAudioOutputDevice->MaxSamplesPerCycle();
307     this->SampleRate = pAudioOutputDevice->SampleRate();
308    
309     MinFadeOutSamples = int(double(SampleRate) * CONFIG_EG_MIN_RELEASE_TIME) - 1;
310     if (MaxSamplesPerCycle < MinFadeOutSamples) {
311     std::cerr << "EngineBase: WARNING, CONFIG_EG_MIN_RELEASE_TIME "
312     << "too big for current audio fragment size & sampling rate! "
313     << "May lead to click sounds if voice stealing chimes in!\n" << std::flush;
314     // force volume ramp downs at the beginning of each fragment
315     MinFadeOutSamples = MaxSamplesPerCycle;
316     // lower minimum release time
317     const float minReleaseTime = (float) MaxSamplesPerCycle / (float) SampleRate;
318     for (VoiceIterator iterVoice = pVoicePool->allocAppend(); iterVoice == pVoicePool->last(); iterVoice = pVoicePool->allocAppend()) {
319 persson 2327 iterVoice->CalculateFadeOutCoeff(minReleaseTime, SampleRate);
320 iliev 2012 }
321     pVoicePool->clear();
322     }
323    
324     // (re)create disk thread
325     if (this->pDiskThread) {
326     dmsg(1,("Stopping disk thread..."));
327     this->pDiskThread->StopThread();
328     delete this->pDiskThread;
329     dmsg(1,("OK\n"));
330     }
331     this->pDiskThread = CreateDiskThread();
332    
333     if (!pDiskThread) {
334     dmsg(0,("EngineBase new diskthread = NULL\n"));
335     exit(EXIT_FAILURE);
336     }
337    
338     for (VoiceIterator iterVoice = pVoicePool->allocAppend(); iterVoice == pVoicePool->last(); iterVoice = pVoicePool->allocAppend()) {
339     iterVoice->pDiskThread = this->pDiskThread;
340     dmsg(3,("d"));
341     }
342     pVoicePool->clear();
343    
344     // (re)create event generator
345     if (pEventGenerator) delete pEventGenerator;
346     pEventGenerator = new EventGenerator(pAudioOut->SampleRate());
347    
348     dmsg(1,("Starting disk thread..."));
349     pDiskThread->StartThread();
350     dmsg(1,("OK\n"));
351    
352 iliev 2298 bool printEqInfo = true;
353 iliev 2012 for (VoiceIterator iterVoice = pVoicePool->allocAppend(); iterVoice == pVoicePool->last(); iterVoice = pVoicePool->allocAppend()) {
354     if (!iterVoice->pDiskThread) {
355     dmsg(0,("Engine -> voice::trigger: !pDiskThread\n"));
356     exit(EXIT_FAILURE);
357     }
358 iliev 2298
359     iterVoice->CreateEq();
360    
361     if(printEqInfo) {
362     iterVoice->PrintEqInfo();
363     printEqInfo = false;
364     }
365 iliev 2012 }
366     pVoicePool->clear();
367 schoenebeck 2121
368     // (re)create dedicated voice audio buffers
369     //TODO: we could optimize resource usage a bit by just allocating these dedicated voice buffers when there is at least one engine channel with FX sends, because only in this case those special buffers are used actually, but since it would usually only save couple bytes in total, its probably not worth it
370     if (pDedicatedVoiceChannelLeft) delete pDedicatedVoiceChannelLeft;
371     if (pDedicatedVoiceChannelRight) delete pDedicatedVoiceChannelRight;
372     pDedicatedVoiceChannelLeft = new AudioChannel(0, MaxSamplesPerCycle);
373     pDedicatedVoiceChannelRight = new AudioChannel(1, MaxSamplesPerCycle);
374 iliev 2012 }
375 schoenebeck 2410
376     // Implementattion for abstract method derived from Engine.
377 schoenebeck 2434 virtual void ReconnectAudioOutputDevice() OVERRIDE {
378 schoenebeck 2410 SuspendAll();
379     if (pAudioOutputDevice) Connect(pAudioOutputDevice);
380     ResumeAll();
381     }
382 iliev 2012
383     /**
384     * Similar to @c Disable() but this method additionally kills all voices
385     * and disk streams and blocks until all voices and disk streams are actually
386     * killed / deleted.
387     *
388     * @e Note: only the original calling thread is able to re-enable the
389     * engine afterwards by calling @c ResumeAll() later on!
390     */
391     virtual void SuspendAll() {
392     dmsg(2,("Engine: Suspending all ...\n"));
393     // stop the engine, so we can safely modify the engine's
394     // data structures from this foreign thread
395     DisableAndLock();
396     // we could also use the respective class member variable here,
397     // but this is probably safer and cleaner
398     int iPendingStreamDeletions = 0;
399     // kill all voices on all engine channels the *die hard* way
400     for (int iChannel = 0; iChannel < engineChannels.size(); iChannel++) {
401     EngineChannelBase<V, R, I>* pEngineChannel =
402     static_cast<EngineChannelBase<V, R, I>*>(engineChannels[iChannel]);
403    
404     iPendingStreamDeletions += pEngineChannel->KillAllVoicesImmediately();
405     }
406     // wait until all streams were actually deleted by the disk thread
407     while (iPendingStreamDeletions) {
408     while (
409     iPendingStreamDeletions &&
410     pDiskThread->AskForDeletedStream() != Stream::INVALID_HANDLE
411     ) iPendingStreamDeletions--;
412     if (!iPendingStreamDeletions) break;
413     usleep(10000); // sleep for 10ms
414     }
415     dmsg(2,("EngineBase: Everything suspended.\n"));
416     }
417    
418     /**
419     * At the moment same as calling @c Enable() directly, but this might
420     * change in future, so better call this method as counterpart to
421     * @c SuspendAll() instead of @c Enable() !
422     */
423     virtual void ResumeAll() { Enable(); }
424    
425     /**
426     * Order the engine to stop rendering audio for the given region.
427     * Additionally this method will block until all voices and their disk
428     * streams associated with that region are actually killed / deleted, so
429     * one can i.e. safely modify the region with an instrument editor after
430     * returning from this method.
431     *
432     * @param pRegion - region the engine shall stop using
433     */
434     virtual void Suspend(RR* pRegion) {
435     dmsg(2,("EngineBase: Suspending Region %x ...\n",pRegion));
436 persson 2427 {
437     LockGuard lock(SuspendedRegionsMutex);
438     SuspensionChangeOngoing.Set(true);
439     pPendingRegionSuspension = pRegion;
440     SuspensionChangeOngoing.WaitAndUnlockIf(true);
441     }
442 iliev 2012 dmsg(2,("EngineBase: Region %x suspended.",pRegion));
443     }
444    
445     /**
446     * Orders the engine to resume playing back the given region, previously
447     * suspended with @c Suspend() .
448     *
449     * @param pRegion - region the engine shall be allowed to use again
450     */
451     virtual void Resume(RR* pRegion) {
452     dmsg(2,("EngineBase: Resuming Region %x ...\n",pRegion));
453 persson 2427 {
454     LockGuard lock(SuspendedRegionsMutex);
455     SuspensionChangeOngoing.Set(true);
456     pPendingRegionResumption = pRegion;
457     SuspensionChangeOngoing.WaitAndUnlockIf(true);
458     }
459 iliev 2012 dmsg(2,("EngineBase: Region %x resumed.\n",pRegion));
460     }
461    
462     virtual void ResetSuspendedRegions() {
463     SuspendedRegions.clear();
464     iPendingStreamDeletions = 0;
465     pPendingRegionSuspension = pPendingRegionResumption = NULL;
466     SuspensionChangeOngoing.Set(false);
467     }
468    
469     /**
470     * Called by the engine's (audio) thread once per cycle to process requests
471     * from the outer world to suspend or resume a given @c gig::Region .
472     */
473     virtual void ProcessSuspensionsChanges() {
474     // process request for suspending one region
475     if (pPendingRegionSuspension) {
476     // kill all voices on all engine channels that use this region
477     for (int iChannel = 0; iChannel < engineChannels.size(); iChannel++) {
478     EngineChannelBase<V, R, I>* pEngineChannel =
479     static_cast<EngineChannelBase<V, R, I>*>(engineChannels[iChannel]);
480     SuspensionVoiceHandler handler(pPendingRegionSuspension);
481     pEngineChannel->ProcessActiveVoices(&handler);
482     iPendingStreamDeletions += handler.PendingStreamDeletions;
483     }
484     // make sure the region is not yet on the list
485     bool bAlreadySuspended = false;
486     RootRegionIterator iter = SuspendedRegions.first();
487     RootRegionIterator end = SuspendedRegions.end();
488     for (; iter != end; ++iter) { // iterate through all suspended regions
489     if (*iter == pPendingRegionSuspension) { // found
490     bAlreadySuspended = true;
491     dmsg(1,("EngineBase: attempt to suspend an already suspended region !!!\n"));
492     break;
493     }
494     }
495     if (!bAlreadySuspended) {
496     // put the region on the list of suspended regions
497     RootRegionIterator iter = SuspendedRegions.allocAppend();
498     if (iter) {
499     *iter = pPendingRegionSuspension;
500     } else std::cerr << "EngineBase: Could not suspend Region, list is full. This is a bug!!!\n" << std::flush;
501     }
502     // free request slot for next caller (and to make sure that
503     // we're not going to process the same request in the next cycle)
504     pPendingRegionSuspension = NULL;
505     // if no disk stream deletions are pending, awaken other side, as
506     // we're done in this case
507     if (!iPendingStreamDeletions) SuspensionChangeOngoing.Set(false);
508     }
509    
510     // process request for resuming one region
511     if (pPendingRegionResumption) {
512     // remove region from the list of suspended regions
513     RootRegionIterator iter = SuspendedRegions.first();
514     RootRegionIterator end = SuspendedRegions.end();
515     for (; iter != end; ++iter) { // iterate through all suspended regions
516     if (*iter == pPendingRegionResumption) { // found
517     SuspendedRegions.free(iter);
518     break; // done
519     }
520     }
521     // free request slot for next caller
522     pPendingRegionResumption = NULL;
523     // awake other side as we're done
524     SuspensionChangeOngoing.Set(false);
525     }
526     }
527    
528     /**
529     * Called by the engine's (audio) thread once per cycle to check if
530     * streams of voices that were killed due to suspension request have
531     * finally really been deleted by the disk thread.
532     */
533     virtual void ProcessPendingStreamDeletions() {
534     if (!iPendingStreamDeletions) return;
535     //TODO: or shall we better store a list with stream handles instead of a scalar amount of streams to be deleted? might be safer
536     while (
537     iPendingStreamDeletions &&
538     pDiskThread->AskForDeletedStream() != Stream::INVALID_HANDLE
539     ) iPendingStreamDeletions--;
540     // just for safety ...
541     while (pDiskThread->AskForDeletedStream() != Stream::INVALID_HANDLE);
542     // now that all disk streams are deleted, awake other side as
543     // we're finally done with suspending the requested region
544     if (!iPendingStreamDeletions) SuspensionChangeOngoing.Set(false);
545     }
546    
547     /**
548     * Returns @c true if the given region is currently set to be suspended
549     * from being used, @c false otherwise.
550     */
551     virtual bool RegionSuspended(RR* pRegion) {
552     if (SuspendedRegions.isEmpty()) return false;
553     //TODO: or shall we use a sorted container instead of the RTList? might be faster ... or trivial ;-)
554     RootRegionIterator iter = SuspendedRegions.first();
555     RootRegionIterator end = SuspendedRegions.end();
556     for (; iter != end; ++iter) // iterate through all suspended regions
557     if (*iter == pRegion) return true;
558     return false;
559     }
560    
561     // implementation of abstract method derived from class 'LinuxSampler::RegionPools'
562     virtual Pool<R*>* GetRegionPool(int index) {
563     if (index < 0 || index > 1) throw Exception("Index out of bounds");
564     return pRegionPool[index];
565     }
566    
567     // implementation of abstract method derived from class 'LinuxSampler::VoicePool'
568     virtual Pool<V>* GetVoicePool() { return pVoicePool; }
569    
570     D* GetDiskThread() { return pDiskThread; }
571    
572     //friend class EngineChannelBase<V, R, I>;
573    
574 persson 2127 static IM instruments;
575    
576 iliev 2012 protected:
577     class SuspensionVoiceHandler : public MidiKeyboardManager<V>::VoiceHandler {
578     public:
579     int PendingStreamDeletions;
580     RR* pPendingRegionSuspension;
581 schoenebeck 2434
582 iliev 2012 SuspensionVoiceHandler(RR* pPendingRegionSuspension) {
583     PendingStreamDeletions = 0;
584     this->pPendingRegionSuspension = pPendingRegionSuspension;
585     }
586    
587 schoenebeck 2434 virtual bool Process(MidiKey* pMidiKey) OVERRIDE {
588 iliev 2012 VoiceIterator itVoice = pMidiKey->pActiveVoices->first();
589     // if current key is not associated with this region, skip this key
590     if (itVoice->GetRegion()->GetParent() != pPendingRegionSuspension) return false;
591    
592     return true;
593     }
594    
595 schoenebeck 2434 virtual void Process(VoiceIterator& itVoice) OVERRIDE {
596 iliev 2012 // request a notification from disk thread side for stream deletion
597     const Stream::Handle hStream = itVoice->KillImmediately(true);
598     if (hStream != Stream::INVALID_HANDLE) { // voice actually used a stream
599     PendingStreamDeletions++;
600     }
601     //NOTE: maybe we should call FreeVoice() here, shouldn't cause a harm though I think, since the voices should be freed by RenderActiveVoices() in the render loop, they are probably just freed a bit later than they could/should be
602     }
603     };
604    
605     Pool<R*>* pRegionPool[2]; ///< Double buffered pool, used by the engine channels to keep track of regions in use.
606     int MinFadeOutSamples; ///< The number of samples needed to make an instant fade out (e.g. for voice stealing) without leading to clicks.
607     D* pDiskThread;
608    
609     int ActiveVoiceCountTemp; ///< number of currently active voices (for internal usage, will be used for incrementation)
610     VoiceIterator itLastStolenVoice; ///< Only for voice stealing: points to the last voice which was theft in current audio fragment, NULL otherwise.
611     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.
612     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.
613     VoiceIterator itLastStolenVoiceGlobally; ///< Same as itLastStolenVoice, but engine globally
614     RTList<uint>::Iterator iuiLastStolenKeyGlobally; ///< Same as iuiLastStolenKey, but engine globally
615     RTList<Event>* pVoiceStealingQueue; ///< All voice-launching events which had to be postponed due to free voice shortage.
616     Mutex ResetInternalMutex; ///< Mutex to protect the ResetInternal function for concurrent usage (e.g. by the lscp and instrument loader threads).
617     int iMaxDiskStreams;
618    
619     /**
620     * Dispatch and handle all events in this audio fragment for the given
621     * engine channel.
622     *
623     * @param pEngineChannel - engine channel on which events should be
624     * processed
625     * @param Samples - amount of sample points to be processed in
626     * this audio fragment cycle
627     */
628     void ProcessEvents(EngineChannel* pEngineChannel, uint Samples) {
629     // get all events from the engine channels's input event queue which belong to the current fragment
630     // (these are the common events like NoteOn, NoteOff, ControlChange, etc.)
631     AbstractEngineChannel* pChannel = static_cast<AbstractEngineChannel*>(pEngineChannel);
632     pChannel->ImportEvents(Samples);
633    
634 schoenebeck 2594 // if a valid real-time instrument script is loaded, pre-process
635     // the event list by running the script now, since the script
636     // might filter events or add new ones for this cycle
637 schoenebeck 2611 if (pChannel->pScript && pChannel->pScript->bHasValidScript) {
638 schoenebeck 2594 // resume any suspended script executions still hanging
639     // around of previous audio fragment cycles
640 schoenebeck 2611 for (RTList<ScriptEvent>::Iterator itEvent = pChannel->pScript->pEvents->first(),
641     end = pChannel->pScript->pEvents->end(); itEvent != end; ++itEvent)
642 schoenebeck 2594 {
643 schoenebeck 2596 ResumeScriptEvent(pChannel, itEvent); //TODO: implement support for actual suspension time (i.e. passed to a script's wait() function call)
644 schoenebeck 2594 }
645    
646     // spawn new script executions for the new MIDI events of
647     // this audio fragment cycle
648     for (RTList<Event>::Iterator itEvent = pChannel->pEvents->first(),
649     end = pChannel->pEvents->end(); itEvent != end; ++itEvent)
650     {
651     switch (itEvent->Type) {
652     case Event::type_note_on:
653 schoenebeck 2611 if (pChannel->pScript->handlerNote)
654     ProcessEventByScript(pChannel, itEvent, pChannel->pScript->handlerNote);
655 schoenebeck 2594 break;
656     case Event::type_note_off:
657 schoenebeck 2611 if (pChannel->pScript->handlerRelease)
658     ProcessEventByScript(pChannel, itEvent, pChannel->pScript->handlerRelease);
659 schoenebeck 2594 break;
660     case Event::type_control_change:
661     case Event::type_channel_pressure:
662     case Event::type_pitchbend:
663 schoenebeck 2611 if (pChannel->pScript->handlerController)
664     ProcessEventByScript(pChannel, itEvent, pChannel->pScript->handlerController);
665 schoenebeck 2594 break;
666     case Event::type_note_pressure:
667     //TODO: ...
668     break;
669     }
670     }
671     }
672    
673     // now process all events regularly
674 iliev 2012 {
675     RTList<Event>::Iterator itEvent = pChannel->pEvents->first();
676     RTList<Event>::Iterator end = pChannel->pEvents->end();
677     for (; itEvent != end; ++itEvent) {
678     switch (itEvent->Type) {
679     case Event::type_note_on:
680     dmsg(5,("Engine: Note on received\n"));
681     ProcessNoteOn((EngineChannel*)itEvent->pEngineChannel, itEvent);
682     break;
683     case Event::type_note_off:
684     dmsg(5,("Engine: Note off received\n"));
685     ProcessNoteOff((EngineChannel*)itEvent->pEngineChannel, itEvent);
686     break;
687     case Event::type_control_change:
688     dmsg(5,("Engine: MIDI CC received\n"));
689     ProcessControlChange((EngineChannel*)itEvent->pEngineChannel, itEvent);
690     break;
691 schoenebeck 2559 case Event::type_channel_pressure:
692     dmsg(5,("Engine: MIDI Chan. Pressure received\n"));
693     ProcessChannelPressure((EngineChannel*)itEvent->pEngineChannel, itEvent);
694     break;
695     case Event::type_note_pressure:
696     dmsg(5,("Engine: MIDI Note Pressure received\n"));
697     ProcessPolyphonicKeyPressure((EngineChannel*)itEvent->pEngineChannel, itEvent);
698     break;
699 iliev 2012 case Event::type_pitchbend:
700     dmsg(5,("Engine: Pitchbend received\n"));
701     ProcessPitchbend(static_cast<AbstractEngineChannel*>(itEvent->pEngineChannel), itEvent);
702     break;
703     }
704     }
705     }
706    
707     // reset voice stealing for the next engine channel (or next audio fragment)
708     itLastStolenVoice = VoiceIterator();
709     itLastStolenVoiceGlobally = VoiceIterator();
710     iuiLastStolenKey = RTList<uint>::Iterator();
711     iuiLastStolenKeyGlobally = RTList<uint>::Iterator();
712     pLastStolenChannel = NULL;
713     }
714    
715 schoenebeck 2594 /** @brief Call instrument script's event handler for this event.
716     *
717     * Causes a new execution instance of the currently loaded real-time
718     * instrument script's event handler (callback) to be spawned for
719     * the given MIDI event.
720     *
721     * @param pChannel - engine channel on which the MIDI event occured
722     * @param itEvent - MIDI event that causes this new script execution
723     * @param pEventHandler - script's event handler to be executed
724     */
725     void ProcessEventByScript(AbstractEngineChannel* pChannel, RTList<Event>::Iterator& itEvent, VMEventHandler* pEventHandler) {
726     RTList<ScriptEvent>::Iterator itScriptEvent =
727 schoenebeck 2611 pChannel->pScript->pEvents->allocAppend();
728 schoenebeck 2594
729     if (!itScriptEvent) return; // no free script event left for execution
730    
731     // fill the list of script handlers to be executed by this event
732     int i = 0;
733     itScriptEvent->handlers[i++] = pEventHandler; // actual event handler (i.e. note, controller)
734     itScriptEvent->handlers[i] = NULL; // NULL termination of list
735    
736     // initialize/reset other members
737     itScriptEvent->cause = *itEvent;
738 schoenebeck 2598 itScriptEvent->id = pEventPool->getID(itEvent);
739 schoenebeck 2594 itScriptEvent->currentHandler = 0;
740     itScriptEvent->executionSlices = 0;
741    
742     // run script handler(s)
743     VMExecStatus_t res = pScriptVM->exec(
744 schoenebeck 2611 pChannel->pScript->parserContext, &*itScriptEvent
745 schoenebeck 2594 );
746    
747     // in case the script was suspended, keep it on the allocated
748     // ScriptEvent list to be continued on the next audio cycle,
749     // otherwise if execution has been finished, free it for a new
750     // future script event to be triggered from start
751     if (!(res & VM_EXEC_SUSPENDED))
752 schoenebeck 2611 pChannel->pScript->pEvents->free(itScriptEvent);
753 schoenebeck 2594 }
754    
755     /** @brief Resume execution of instrument script.
756     *
757     * Will be called to resume execution of a real-time instrument
758     * script event which has been suspended in a previous audio
759     * fragment cycle.
760     *
761     * Script execution might be suspended for various reasons. Usually
762     * a script will be suspended if the script called the built-in
763     * "wait()" function, but it might also be suspended automatically
764     * if the script took too much execution time in an audio fragment
765     * cycle. So in the latter case automatic suspension is performed in
766     * order to avoid harm for the sampler's overall real-time
767     * requirements.
768     *
769     * @param pChannel - engine channel this script is running for
770     * @param itScriptEvent - script execution that shall be resumed
771     */
772     void ResumeScriptEvent(AbstractEngineChannel* pChannel, RTList<ScriptEvent>::Iterator& itScriptEvent) {
773     // run script
774     VMExecStatus_t res = pScriptVM->exec(
775 schoenebeck 2611 pChannel->pScript->parserContext, &*itScriptEvent
776 schoenebeck 2594 );
777     // in case the script was again suspended, keep it on the allocated
778     // ScriptEvent list to be continued on the next audio cycle,
779     // otherwise if execution has been finished, free it for a new
780     // future script event to be triggered from start
781     if (!(res & VM_EXEC_SUSPENDED))
782 schoenebeck 2611 pChannel->pScript->pEvents->free(itScriptEvent);
783 schoenebeck 2594 }
784    
785 iliev 2012 /**
786     * Will be called by LaunchVoice() method in case there are no free
787     * voices left. This method will select and kill one old voice for
788     * voice stealing and postpone the note-on event until the selected
789     * voice actually died.
790     *
791     * @param pEngineChannel - engine channel on which this event occured on
792     * @param itNoteOnEvent - key, velocity and time stamp of the event
793     * @returns 0 on success, a value < 0 if no active voice could be picked for voice stealing
794     */
795     int StealVoice(EngineChannel* pEngineChannel, Pool<Event>::Iterator& itNoteOnEvent) {
796     if (VoiceSpawnsLeft <= 0) {
797     dmsg(1,("Max. voice thefts per audio fragment reached (you may raise CONFIG_MAX_VOICES).\n"));
798     return -1;
799     }
800    
801     EngineChannelBase<V, R, I>* pEngineChn = static_cast<EngineChannelBase<V, R, I>*>(pEngineChannel);
802    
803     if (!pEventPool->poolIsEmpty()) {
804    
805     if(!pEngineChn->StealVoice(itNoteOnEvent, &itLastStolenVoice, &iuiLastStolenKey)) {
806     --VoiceSpawnsLeft;
807     return 0;
808     }
809    
810     // if we couldn't steal a voice from the same engine channel then
811     // steal oldest voice on the oldest key from any other engine channel
812     // (the smaller engine channel number, the higher priority)
813     EngineChannelBase<V, R, I>* pSelectedChannel;
814     int iChannelIndex;
815     VoiceIterator itSelectedVoice;
816    
817     // select engine channel
818     if (pLastStolenChannel) {
819     pSelectedChannel = pLastStolenChannel;
820     iChannelIndex = pSelectedChannel->iEngineIndexSelf;
821     } else { // pick the engine channel followed by this engine channel
822     iChannelIndex = (pEngineChn->iEngineIndexSelf + 1) % engineChannels.size();
823     pSelectedChannel = static_cast<EngineChannelBase<V, R, I>*>(engineChannels[iChannelIndex]);
824     }
825    
826     // if we already stole in this fragment, try to proceed on same key
827     if (this->itLastStolenVoiceGlobally) {
828     itSelectedVoice = this->itLastStolenVoiceGlobally;
829     do {
830     ++itSelectedVoice;
831     } while (itSelectedVoice && !itSelectedVoice->IsStealable()); // proceed iterating if voice was created in this fragment cycle
832     }
833    
834     #if CONFIG_DEVMODE
835     EngineChannel* pBegin = pSelectedChannel; // to detect endless loop
836     #endif // CONFIG_DEVMODE
837    
838     // did we find a 'stealable' voice?
839     if (itSelectedVoice && itSelectedVoice->IsStealable()) {
840     // remember which voice we stole, so we can simply proceed on next voice stealing
841     this->itLastStolenVoiceGlobally = itSelectedVoice;
842     } else while (true) { // iterate through engine channels
843     // get (next) oldest key
844     RTList<uint>::Iterator iuiSelectedKey = (this->iuiLastStolenKeyGlobally) ? ++this->iuiLastStolenKeyGlobally : pSelectedChannel->pActiveKeys->first();
845     this->iuiLastStolenKeyGlobally = RTList<uint>::Iterator(); // to prevent endless loop (see line above)
846     while (iuiSelectedKey) {
847     MidiKey* pSelectedKey = &pSelectedChannel->pMIDIKeyInfo[*iuiSelectedKey];
848     itSelectedVoice = pSelectedKey->pActiveVoices->first();
849     // proceed iterating if voice was created in this fragment cycle
850     while (itSelectedVoice && !itSelectedVoice->IsStealable()) ++itSelectedVoice;
851     // found a "stealable" voice ?
852     if (itSelectedVoice && itSelectedVoice->IsStealable()) {
853     // remember which voice on which key on which engine channel we stole, so we can simply proceed on next voice stealing
854     this->iuiLastStolenKeyGlobally = iuiSelectedKey;
855     this->itLastStolenVoiceGlobally = itSelectedVoice;
856     this->pLastStolenChannel = pSelectedChannel;
857     goto stealable_voice_found; // selection succeeded
858     }
859     ++iuiSelectedKey; // get next key on current engine channel
860     }
861     // get next engine channel
862     iChannelIndex = (iChannelIndex + 1) % engineChannels.size();
863     pSelectedChannel = static_cast<EngineChannelBase<V, R, I>*>(engineChannels[iChannelIndex]);
864    
865     #if CONFIG_DEVMODE
866     if (pSelectedChannel == pBegin) {
867     dmsg(1,("FATAL ERROR: voice stealing endless loop!\n"));
868     dmsg(1,("VoiceSpawnsLeft=%d.\n", VoiceSpawnsLeft));
869     dmsg(1,("Exiting.\n"));
870     exit(-1);
871     }
872     #endif // CONFIG_DEVMODE
873     }
874    
875     // jump point if a 'stealable' voice was found
876     stealable_voice_found:
877    
878     #if CONFIG_DEVMODE
879     if (!itSelectedVoice->IsActive()) {
880     dmsg(1,("EngineBase: ERROR, tried to steal a voice which was not active !!!\n"));
881     return -1;
882     }
883     #endif // CONFIG_DEVMODE
884    
885     // now kill the selected voice
886     itSelectedVoice->Kill(itNoteOnEvent);
887    
888     --VoiceSpawnsLeft;
889    
890     return 0; // success
891     }
892     else {
893     dmsg(1,("Event pool emtpy!\n"));
894     return -1;
895     }
896     }
897    
898     void HandleInstrumentChanges() {
899     bool instrumentChanged = false;
900     for (int i = 0; i < engineChannels.size(); i++) {
901     EngineChannelBase<V, R, I>* pEngineChannel =
902     static_cast<EngineChannelBase<V, R, I>*>(engineChannels[i]);
903    
904     // as we're going to (carefully) write some status to the
905     // synchronized struct, we cast away the const
906     InstrumentChangeCmd<R, I>& cmd =
907     const_cast<InstrumentChangeCmd<R, I>&>(pEngineChannel->InstrumentChangeCommandReader.Lock());
908    
909     pEngineChannel->pRegionsInUse = cmd.pRegionsInUse;
910     pEngineChannel->pRegionsInUse->clear();
911    
912     if (cmd.bChangeInstrument) {
913     // change instrument
914     dmsg(5,("Engine: instrument change command received\n"));
915     cmd.bChangeInstrument = false;
916     pEngineChannel->pInstrument = cmd.pInstrument;
917 schoenebeck 2612 pEngineChannel->pScript = cmd.pScript;
918 iliev 2012 instrumentChanged = true;
919    
920     pEngineChannel->MarkAllActiveVoicesAsOrphans();
921 schoenebeck 2611
922     // the script's "init" event handler is only executed
923     // once (when the script is loaded or reloaded)
924     if (pEngineChannel->pScript && pEngineChannel->pScript->handlerInit) {
925     RTList<ScriptEvent>::Iterator itScriptEvent =
926     pEngineChannel->pScript->pEvents->allocAppend();
927    
928     VMExecStatus_t res = pScriptVM->exec(
929     pEngineChannel->pScript->parserContext, &*itScriptEvent
930     );
931    
932     pEngineChannel->pScript->pEvents->free(itScriptEvent);
933     }
934 iliev 2012 }
935     }
936    
937     if (instrumentChanged) {
938     //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
939     ResetSuspendedRegions();
940     }
941     }
942    
943     /**
944     * Render all 'normal' voices (that is voices which were not stolen in
945     * this fragment) on the given engine channel.
946     *
947     * @param pEngineChannel - engine channel on which audio should be
948     * rendered
949     * @param Samples - amount of sample points to be rendered in
950     * this audio fragment cycle
951     */
952     void RenderActiveVoices(EngineChannel* pEngineChannel, uint Samples) {
953     #if !CONFIG_PROCESS_MUTED_CHANNELS
954     if (pEngineChannel->GetMute()) return; // skip if sampler channel is muted
955     #endif
956    
957     EngineChannelBase<V, R, I>* pChannel =
958     static_cast<EngineChannelBase<V, R, I>*>(pEngineChannel);
959     pChannel->RenderActiveVoices(Samples);
960    
961     ActiveVoiceCountTemp += pEngineChannel->GetVoiceCount();
962     }
963    
964     /**
965     * Render all stolen voices (only voices which were stolen in this
966     * fragment) on the given engine channel. Stolen voices are rendered
967     * after all normal voices have been rendered; this is needed to render
968     * audio of those voices which were selected for voice stealing until
969     * the point were the stealing (that is the take over of the voice)
970     * actually happened.
971     *
972     * @param pEngineChannel - engine channel on which audio should be
973     * rendered
974     * @param Samples - amount of sample points to be rendered in
975     * this audio fragment cycle
976     */
977     void RenderStolenVoices(uint Samples) {
978     RTList<Event>::Iterator itVoiceStealEvent = pVoiceStealingQueue->first();
979     RTList<Event>::Iterator end = pVoiceStealingQueue->end();
980     for (; itVoiceStealEvent != end; ++itVoiceStealEvent) {
981     EngineChannelBase<V, R, I>* pEngineChannel =
982     static_cast<EngineChannelBase<V, R, I>*>(itVoiceStealEvent->pEngineChannel);;
983     if (!pEngineChannel->pInstrument) continue; // ignore if no instrument loaded
984     PoolVoiceIterator itNewVoice =
985     LaunchVoice(pEngineChannel, itVoiceStealEvent, itVoiceStealEvent->Param.Note.Layer, itVoiceStealEvent->Param.Note.ReleaseTrigger, false, false);
986     if (itNewVoice) {
987     itNewVoice->Render(Samples);
988     if (itNewVoice->IsActive()) { // still active
989     *(pEngineChannel->pRegionsInUse->allocAppend()) = itNewVoice->GetRegion();
990     ActiveVoiceCountTemp++;
991     pEngineChannel->SetVoiceCount(pEngineChannel->GetVoiceCount() + 1);
992    
993     if (itNewVoice->PlaybackState == Voice::playback_state_disk) {
994     if (itNewVoice->DiskStreamRef.State != Stream::state_unused) {
995     pEngineChannel->SetDiskStreamCount(pEngineChannel->GetDiskStreamCount() + 1);
996     }
997     }
998     } else { // voice reached end, is now inactive
999     pEngineChannel->FreeVoice(itNewVoice); // remove voice from the list of active voices
1000     }
1001     }
1002     else dmsg(1,("EngineBase: ERROR, voice stealing didn't work out!\n"));
1003    
1004     // we need to clear the key's event list explicitly here in case key was never active
1005     MidiKey* pKey = &pEngineChannel->pMIDIKeyInfo[itVoiceStealEvent->Param.Note.Key];
1006     pKey->VoiceTheftsQueued--;
1007     if (!pKey->Active && !pKey->VoiceTheftsQueued) pKey->pEvents->clear();
1008     }
1009     }
1010    
1011     /**
1012     * Free all keys which have turned inactive in this audio fragment, from
1013     * the list of active keys and clear all event lists on that engine
1014     * channel.
1015     *
1016     * @param pEngineChannel - engine channel to cleanup
1017     */
1018     void PostProcess(EngineChannel* pEngineChannel) {
1019     EngineChannelBase<V, R, I>* pChannel =
1020     static_cast<EngineChannelBase<V, R, I>*>(pEngineChannel);
1021     pChannel->FreeAllInactiveKyes();
1022    
1023     // empty the engine channel's own event lists
1024     pChannel->ClearEventLists();
1025     }
1026    
1027 schoenebeck 2121 /**
1028     * Process MIDI control change events with hard coded behavior,
1029     * that is controllers whose behavior is defined independently
1030     * of the actual sampler engine type and instrument.
1031     *
1032     * @param pEngineChannel - engine channel on which the MIDI CC event was received
1033     * @param itControlChangeEvent - the actual MIDI CC event
1034     */
1035 iliev 2012 void ProcessHardcodedControllers (
1036     EngineChannel* pEngineChannel,
1037     Pool<Event>::Iterator& itControlChangeEvent
1038     ) {
1039     EngineChannelBase<V, R, I>* pChannel =
1040     static_cast<EngineChannelBase<V, R, I>*>(pEngineChannel);
1041    
1042     switch (itControlChangeEvent->Param.CC.Controller) {
1043     case 5: { // portamento time
1044     pChannel->PortamentoTime = (float) itControlChangeEvent->Param.CC.Value / 127.0f * (float) CONFIG_PORTAMENTO_TIME_MAX + (float) CONFIG_PORTAMENTO_TIME_MIN;
1045     break;
1046     }
1047 schoenebeck 2121 case 6: { // data entry (currently only used for RPN and NRPN controllers)
1048     //dmsg(1,("DATA ENTRY %d\n", itControlChangeEvent->Param.CC.Value));
1049     if (pChannel->GetMidiRpnController() >= 0) { // RPN controller number was sent previously ...
1050     dmsg(4,("Guess it's an RPN ...\n"));
1051     if (pChannel->GetMidiRpnController() == 2) { // coarse tuning in half tones
1052     int transpose = (int) itControlChangeEvent->Param.CC.Value - 64;
1053     // limit to +- two octaves for now
1054     transpose = RTMath::Min(transpose, 24);
1055     transpose = RTMath::Max(transpose, -24);
1056     pChannel->GlobalTranspose = transpose;
1057     // workaround, so we won't have hanging notes
1058     pChannel->ReleaseAllVoices(itControlChangeEvent);
1059     }
1060     // to prevent other MIDI CC #6 messages to be misenterpreted as RPN controller data
1061     pChannel->ResetMidiRpnController();
1062     } else if (pChannel->GetMidiNrpnController() >= 0) { // NRPN controller number was sent previously ...
1063     dmsg(4,("Guess it's an NRPN ...\n"));
1064     const int NrpnCtrlMSB = pChannel->GetMidiNrpnController() >> 8;
1065     const int NrpnCtrlLSB = pChannel->GetMidiNrpnController() & 0xff;
1066     dmsg(4,("NRPN MSB=%d LSB=%d Data=%d\n", NrpnCtrlMSB, NrpnCtrlLSB, itControlChangeEvent->Param.CC.Value));
1067     switch (NrpnCtrlMSB) {
1068     case 0x1a: { // volume level of note (Roland GS NRPN)
1069     const uint note = NrpnCtrlLSB;
1070     const uint vol = itControlChangeEvent->Param.CC.Value;
1071     dmsg(4,("Note Volume NRPN received (note=%d,vol=%d).\n", note, vol));
1072     if (note < 128 && vol < 128)
1073     pChannel->pMIDIKeyInfo[note].Volume = VolumeCurve[vol];
1074     break;
1075     }
1076     case 0x1c: { // panpot of note (Roland GS NRPN)
1077     const uint note = NrpnCtrlLSB;
1078     const uint pan = itControlChangeEvent->Param.CC.Value;
1079     dmsg(4,("Note Pan NRPN received (note=%d,pan=%d).\n", note, pan));
1080     if (note < 128 && pan < 128) {
1081     pChannel->pMIDIKeyInfo[note].PanLeft = PanCurve[128 - pan];
1082     pChannel->pMIDIKeyInfo[note].PanRight = PanCurve[pan];
1083     }
1084     break;
1085     }
1086     case 0x1d: { // reverb send of note (Roland GS NRPN)
1087     const uint note = NrpnCtrlLSB;
1088     const float reverb = float(itControlChangeEvent->Param.CC.Value) / 127.0f;
1089     dmsg(4,("Note Reverb Send NRPN received (note=%d,send=%d).\n", note, reverb));
1090     if (note < 128)
1091     pChannel->pMIDIKeyInfo[note].ReverbSend = reverb;
1092     break;
1093     }
1094     case 0x1e: { // chorus send of note (Roland GS NRPN)
1095     const uint note = NrpnCtrlLSB;
1096     const float chorus = float(itControlChangeEvent->Param.CC.Value) / 127.0f;
1097     dmsg(4,("Note Chorus Send NRPN received (note=%d,send=%d).\n", note, chorus));
1098     if (note < 128)
1099     pChannel->pMIDIKeyInfo[note].ChorusSend = chorus;
1100     break;
1101     }
1102     }
1103     // to prevent other MIDI CC #6 messages to be misenterpreted as NRPN controller data
1104     pChannel->ResetMidiNrpnController();
1105 iliev 2012 }
1106     break;
1107     }
1108     case 7: { // volume
1109     //TODO: not sample accurate yet
1110     pChannel->MidiVolume = VolumeCurve[itControlChangeEvent->Param.CC.Value];
1111     pChannel->bStatusChanged = true; // engine channel status has changed, so set notify flag
1112     break;
1113     }
1114     case 10: { // panpot
1115     //TODO: not sample accurate yet
1116     pChannel->iLastPanRequest = itControlChangeEvent->Param.CC.Value;
1117     break;
1118     }
1119     case 64: { // sustain
1120     if (itControlChangeEvent->Param.CC.Value >= 64 && !pChannel->SustainPedal) {
1121     dmsg(4,("DAMPER (RIGHT) PEDAL DOWN\n"));
1122     pChannel->SustainPedal = true;
1123     pChannel->listeners.PreProcessSustainPedalDown();
1124    
1125     #if !CONFIG_PROCESS_MUTED_CHANNELS
1126     if (pEngineChannel->GetMute()) { // skip if sampler channel is muted
1127     pChannel->listeners.PostProcessSustainPedalDown();
1128     return;
1129     }
1130     #endif
1131    
1132     pChannel->ProcessSustainPedalDown(itControlChangeEvent);
1133     pChannel->listeners.PostProcessSustainPedalDown();
1134     }
1135     if (itControlChangeEvent->Param.CC.Value < 64 && pChannel->SustainPedal) {
1136     dmsg(4,("DAMPER (RIGHT) PEDAL UP\n"));
1137     pChannel->SustainPedal = false;
1138     pChannel->listeners.PreProcessSustainPedalUp();
1139    
1140     #if !CONFIG_PROCESS_MUTED_CHANNELS
1141     if (pChannel->GetMute()) { // skip if sampler channel is muted
1142     pChannel->listeners.PostProcessSustainPedalUp();
1143     return;
1144     }
1145     #endif
1146    
1147     pChannel->ProcessSustainPedalUp(itControlChangeEvent);
1148     pChannel->listeners.PostProcessSustainPedalUp();
1149     }
1150     break;
1151     }
1152     case 65: { // portamento on / off
1153     const bool bPortamento = itControlChangeEvent->Param.CC.Value >= 64;
1154     if (bPortamento != pChannel->PortamentoMode)
1155     KillAllVoices(pChannel, itControlChangeEvent);
1156     pChannel->PortamentoMode = bPortamento;
1157     break;
1158     }
1159     case 66: { // sostenuto
1160     if (itControlChangeEvent->Param.CC.Value >= 64 && !pChannel->SostenutoPedal) {
1161     dmsg(4,("SOSTENUTO (CENTER) PEDAL DOWN\n"));
1162     pChannel->SostenutoPedal = true;
1163     pChannel->listeners.PreProcessSostenutoPedalDown();
1164    
1165     #if !CONFIG_PROCESS_MUTED_CHANNELS
1166     if (pEngineChannel->GetMute()) { // skip if sampler channel is muted
1167     pChannel->listeners.PostProcessSostenutoPedalDown();
1168     return;
1169     }
1170     #endif
1171    
1172     pChannel->ProcessSostenutoPedalDown();
1173     pChannel->listeners.PostProcessSostenutoPedalDown();
1174     }
1175     if (itControlChangeEvent->Param.CC.Value < 64 && pChannel->SostenutoPedal) {
1176     dmsg(4,("SOSTENUTO (CENTER) PEDAL UP\n"));
1177     pChannel->SostenutoPedal = false;
1178     pChannel->listeners.PreProcessSostenutoPedalUp();
1179    
1180     #if !CONFIG_PROCESS_MUTED_CHANNELS
1181     if (pEngineChannel->GetMute()) { // skip if sampler channel is muted
1182     pChannel->listeners.PostProcessSostenutoPedalUp();
1183     return;
1184     }
1185     #endif
1186    
1187     pChannel->ProcessSostenutoPedalUp(itControlChangeEvent);
1188     pChannel->listeners.PostProcessSostenutoPedalUp();
1189     }
1190     break;
1191     }
1192 schoenebeck 2121 case 98: { // NRPN controller LSB
1193     dmsg(4,("NRPN LSB %d\n", itControlChangeEvent->Param.CC.Value));
1194     pEngineChannel->SetMidiNrpnControllerLsb(itControlChangeEvent->Param.CC.Value);
1195     break;
1196     }
1197     case 99: { // NRPN controller MSB
1198     dmsg(4,("NRPN MSB %d\n", itControlChangeEvent->Param.CC.Value));
1199     pEngineChannel->SetMidiNrpnControllerMsb(itControlChangeEvent->Param.CC.Value);
1200     break;
1201     }
1202 iliev 2012 case 100: { // RPN controller LSB
1203 schoenebeck 2121 dmsg(4,("RPN LSB %d\n", itControlChangeEvent->Param.CC.Value));
1204 iliev 2012 pEngineChannel->SetMidiRpnControllerLsb(itControlChangeEvent->Param.CC.Value);
1205     break;
1206     }
1207     case 101: { // RPN controller MSB
1208 schoenebeck 2121 dmsg(4,("RPN MSB %d\n", itControlChangeEvent->Param.CC.Value));
1209 iliev 2012 pEngineChannel->SetMidiRpnControllerMsb(itControlChangeEvent->Param.CC.Value);
1210     break;
1211     }
1212    
1213    
1214     // Channel Mode Messages
1215    
1216     case 120: { // all sound off
1217     KillAllVoices(pEngineChannel, itControlChangeEvent);
1218     break;
1219     }
1220     case 121: { // reset all controllers
1221     pChannel->ResetControllers();
1222     break;
1223     }
1224     case 123: { // all notes off
1225     #if CONFIG_PROCESS_ALL_NOTES_OFF
1226     pChannel->ReleaseAllVoices(itControlChangeEvent);
1227     #endif // CONFIG_PROCESS_ALL_NOTES_OFF
1228     break;
1229     }
1230     case 126: { // mono mode on
1231     if (!pChannel->SoloMode)
1232     KillAllVoices(pEngineChannel, itControlChangeEvent);
1233     pChannel->SoloMode = true;
1234     break;
1235     }
1236     case 127: { // poly mode on
1237     if (pChannel->SoloMode)
1238     KillAllVoices(pEngineChannel, itControlChangeEvent);
1239     pChannel->SoloMode = false;
1240     break;
1241     }
1242     }
1243     }
1244    
1245     virtual D* CreateDiskThread() = 0;
1246    
1247     /**
1248     * Assigns and triggers a new voice for the respective MIDI key.
1249     *
1250     * @param pEngineChannel - engine channel on which this event occured on
1251     * @param itNoteOnEvent - key, velocity and time stamp of the event
1252     */
1253     virtual void ProcessNoteOn(EngineChannel* pEngineChannel, Pool<Event>::Iterator& itNoteOnEvent) {
1254     EngineChannelBase<V, R, I>* pChannel =
1255     static_cast<EngineChannelBase<V, R, I>*>(pEngineChannel);
1256    
1257     //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
1258     int k = itNoteOnEvent->Param.Note.Key + pChannel->GlobalTranspose;
1259     if (k < 0 || k > 127) return; //ignore keys outside the key range
1260    
1261     itNoteOnEvent->Param.Note.Key += pChannel->GlobalTranspose;
1262     int vel = itNoteOnEvent->Param.Note.Velocity;
1263    
1264     const int key = itNoteOnEvent->Param.Note.Key;
1265     MidiKey* pKey = &pChannel->pMIDIKeyInfo[key];
1266    
1267     pChannel->listeners.PreProcessNoteOn(key, vel);
1268     #if !CONFIG_PROCESS_MUTED_CHANNELS
1269     if (pEngineChannel->GetMute()) { // skip if sampler channel is muted
1270     pChannel->listeners.PostProcessNoteOn(key, vel);
1271     return;
1272     }
1273     #endif
1274    
1275     if (!pChannel->pInstrument) {
1276     pChannel->listeners.PostProcessNoteOn(key, vel);
1277     return; // ignore if no instrument loaded
1278     }
1279    
1280     // move note on event to the key's own event list
1281     RTList<Event>::Iterator itNoteOnEventOnKeyList = itNoteOnEvent.moveToEndOf(pKey->pEvents);
1282    
1283     // if Solo Mode then kill all already active voices
1284     if (pChannel->SoloMode) {
1285     Pool<uint>::Iterator itYoungestKey = pChannel->pActiveKeys->last();
1286     if (itYoungestKey) {
1287     const int iYoungestKey = *itYoungestKey;
1288     const MidiKey* pOtherKey = &pChannel->pMIDIKeyInfo[iYoungestKey];
1289     if (pOtherKey->Active) {
1290     // get final portamento position of currently active voice
1291     if (pChannel->PortamentoMode) {
1292     VoiceIterator itVoice = pOtherKey->pActiveVoices->last();
1293     if (itVoice) itVoice->UpdatePortamentoPos(itNoteOnEventOnKeyList);
1294     }
1295     // kill all voices on the (other) key
1296     VoiceIterator itVoiceToBeKilled = pOtherKey->pActiveVoices->first();
1297     VoiceIterator end = pOtherKey->pActiveVoices->end();
1298     for (; itVoiceToBeKilled != end; ++itVoiceToBeKilled) {
1299 persson 2115 if (!(itVoiceToBeKilled->Type & Voice::type_release_trigger))
1300 iliev 2012 itVoiceToBeKilled->Kill(itNoteOnEventOnKeyList);
1301     }
1302     }
1303     }
1304     // set this key as 'currently active solo key'
1305     pChannel->SoloKey = key;
1306     }
1307    
1308     pChannel->ProcessKeySwitchChange(key);
1309    
1310     pKey->KeyPressed = true; // the MIDI key was now pressed down
1311     pKey->Velocity = itNoteOnEventOnKeyList->Param.Note.Velocity;
1312     pKey->NoteOnTime = FrameTime + itNoteOnEventOnKeyList->FragmentPos(); // will be used to calculate note length
1313    
1314     // cancel release process of voices on this key if needed
1315     if (pKey->Active && !pChannel->SustainPedal) {
1316     RTList<Event>::Iterator itCancelReleaseEvent = pKey->pEvents->allocAppend();
1317     if (itCancelReleaseEvent) {
1318     *itCancelReleaseEvent = *itNoteOnEventOnKeyList; // copy event
1319     itCancelReleaseEvent->Type = Event::type_cancel_release; // transform event type
1320     }
1321     else dmsg(1,("Event pool emtpy!\n"));
1322     }
1323    
1324     TriggerNewVoices(pEngineChannel, itNoteOnEventOnKeyList);
1325    
1326     // if neither a voice was spawned or postponed then remove note on event from key again
1327     if (!pKey->Active && !pKey->VoiceTheftsQueued)
1328     pKey->pEvents->free(itNoteOnEventOnKeyList);
1329    
1330     if (!pChannel->SoloMode || pChannel->PortamentoPos < 0.0f) pChannel->PortamentoPos = (float) key;
1331 persson 2043 if (pKey->pRoundRobinIndex) {
1332     (*pKey->pRoundRobinIndex)++; // counter specific for the key or region
1333     pChannel->RoundRobinIndex++; // common counter for the channel
1334     }
1335 iliev 2012 pChannel->listeners.PostProcessNoteOn(key, vel);
1336     }
1337    
1338     /**
1339     * Allocate and trigger new voice(s) for the key.
1340     */
1341     virtual void TriggerNewVoices (
1342     EngineChannel* pEngineChannel,
1343     RTList<Event>::Iterator& itNoteOnEvent,
1344     bool HandleKeyGroupConflicts = true
1345     ) = 0;
1346    
1347     /**
1348     * Allocate and trigger release voice(s) for the key.
1349     */
1350     virtual void TriggerReleaseVoices (
1351     EngineChannel* pEngineChannel,
1352     RTList<Event>::Iterator& itNoteOffEvent
1353     ) = 0;
1354    
1355     /**
1356     * Releases the voices on the given key if sustain pedal is not pressed.
1357     * If sustain is pressed, the release of the note will be postponed until
1358     * sustain pedal will be released or voice turned inactive by itself (e.g.
1359     * due to completion of sample playback).
1360     *
1361     * @param pEngineChannel - engine channel on which this event occured on
1362     * @param itNoteOffEvent - key, velocity and time stamp of the event
1363     */
1364     virtual void ProcessNoteOff(EngineChannel* pEngineChannel, Pool<Event>::Iterator& itNoteOffEvent) {
1365     EngineChannelBase<V, R, I>* pChannel = static_cast<EngineChannelBase<V, R, I>*>(pEngineChannel);
1366    
1367     int k = itNoteOffEvent->Param.Note.Key + pChannel->GlobalTranspose;
1368     if (k < 0 || k > 127) return; //ignore keys outside the key range
1369    
1370     //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
1371     itNoteOffEvent->Param.Note.Key += pChannel->GlobalTranspose;
1372     int vel = itNoteOffEvent->Param.Note.Velocity;
1373    
1374     const int iKey = itNoteOffEvent->Param.Note.Key;
1375     MidiKey* pKey = &pChannel->pMIDIKeyInfo[iKey];
1376    
1377     pChannel->listeners.PreProcessNoteOff(iKey, vel);
1378    
1379     #if !CONFIG_PROCESS_MUTED_CHANNELS
1380     if (pEngineChannel->GetMute()) { // skip if sampler channel is muted
1381     pChannel->listeners.PostProcessNoteOff(iKey, vel);
1382     return;
1383     }
1384     #endif
1385    
1386     pKey->KeyPressed = false; // the MIDI key was now released
1387    
1388     // move event to the key's own event list
1389     RTList<Event>::Iterator itNoteOffEventOnKeyList = itNoteOffEvent.moveToEndOf(pKey->pEvents);
1390    
1391     bool bShouldRelease = pKey->Active && pChannel->ShouldReleaseVoice(itNoteOffEventOnKeyList->Param.Note.Key);
1392    
1393     // in case Solo Mode is enabled, kill all voices on this key and respawn a voice on the highest pressed key (if any)
1394     if (pChannel->SoloMode && pChannel->pInstrument) { //TODO: this feels like too much code just for handling solo mode :P
1395     bool bOtherKeysPressed = false;
1396     if (iKey == pChannel->SoloKey) {
1397     pChannel->SoloKey = -1;
1398     // if there's still a key pressed down, respawn a voice (group) on the highest key
1399     for (int i = 127; i > 0; i--) {
1400     MidiKey* pOtherKey = &pChannel->pMIDIKeyInfo[i];
1401     if (pOtherKey->KeyPressed) {
1402     bOtherKeysPressed = true;
1403     // make the other key the new 'currently active solo key'
1404     pChannel->SoloKey = i;
1405     // get final portamento position of currently active voice
1406     if (pChannel->PortamentoMode) {
1407     VoiceIterator itVoice = pKey->pActiveVoices->first();
1408     if (itVoice) itVoice->UpdatePortamentoPos(itNoteOffEventOnKeyList);
1409     }
1410     // create a pseudo note on event
1411     RTList<Event>::Iterator itPseudoNoteOnEvent = pOtherKey->pEvents->allocAppend();
1412     if (itPseudoNoteOnEvent) {
1413     // copy event
1414     *itPseudoNoteOnEvent = *itNoteOffEventOnKeyList;
1415     // transform event to a note on event
1416     itPseudoNoteOnEvent->Type = Event::type_note_on;
1417     itPseudoNoteOnEvent->Param.Note.Key = i;
1418     itPseudoNoteOnEvent->Param.Note.Velocity = pOtherKey->Velocity;
1419     // allocate and trigger new voice(s) for the other key
1420     TriggerNewVoices(pChannel, itPseudoNoteOnEvent, false);
1421     // if neither a voice was spawned or postponed then remove note on event from key again
1422     if (!pOtherKey->Active && !pOtherKey->VoiceTheftsQueued)
1423     pOtherKey->pEvents->free(itPseudoNoteOnEvent);
1424    
1425     } else dmsg(1,("Could not respawn voice, no free event left\n"));
1426     break; // done
1427     }
1428     }
1429     }
1430     if (bOtherKeysPressed) {
1431     if (pKey->Active) { // kill all voices on this key
1432     bShouldRelease = false; // no need to release, as we kill it here
1433     VoiceIterator itVoiceToBeKilled = pKey->pActiveVoices->first();
1434     VoiceIterator end = pKey->pActiveVoices->end();
1435     for (; itVoiceToBeKilled != end; ++itVoiceToBeKilled) {
1436 persson 2115 if (!(itVoiceToBeKilled->Type & Voice::type_release_trigger))
1437 iliev 2012 itVoiceToBeKilled->Kill(itNoteOffEventOnKeyList);
1438     }
1439     }
1440     } else pChannel->PortamentoPos = -1.0f;
1441     }
1442    
1443     // if no solo mode (the usual case) or if solo mode and no other key pressed, then release voices on this key if needed
1444     if (bShouldRelease) {
1445     itNoteOffEventOnKeyList->Type = Event::type_release; // transform event type
1446    
1447     // spawn release triggered voice(s) if needed
1448     if (pKey->ReleaseTrigger && pChannel->pInstrument) {
1449     TriggerReleaseVoices(pChannel, itNoteOffEventOnKeyList);
1450     pKey->ReleaseTrigger = false;
1451     }
1452     }
1453    
1454     // if neither a voice was spawned or postponed on this key then remove note off event from key again
1455     if (!pKey->Active && !pKey->VoiceTheftsQueued)
1456     pKey->pEvents->free(itNoteOffEventOnKeyList);
1457    
1458     pChannel->listeners.PostProcessNoteOff(iKey, vel);
1459     }
1460    
1461     /**
1462     * Reset all voices and disk thread and clear input event queue and all
1463     * control and status variables. This method is protected by a mutex.
1464     */
1465     virtual void ResetInternal() {
1466 persson 2427 LockGuard lock(ResetInternalMutex);
1467 iliev 2012
1468     // make sure that the engine does not get any sysex messages
1469     // while it's reseting
1470     bool sysexDisabled = MidiInputPort::RemoveSysexListener(this);
1471     SetVoiceCount(0);
1472     ActiveVoiceCountMax = 0;
1473    
1474     // reset voice stealing parameters
1475     pVoiceStealingQueue->clear();
1476     itLastStolenVoice = VoiceIterator();
1477     itLastStolenVoiceGlobally = VoiceIterator();
1478     iuiLastStolenKey = RTList<uint>::Iterator();
1479     iuiLastStolenKeyGlobally = RTList<uint>::Iterator();
1480     pLastStolenChannel = NULL;
1481    
1482     // reset all voices
1483     for (VoiceIterator iterVoice = pVoicePool->allocAppend(); iterVoice == pVoicePool->last(); iterVoice = pVoicePool->allocAppend()) {
1484     iterVoice->Reset();
1485     }
1486     pVoicePool->clear();
1487    
1488     // reset disk thread
1489     if (pDiskThread) pDiskThread->Reset();
1490    
1491     // delete all input events
1492     pEventQueue->init();
1493     pSysexBuffer->init();
1494     if (sysexDisabled) MidiInputPort::AddSysexListener(this);
1495     }
1496    
1497     /**
1498     * Kills all voices on an engine channel as soon as possible. Voices
1499     * won't get into release state, their volume level will be ramped down
1500     * as fast as possible.
1501     *
1502     * @param pEngineChannel - engine channel on which all voices should be killed
1503     * @param itKillEvent - event which caused this killing of all voices
1504     */
1505     virtual void KillAllVoices(EngineChannel* pEngineChannel, Pool<Event>::Iterator& itKillEvent) {
1506     EngineChannelBase<V, R, I>* pChannel = static_cast<EngineChannelBase<V, R, I>*>(pEngineChannel);
1507     int count = pChannel->KillAllVoices(itKillEvent);
1508     VoiceSpawnsLeft -= count; //FIXME: just a temporary workaround, we should check the cause in StealVoice() instead
1509     }
1510    
1511     /**
1512     * Allocates and triggers a new voice. This method will usually be
1513     * called by the ProcessNoteOn() method and by the voices itself
1514     * (e.g. to spawn further voices on the same key for layered sounds).
1515     *
1516     * @param pEngineChannel - engine channel on which this event occured on
1517     * @param itNoteOnEvent - key, velocity and time stamp of the event
1518     * @param iLayer - layer index for the new voice (optional - only
1519     * in case of layered sounds of course)
1520     * @param ReleaseTriggerVoice - if new voice is a release triggered voice
1521     * (optional, default = false)
1522     * @param VoiceStealing - if voice stealing should be performed
1523     * when there is no free voice
1524     * (optional, default = true)
1525     * @param HandleKeyGroupConflicts - if voices should be killed due to a
1526     * key group conflict
1527     * @returns pointer to new voice or NULL if there was no free voice or
1528     * if the voice wasn't triggered (for example when no region is
1529     * defined for the given key).
1530     */
1531     virtual PoolVoiceIterator LaunchVoice (
1532     EngineChannel* pEngineChannel,
1533     Pool<Event>::Iterator& itNoteOnEvent,
1534     int iLayer,
1535     bool ReleaseTriggerVoice,
1536     bool VoiceStealing,
1537     bool HandleKeyGroupConflicts
1538     ) = 0;
1539    
1540 iliev 2015 virtual int GetMinFadeOutSamples() { return MinFadeOutSamples; }
1541    
1542 iliev 2027 int InitNewVoice (
1543     EngineChannelBase<V, R, I>* pChannel,
1544     R* pRegion,
1545     Pool<Event>::Iterator& itNoteOnEvent,
1546     Voice::type_t VoiceType,
1547     int iLayer,
1548     int iKeyGroup,
1549     bool ReleaseTriggerVoice,
1550     bool VoiceStealing,
1551     typename Pool<V>::Iterator& itNewVoice
1552     ) {
1553     int key = itNoteOnEvent->Param.Note.Key;
1554     typename MidiKeyboardManager<V>::MidiKey* pKey = &pChannel->pMIDIKeyInfo[key];
1555     if (itNewVoice) {
1556     // launch the new voice
1557     if (itNewVoice->Trigger(pChannel, itNoteOnEvent, pChannel->Pitch, pRegion, VoiceType, iKeyGroup) < 0) {
1558     dmsg(4,("Voice not triggered\n"));
1559     pKey->pActiveVoices->free(itNewVoice);
1560     }
1561     else { // on success
1562     --VoiceSpawnsLeft;
1563     if (!pKey->Active) { // mark as active key
1564     pKey->Active = true;
1565     pKey->itSelf = pChannel->pActiveKeys->allocAppend();
1566     *pKey->itSelf = itNoteOnEvent->Param.Note.Key;
1567     }
1568 persson 2115 if (itNewVoice->Type & Voice::type_release_trigger_required) pKey->ReleaseTrigger = true; // mark key for the need of release triggered voice(s)
1569 iliev 2027 return 0; // success
1570     }
1571     }
1572     else if (VoiceStealing) {
1573     // try to steal one voice
1574     int result = StealVoice(pChannel, itNoteOnEvent);
1575     if (!result) { // voice stolen successfully
1576     // put note-on event into voice-stealing queue, so it will be reprocessed after killed voice died
1577     RTList<Event>::Iterator itStealEvent = pVoiceStealingQueue->allocAppend();
1578     if (itStealEvent) {
1579     *itStealEvent = *itNoteOnEvent; // copy event
1580     itStealEvent->Param.Note.Layer = iLayer;
1581     itStealEvent->Param.Note.ReleaseTrigger = ReleaseTriggerVoice;
1582     pKey->VoiceTheftsQueued++;
1583     }
1584     else dmsg(1,("Voice stealing queue full!\n"));
1585     }
1586     }
1587    
1588     return -1;
1589     }
1590 schoenebeck 2448
1591     /**
1592     * Checks whether scale tuning setting has been changed since last
1593     * time this method was called, if yes, it recalculates the pitch
1594     * for all active voices.
1595     */
1596     void ProcessScaleTuningChange() {
1597     const bool changed = ScaleTuningChanged.readAndReset();
1598     if (!changed) return;
1599    
1600     for (int i = 0; i < engineChannels.size(); i++) {
1601     EngineChannelBase<V, R, I>* channel =
1602     static_cast<EngineChannelBase<V, R, I>*>(engineChannels[i]);
1603     channel->OnScaleTuningChanged();
1604     }
1605     }
1606 iliev 2027
1607 iliev 2012 private:
1608     Pool<V>* pVoicePool; ///< Contains all voices that can be activated.
1609     Pool<RR*> SuspendedRegions;
1610     Mutex SuspendedRegionsMutex;
1611     Condition SuspensionChangeOngoing;
1612     RR* pPendingRegionSuspension;
1613     RR* pPendingRegionResumption;
1614     int iPendingStreamDeletions;
1615     };
1616    
1617     template <class V, class RR, class R, class D, class IM, class I>
1618     IM EngineBase<V, RR, R, D, IM, I>::instruments;
1619    
1620     } // namespace LinuxSampler
1621    
1622     #endif /* __LS_ENGINEBASE_H__ */
1623    

  ViewVC Help
Powered by ViewVC