/[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 2559 - (hide annotations) (download) (as text)
Sun May 18 17:38:25 2014 UTC (9 years, 10 months ago) by schoenebeck
File MIME type: text/x-c++hdr
File size: 81126 byte(s)
* Aftertouch: extended API to explicitly handle channel pressure and
  polyphonic key pressure events (so far polyphonic pressure was not
  supported at all, and channel pressure was rerouted as CC128 but not
  used so far).
* Gig Engine: Fixed support for 'aftertouch' attenuation controller.
* Bumped version (1.0.0.svn39).

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     // process events
635     {
636     RTList<Event>::Iterator itEvent = pChannel->pEvents->first();
637     RTList<Event>::Iterator end = pChannel->pEvents->end();
638     for (; itEvent != end; ++itEvent) {
639     switch (itEvent->Type) {
640     case Event::type_note_on:
641     dmsg(5,("Engine: Note on received\n"));
642     ProcessNoteOn((EngineChannel*)itEvent->pEngineChannel, itEvent);
643     break;
644     case Event::type_note_off:
645     dmsg(5,("Engine: Note off received\n"));
646     ProcessNoteOff((EngineChannel*)itEvent->pEngineChannel, itEvent);
647     break;
648     case Event::type_control_change:
649     dmsg(5,("Engine: MIDI CC received\n"));
650     ProcessControlChange((EngineChannel*)itEvent->pEngineChannel, itEvent);
651     break;
652 schoenebeck 2559 case Event::type_channel_pressure:
653     dmsg(5,("Engine: MIDI Chan. Pressure received\n"));
654     ProcessChannelPressure((EngineChannel*)itEvent->pEngineChannel, itEvent);
655     break;
656     case Event::type_note_pressure:
657     dmsg(5,("Engine: MIDI Note Pressure received\n"));
658     ProcessPolyphonicKeyPressure((EngineChannel*)itEvent->pEngineChannel, itEvent);
659     break;
660 iliev 2012 case Event::type_pitchbend:
661     dmsg(5,("Engine: Pitchbend received\n"));
662     ProcessPitchbend(static_cast<AbstractEngineChannel*>(itEvent->pEngineChannel), itEvent);
663     break;
664     }
665     }
666     }
667    
668     // reset voice stealing for the next engine channel (or next audio fragment)
669     itLastStolenVoice = VoiceIterator();
670     itLastStolenVoiceGlobally = VoiceIterator();
671     iuiLastStolenKey = RTList<uint>::Iterator();
672     iuiLastStolenKeyGlobally = RTList<uint>::Iterator();
673     pLastStolenChannel = NULL;
674     }
675    
676     /**
677     * Will be called by LaunchVoice() method in case there are no free
678     * voices left. This method will select and kill one old voice for
679     * voice stealing and postpone the note-on event until the selected
680     * voice actually died.
681     *
682     * @param pEngineChannel - engine channel on which this event occured on
683     * @param itNoteOnEvent - key, velocity and time stamp of the event
684     * @returns 0 on success, a value < 0 if no active voice could be picked for voice stealing
685     */
686     int StealVoice(EngineChannel* pEngineChannel, Pool<Event>::Iterator& itNoteOnEvent) {
687     if (VoiceSpawnsLeft <= 0) {
688     dmsg(1,("Max. voice thefts per audio fragment reached (you may raise CONFIG_MAX_VOICES).\n"));
689     return -1;
690     }
691    
692     EngineChannelBase<V, R, I>* pEngineChn = static_cast<EngineChannelBase<V, R, I>*>(pEngineChannel);
693    
694     if (!pEventPool->poolIsEmpty()) {
695    
696     if(!pEngineChn->StealVoice(itNoteOnEvent, &itLastStolenVoice, &iuiLastStolenKey)) {
697     --VoiceSpawnsLeft;
698     return 0;
699     }
700    
701     // if we couldn't steal a voice from the same engine channel then
702     // steal oldest voice on the oldest key from any other engine channel
703     // (the smaller engine channel number, the higher priority)
704     EngineChannelBase<V, R, I>* pSelectedChannel;
705     int iChannelIndex;
706     VoiceIterator itSelectedVoice;
707    
708     // select engine channel
709     if (pLastStolenChannel) {
710     pSelectedChannel = pLastStolenChannel;
711     iChannelIndex = pSelectedChannel->iEngineIndexSelf;
712     } else { // pick the engine channel followed by this engine channel
713     iChannelIndex = (pEngineChn->iEngineIndexSelf + 1) % engineChannels.size();
714     pSelectedChannel = static_cast<EngineChannelBase<V, R, I>*>(engineChannels[iChannelIndex]);
715     }
716    
717     // if we already stole in this fragment, try to proceed on same key
718     if (this->itLastStolenVoiceGlobally) {
719     itSelectedVoice = this->itLastStolenVoiceGlobally;
720     do {
721     ++itSelectedVoice;
722     } while (itSelectedVoice && !itSelectedVoice->IsStealable()); // proceed iterating if voice was created in this fragment cycle
723     }
724    
725     #if CONFIG_DEVMODE
726     EngineChannel* pBegin = pSelectedChannel; // to detect endless loop
727     #endif // CONFIG_DEVMODE
728    
729     // did we find a 'stealable' voice?
730     if (itSelectedVoice && itSelectedVoice->IsStealable()) {
731     // remember which voice we stole, so we can simply proceed on next voice stealing
732     this->itLastStolenVoiceGlobally = itSelectedVoice;
733     } else while (true) { // iterate through engine channels
734     // get (next) oldest key
735     RTList<uint>::Iterator iuiSelectedKey = (this->iuiLastStolenKeyGlobally) ? ++this->iuiLastStolenKeyGlobally : pSelectedChannel->pActiveKeys->first();
736     this->iuiLastStolenKeyGlobally = RTList<uint>::Iterator(); // to prevent endless loop (see line above)
737     while (iuiSelectedKey) {
738     MidiKey* pSelectedKey = &pSelectedChannel->pMIDIKeyInfo[*iuiSelectedKey];
739     itSelectedVoice = pSelectedKey->pActiveVoices->first();
740     // proceed iterating if voice was created in this fragment cycle
741     while (itSelectedVoice && !itSelectedVoice->IsStealable()) ++itSelectedVoice;
742     // found a "stealable" voice ?
743     if (itSelectedVoice && itSelectedVoice->IsStealable()) {
744     // remember which voice on which key on which engine channel we stole, so we can simply proceed on next voice stealing
745     this->iuiLastStolenKeyGlobally = iuiSelectedKey;
746     this->itLastStolenVoiceGlobally = itSelectedVoice;
747     this->pLastStolenChannel = pSelectedChannel;
748     goto stealable_voice_found; // selection succeeded
749     }
750     ++iuiSelectedKey; // get next key on current engine channel
751     }
752     // get next engine channel
753     iChannelIndex = (iChannelIndex + 1) % engineChannels.size();
754     pSelectedChannel = static_cast<EngineChannelBase<V, R, I>*>(engineChannels[iChannelIndex]);
755    
756     #if CONFIG_DEVMODE
757     if (pSelectedChannel == pBegin) {
758     dmsg(1,("FATAL ERROR: voice stealing endless loop!\n"));
759     dmsg(1,("VoiceSpawnsLeft=%d.\n", VoiceSpawnsLeft));
760     dmsg(1,("Exiting.\n"));
761     exit(-1);
762     }
763     #endif // CONFIG_DEVMODE
764     }
765    
766     // jump point if a 'stealable' voice was found
767     stealable_voice_found:
768    
769     #if CONFIG_DEVMODE
770     if (!itSelectedVoice->IsActive()) {
771     dmsg(1,("EngineBase: ERROR, tried to steal a voice which was not active !!!\n"));
772     return -1;
773     }
774     #endif // CONFIG_DEVMODE
775    
776     // now kill the selected voice
777     itSelectedVoice->Kill(itNoteOnEvent);
778    
779     --VoiceSpawnsLeft;
780    
781     return 0; // success
782     }
783     else {
784     dmsg(1,("Event pool emtpy!\n"));
785     return -1;
786     }
787     }
788    
789     void HandleInstrumentChanges() {
790     bool instrumentChanged = false;
791     for (int i = 0; i < engineChannels.size(); i++) {
792     EngineChannelBase<V, R, I>* pEngineChannel =
793     static_cast<EngineChannelBase<V, R, I>*>(engineChannels[i]);
794    
795     // as we're going to (carefully) write some status to the
796     // synchronized struct, we cast away the const
797     InstrumentChangeCmd<R, I>& cmd =
798     const_cast<InstrumentChangeCmd<R, I>&>(pEngineChannel->InstrumentChangeCommandReader.Lock());
799    
800     pEngineChannel->pRegionsInUse = cmd.pRegionsInUse;
801     pEngineChannel->pRegionsInUse->clear();
802    
803     if (cmd.bChangeInstrument) {
804     // change instrument
805     dmsg(5,("Engine: instrument change command received\n"));
806     cmd.bChangeInstrument = false;
807     pEngineChannel->pInstrument = cmd.pInstrument;
808     instrumentChanged = true;
809    
810     pEngineChannel->MarkAllActiveVoicesAsOrphans();
811     }
812     }
813    
814     if (instrumentChanged) {
815     //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
816     ResetSuspendedRegions();
817     }
818     }
819    
820     /**
821     * Render all 'normal' voices (that is voices which were not stolen in
822     * this fragment) on the given engine channel.
823     *
824     * @param pEngineChannel - engine channel on which audio should be
825     * rendered
826     * @param Samples - amount of sample points to be rendered in
827     * this audio fragment cycle
828     */
829     void RenderActiveVoices(EngineChannel* pEngineChannel, uint Samples) {
830     #if !CONFIG_PROCESS_MUTED_CHANNELS
831     if (pEngineChannel->GetMute()) return; // skip if sampler channel is muted
832     #endif
833    
834     EngineChannelBase<V, R, I>* pChannel =
835     static_cast<EngineChannelBase<V, R, I>*>(pEngineChannel);
836     pChannel->RenderActiveVoices(Samples);
837    
838     ActiveVoiceCountTemp += pEngineChannel->GetVoiceCount();
839     }
840    
841     /**
842     * Render all stolen voices (only voices which were stolen in this
843     * fragment) on the given engine channel. Stolen voices are rendered
844     * after all normal voices have been rendered; this is needed to render
845     * audio of those voices which were selected for voice stealing until
846     * the point were the stealing (that is the take over of the voice)
847     * actually happened.
848     *
849     * @param pEngineChannel - engine channel on which audio should be
850     * rendered
851     * @param Samples - amount of sample points to be rendered in
852     * this audio fragment cycle
853     */
854     void RenderStolenVoices(uint Samples) {
855     RTList<Event>::Iterator itVoiceStealEvent = pVoiceStealingQueue->first();
856     RTList<Event>::Iterator end = pVoiceStealingQueue->end();
857     for (; itVoiceStealEvent != end; ++itVoiceStealEvent) {
858     EngineChannelBase<V, R, I>* pEngineChannel =
859     static_cast<EngineChannelBase<V, R, I>*>(itVoiceStealEvent->pEngineChannel);;
860     if (!pEngineChannel->pInstrument) continue; // ignore if no instrument loaded
861     PoolVoiceIterator itNewVoice =
862     LaunchVoice(pEngineChannel, itVoiceStealEvent, itVoiceStealEvent->Param.Note.Layer, itVoiceStealEvent->Param.Note.ReleaseTrigger, false, false);
863     if (itNewVoice) {
864     itNewVoice->Render(Samples);
865     if (itNewVoice->IsActive()) { // still active
866     *(pEngineChannel->pRegionsInUse->allocAppend()) = itNewVoice->GetRegion();
867     ActiveVoiceCountTemp++;
868     pEngineChannel->SetVoiceCount(pEngineChannel->GetVoiceCount() + 1);
869    
870     if (itNewVoice->PlaybackState == Voice::playback_state_disk) {
871     if (itNewVoice->DiskStreamRef.State != Stream::state_unused) {
872     pEngineChannel->SetDiskStreamCount(pEngineChannel->GetDiskStreamCount() + 1);
873     }
874     }
875     } else { // voice reached end, is now inactive
876     pEngineChannel->FreeVoice(itNewVoice); // remove voice from the list of active voices
877     }
878     }
879     else dmsg(1,("EngineBase: ERROR, voice stealing didn't work out!\n"));
880    
881     // we need to clear the key's event list explicitly here in case key was never active
882     MidiKey* pKey = &pEngineChannel->pMIDIKeyInfo[itVoiceStealEvent->Param.Note.Key];
883     pKey->VoiceTheftsQueued--;
884     if (!pKey->Active && !pKey->VoiceTheftsQueued) pKey->pEvents->clear();
885     }
886     }
887    
888     /**
889     * Free all keys which have turned inactive in this audio fragment, from
890     * the list of active keys and clear all event lists on that engine
891     * channel.
892     *
893     * @param pEngineChannel - engine channel to cleanup
894     */
895     void PostProcess(EngineChannel* pEngineChannel) {
896     EngineChannelBase<V, R, I>* pChannel =
897     static_cast<EngineChannelBase<V, R, I>*>(pEngineChannel);
898     pChannel->FreeAllInactiveKyes();
899    
900     // empty the engine channel's own event lists
901     pChannel->ClearEventLists();
902     }
903    
904 schoenebeck 2121 /**
905     * Process MIDI control change events with hard coded behavior,
906     * that is controllers whose behavior is defined independently
907     * of the actual sampler engine type and instrument.
908     *
909     * @param pEngineChannel - engine channel on which the MIDI CC event was received
910     * @param itControlChangeEvent - the actual MIDI CC event
911     */
912 iliev 2012 void ProcessHardcodedControllers (
913     EngineChannel* pEngineChannel,
914     Pool<Event>::Iterator& itControlChangeEvent
915     ) {
916     EngineChannelBase<V, R, I>* pChannel =
917     static_cast<EngineChannelBase<V, R, I>*>(pEngineChannel);
918    
919     switch (itControlChangeEvent->Param.CC.Controller) {
920     case 5: { // portamento time
921     pChannel->PortamentoTime = (float) itControlChangeEvent->Param.CC.Value / 127.0f * (float) CONFIG_PORTAMENTO_TIME_MAX + (float) CONFIG_PORTAMENTO_TIME_MIN;
922     break;
923     }
924 schoenebeck 2121 case 6: { // data entry (currently only used for RPN and NRPN controllers)
925     //dmsg(1,("DATA ENTRY %d\n", itControlChangeEvent->Param.CC.Value));
926     if (pChannel->GetMidiRpnController() >= 0) { // RPN controller number was sent previously ...
927     dmsg(4,("Guess it's an RPN ...\n"));
928     if (pChannel->GetMidiRpnController() == 2) { // coarse tuning in half tones
929     int transpose = (int) itControlChangeEvent->Param.CC.Value - 64;
930     // limit to +- two octaves for now
931     transpose = RTMath::Min(transpose, 24);
932     transpose = RTMath::Max(transpose, -24);
933     pChannel->GlobalTranspose = transpose;
934     // workaround, so we won't have hanging notes
935     pChannel->ReleaseAllVoices(itControlChangeEvent);
936     }
937     // to prevent other MIDI CC #6 messages to be misenterpreted as RPN controller data
938     pChannel->ResetMidiRpnController();
939     } else if (pChannel->GetMidiNrpnController() >= 0) { // NRPN controller number was sent previously ...
940     dmsg(4,("Guess it's an NRPN ...\n"));
941     const int NrpnCtrlMSB = pChannel->GetMidiNrpnController() >> 8;
942     const int NrpnCtrlLSB = pChannel->GetMidiNrpnController() & 0xff;
943     dmsg(4,("NRPN MSB=%d LSB=%d Data=%d\n", NrpnCtrlMSB, NrpnCtrlLSB, itControlChangeEvent->Param.CC.Value));
944     switch (NrpnCtrlMSB) {
945     case 0x1a: { // volume level of note (Roland GS NRPN)
946     const uint note = NrpnCtrlLSB;
947     const uint vol = itControlChangeEvent->Param.CC.Value;
948     dmsg(4,("Note Volume NRPN received (note=%d,vol=%d).\n", note, vol));
949     if (note < 128 && vol < 128)
950     pChannel->pMIDIKeyInfo[note].Volume = VolumeCurve[vol];
951     break;
952     }
953     case 0x1c: { // panpot of note (Roland GS NRPN)
954     const uint note = NrpnCtrlLSB;
955     const uint pan = itControlChangeEvent->Param.CC.Value;
956     dmsg(4,("Note Pan NRPN received (note=%d,pan=%d).\n", note, pan));
957     if (note < 128 && pan < 128) {
958     pChannel->pMIDIKeyInfo[note].PanLeft = PanCurve[128 - pan];
959     pChannel->pMIDIKeyInfo[note].PanRight = PanCurve[pan];
960     }
961     break;
962     }
963     case 0x1d: { // reverb send of note (Roland GS NRPN)
964     const uint note = NrpnCtrlLSB;
965     const float reverb = float(itControlChangeEvent->Param.CC.Value) / 127.0f;
966     dmsg(4,("Note Reverb Send NRPN received (note=%d,send=%d).\n", note, reverb));
967     if (note < 128)
968     pChannel->pMIDIKeyInfo[note].ReverbSend = reverb;
969     break;
970     }
971     case 0x1e: { // chorus send of note (Roland GS NRPN)
972     const uint note = NrpnCtrlLSB;
973     const float chorus = float(itControlChangeEvent->Param.CC.Value) / 127.0f;
974     dmsg(4,("Note Chorus Send NRPN received (note=%d,send=%d).\n", note, chorus));
975     if (note < 128)
976     pChannel->pMIDIKeyInfo[note].ChorusSend = chorus;
977     break;
978     }
979     }
980     // to prevent other MIDI CC #6 messages to be misenterpreted as NRPN controller data
981     pChannel->ResetMidiNrpnController();
982 iliev 2012 }
983     break;
984     }
985     case 7: { // volume
986     //TODO: not sample accurate yet
987     pChannel->MidiVolume = VolumeCurve[itControlChangeEvent->Param.CC.Value];
988     pChannel->bStatusChanged = true; // engine channel status has changed, so set notify flag
989     break;
990     }
991     case 10: { // panpot
992     //TODO: not sample accurate yet
993     pChannel->iLastPanRequest = itControlChangeEvent->Param.CC.Value;
994     break;
995     }
996     case 64: { // sustain
997     if (itControlChangeEvent->Param.CC.Value >= 64 && !pChannel->SustainPedal) {
998     dmsg(4,("DAMPER (RIGHT) PEDAL DOWN\n"));
999     pChannel->SustainPedal = true;
1000     pChannel->listeners.PreProcessSustainPedalDown();
1001    
1002     #if !CONFIG_PROCESS_MUTED_CHANNELS
1003     if (pEngineChannel->GetMute()) { // skip if sampler channel is muted
1004     pChannel->listeners.PostProcessSustainPedalDown();
1005     return;
1006     }
1007     #endif
1008    
1009     pChannel->ProcessSustainPedalDown(itControlChangeEvent);
1010     pChannel->listeners.PostProcessSustainPedalDown();
1011     }
1012     if (itControlChangeEvent->Param.CC.Value < 64 && pChannel->SustainPedal) {
1013     dmsg(4,("DAMPER (RIGHT) PEDAL UP\n"));
1014     pChannel->SustainPedal = false;
1015     pChannel->listeners.PreProcessSustainPedalUp();
1016    
1017     #if !CONFIG_PROCESS_MUTED_CHANNELS
1018     if (pChannel->GetMute()) { // skip if sampler channel is muted
1019     pChannel->listeners.PostProcessSustainPedalUp();
1020     return;
1021     }
1022     #endif
1023    
1024     pChannel->ProcessSustainPedalUp(itControlChangeEvent);
1025     pChannel->listeners.PostProcessSustainPedalUp();
1026     }
1027     break;
1028     }
1029     case 65: { // portamento on / off
1030     const bool bPortamento = itControlChangeEvent->Param.CC.Value >= 64;
1031     if (bPortamento != pChannel->PortamentoMode)
1032     KillAllVoices(pChannel, itControlChangeEvent);
1033     pChannel->PortamentoMode = bPortamento;
1034     break;
1035     }
1036     case 66: { // sostenuto
1037     if (itControlChangeEvent->Param.CC.Value >= 64 && !pChannel->SostenutoPedal) {
1038     dmsg(4,("SOSTENUTO (CENTER) PEDAL DOWN\n"));
1039     pChannel->SostenutoPedal = true;
1040     pChannel->listeners.PreProcessSostenutoPedalDown();
1041    
1042     #if !CONFIG_PROCESS_MUTED_CHANNELS
1043     if (pEngineChannel->GetMute()) { // skip if sampler channel is muted
1044     pChannel->listeners.PostProcessSostenutoPedalDown();
1045     return;
1046     }
1047     #endif
1048    
1049     pChannel->ProcessSostenutoPedalDown();
1050     pChannel->listeners.PostProcessSostenutoPedalDown();
1051     }
1052     if (itControlChangeEvent->Param.CC.Value < 64 && pChannel->SostenutoPedal) {
1053     dmsg(4,("SOSTENUTO (CENTER) PEDAL UP\n"));
1054     pChannel->SostenutoPedal = false;
1055     pChannel->listeners.PreProcessSostenutoPedalUp();
1056    
1057     #if !CONFIG_PROCESS_MUTED_CHANNELS
1058     if (pEngineChannel->GetMute()) { // skip if sampler channel is muted
1059     pChannel->listeners.PostProcessSostenutoPedalUp();
1060     return;
1061     }
1062     #endif
1063    
1064     pChannel->ProcessSostenutoPedalUp(itControlChangeEvent);
1065     pChannel->listeners.PostProcessSostenutoPedalUp();
1066     }
1067     break;
1068     }
1069 schoenebeck 2121 case 98: { // NRPN controller LSB
1070     dmsg(4,("NRPN LSB %d\n", itControlChangeEvent->Param.CC.Value));
1071     pEngineChannel->SetMidiNrpnControllerLsb(itControlChangeEvent->Param.CC.Value);
1072     break;
1073     }
1074     case 99: { // NRPN controller MSB
1075     dmsg(4,("NRPN MSB %d\n", itControlChangeEvent->Param.CC.Value));
1076     pEngineChannel->SetMidiNrpnControllerMsb(itControlChangeEvent->Param.CC.Value);
1077     break;
1078     }
1079 iliev 2012 case 100: { // RPN controller LSB
1080 schoenebeck 2121 dmsg(4,("RPN LSB %d\n", itControlChangeEvent->Param.CC.Value));
1081 iliev 2012 pEngineChannel->SetMidiRpnControllerLsb(itControlChangeEvent->Param.CC.Value);
1082     break;
1083     }
1084     case 101: { // RPN controller MSB
1085 schoenebeck 2121 dmsg(4,("RPN MSB %d\n", itControlChangeEvent->Param.CC.Value));
1086 iliev 2012 pEngineChannel->SetMidiRpnControllerMsb(itControlChangeEvent->Param.CC.Value);
1087     break;
1088     }
1089    
1090    
1091     // Channel Mode Messages
1092    
1093     case 120: { // all sound off
1094     KillAllVoices(pEngineChannel, itControlChangeEvent);
1095     break;
1096     }
1097     case 121: { // reset all controllers
1098     pChannel->ResetControllers();
1099     break;
1100     }
1101     case 123: { // all notes off
1102     #if CONFIG_PROCESS_ALL_NOTES_OFF
1103     pChannel->ReleaseAllVoices(itControlChangeEvent);
1104     #endif // CONFIG_PROCESS_ALL_NOTES_OFF
1105     break;
1106     }
1107     case 126: { // mono mode on
1108     if (!pChannel->SoloMode)
1109     KillAllVoices(pEngineChannel, itControlChangeEvent);
1110     pChannel->SoloMode = true;
1111     break;
1112     }
1113     case 127: { // poly mode on
1114     if (pChannel->SoloMode)
1115     KillAllVoices(pEngineChannel, itControlChangeEvent);
1116     pChannel->SoloMode = false;
1117     break;
1118     }
1119     }
1120     }
1121    
1122     virtual D* CreateDiskThread() = 0;
1123    
1124     /**
1125     * Assigns and triggers a new voice for the respective MIDI key.
1126     *
1127     * @param pEngineChannel - engine channel on which this event occured on
1128     * @param itNoteOnEvent - key, velocity and time stamp of the event
1129     */
1130     virtual void ProcessNoteOn(EngineChannel* pEngineChannel, Pool<Event>::Iterator& itNoteOnEvent) {
1131     EngineChannelBase<V, R, I>* pChannel =
1132     static_cast<EngineChannelBase<V, R, I>*>(pEngineChannel);
1133    
1134     //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
1135     int k = itNoteOnEvent->Param.Note.Key + pChannel->GlobalTranspose;
1136     if (k < 0 || k > 127) return; //ignore keys outside the key range
1137    
1138     itNoteOnEvent->Param.Note.Key += pChannel->GlobalTranspose;
1139     int vel = itNoteOnEvent->Param.Note.Velocity;
1140    
1141     const int key = itNoteOnEvent->Param.Note.Key;
1142     MidiKey* pKey = &pChannel->pMIDIKeyInfo[key];
1143    
1144     pChannel->listeners.PreProcessNoteOn(key, vel);
1145     #if !CONFIG_PROCESS_MUTED_CHANNELS
1146     if (pEngineChannel->GetMute()) { // skip if sampler channel is muted
1147     pChannel->listeners.PostProcessNoteOn(key, vel);
1148     return;
1149     }
1150     #endif
1151    
1152     if (!pChannel->pInstrument) {
1153     pChannel->listeners.PostProcessNoteOn(key, vel);
1154     return; // ignore if no instrument loaded
1155     }
1156    
1157     // move note on event to the key's own event list
1158     RTList<Event>::Iterator itNoteOnEventOnKeyList = itNoteOnEvent.moveToEndOf(pKey->pEvents);
1159    
1160     // if Solo Mode then kill all already active voices
1161     if (pChannel->SoloMode) {
1162     Pool<uint>::Iterator itYoungestKey = pChannel->pActiveKeys->last();
1163     if (itYoungestKey) {
1164     const int iYoungestKey = *itYoungestKey;
1165     const MidiKey* pOtherKey = &pChannel->pMIDIKeyInfo[iYoungestKey];
1166     if (pOtherKey->Active) {
1167     // get final portamento position of currently active voice
1168     if (pChannel->PortamentoMode) {
1169     VoiceIterator itVoice = pOtherKey->pActiveVoices->last();
1170     if (itVoice) itVoice->UpdatePortamentoPos(itNoteOnEventOnKeyList);
1171     }
1172     // kill all voices on the (other) key
1173     VoiceIterator itVoiceToBeKilled = pOtherKey->pActiveVoices->first();
1174     VoiceIterator end = pOtherKey->pActiveVoices->end();
1175     for (; itVoiceToBeKilled != end; ++itVoiceToBeKilled) {
1176 persson 2115 if (!(itVoiceToBeKilled->Type & Voice::type_release_trigger))
1177 iliev 2012 itVoiceToBeKilled->Kill(itNoteOnEventOnKeyList);
1178     }
1179     }
1180     }
1181     // set this key as 'currently active solo key'
1182     pChannel->SoloKey = key;
1183     }
1184    
1185     pChannel->ProcessKeySwitchChange(key);
1186    
1187     pKey->KeyPressed = true; // the MIDI key was now pressed down
1188     pKey->Velocity = itNoteOnEventOnKeyList->Param.Note.Velocity;
1189     pKey->NoteOnTime = FrameTime + itNoteOnEventOnKeyList->FragmentPos(); // will be used to calculate note length
1190    
1191     // cancel release process of voices on this key if needed
1192     if (pKey->Active && !pChannel->SustainPedal) {
1193     RTList<Event>::Iterator itCancelReleaseEvent = pKey->pEvents->allocAppend();
1194     if (itCancelReleaseEvent) {
1195     *itCancelReleaseEvent = *itNoteOnEventOnKeyList; // copy event
1196     itCancelReleaseEvent->Type = Event::type_cancel_release; // transform event type
1197     }
1198     else dmsg(1,("Event pool emtpy!\n"));
1199     }
1200    
1201     TriggerNewVoices(pEngineChannel, itNoteOnEventOnKeyList);
1202    
1203     // if neither a voice was spawned or postponed then remove note on event from key again
1204     if (!pKey->Active && !pKey->VoiceTheftsQueued)
1205     pKey->pEvents->free(itNoteOnEventOnKeyList);
1206    
1207     if (!pChannel->SoloMode || pChannel->PortamentoPos < 0.0f) pChannel->PortamentoPos = (float) key;
1208 persson 2043 if (pKey->pRoundRobinIndex) {
1209     (*pKey->pRoundRobinIndex)++; // counter specific for the key or region
1210     pChannel->RoundRobinIndex++; // common counter for the channel
1211     }
1212 iliev 2012 pChannel->listeners.PostProcessNoteOn(key, vel);
1213     }
1214    
1215     /**
1216     * Allocate and trigger new voice(s) for the key.
1217     */
1218     virtual void TriggerNewVoices (
1219     EngineChannel* pEngineChannel,
1220     RTList<Event>::Iterator& itNoteOnEvent,
1221     bool HandleKeyGroupConflicts = true
1222     ) = 0;
1223    
1224     /**
1225     * Allocate and trigger release voice(s) for the key.
1226     */
1227     virtual void TriggerReleaseVoices (
1228     EngineChannel* pEngineChannel,
1229     RTList<Event>::Iterator& itNoteOffEvent
1230     ) = 0;
1231    
1232     /**
1233     * Releases the voices on the given key if sustain pedal is not pressed.
1234     * If sustain is pressed, the release of the note will be postponed until
1235     * sustain pedal will be released or voice turned inactive by itself (e.g.
1236     * due to completion of sample playback).
1237     *
1238     * @param pEngineChannel - engine channel on which this event occured on
1239     * @param itNoteOffEvent - key, velocity and time stamp of the event
1240     */
1241     virtual void ProcessNoteOff(EngineChannel* pEngineChannel, Pool<Event>::Iterator& itNoteOffEvent) {
1242     EngineChannelBase<V, R, I>* pChannel = static_cast<EngineChannelBase<V, R, I>*>(pEngineChannel);
1243    
1244     int k = itNoteOffEvent->Param.Note.Key + pChannel->GlobalTranspose;
1245     if (k < 0 || k > 127) return; //ignore keys outside the key range
1246    
1247     //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
1248     itNoteOffEvent->Param.Note.Key += pChannel->GlobalTranspose;
1249     int vel = itNoteOffEvent->Param.Note.Velocity;
1250    
1251     const int iKey = itNoteOffEvent->Param.Note.Key;
1252     MidiKey* pKey = &pChannel->pMIDIKeyInfo[iKey];
1253    
1254     pChannel->listeners.PreProcessNoteOff(iKey, vel);
1255    
1256     #if !CONFIG_PROCESS_MUTED_CHANNELS
1257     if (pEngineChannel->GetMute()) { // skip if sampler channel is muted
1258     pChannel->listeners.PostProcessNoteOff(iKey, vel);
1259     return;
1260     }
1261     #endif
1262    
1263     pKey->KeyPressed = false; // the MIDI key was now released
1264    
1265     // move event to the key's own event list
1266     RTList<Event>::Iterator itNoteOffEventOnKeyList = itNoteOffEvent.moveToEndOf(pKey->pEvents);
1267    
1268     bool bShouldRelease = pKey->Active && pChannel->ShouldReleaseVoice(itNoteOffEventOnKeyList->Param.Note.Key);
1269    
1270     // in case Solo Mode is enabled, kill all voices on this key and respawn a voice on the highest pressed key (if any)
1271     if (pChannel->SoloMode && pChannel->pInstrument) { //TODO: this feels like too much code just for handling solo mode :P
1272     bool bOtherKeysPressed = false;
1273     if (iKey == pChannel->SoloKey) {
1274     pChannel->SoloKey = -1;
1275     // if there's still a key pressed down, respawn a voice (group) on the highest key
1276     for (int i = 127; i > 0; i--) {
1277     MidiKey* pOtherKey = &pChannel->pMIDIKeyInfo[i];
1278     if (pOtherKey->KeyPressed) {
1279     bOtherKeysPressed = true;
1280     // make the other key the new 'currently active solo key'
1281     pChannel->SoloKey = i;
1282     // get final portamento position of currently active voice
1283     if (pChannel->PortamentoMode) {
1284     VoiceIterator itVoice = pKey->pActiveVoices->first();
1285     if (itVoice) itVoice->UpdatePortamentoPos(itNoteOffEventOnKeyList);
1286     }
1287     // create a pseudo note on event
1288     RTList<Event>::Iterator itPseudoNoteOnEvent = pOtherKey->pEvents->allocAppend();
1289     if (itPseudoNoteOnEvent) {
1290     // copy event
1291     *itPseudoNoteOnEvent = *itNoteOffEventOnKeyList;
1292     // transform event to a note on event
1293     itPseudoNoteOnEvent->Type = Event::type_note_on;
1294     itPseudoNoteOnEvent->Param.Note.Key = i;
1295     itPseudoNoteOnEvent->Param.Note.Velocity = pOtherKey->Velocity;
1296     // allocate and trigger new voice(s) for the other key
1297     TriggerNewVoices(pChannel, itPseudoNoteOnEvent, false);
1298     // if neither a voice was spawned or postponed then remove note on event from key again
1299     if (!pOtherKey->Active && !pOtherKey->VoiceTheftsQueued)
1300     pOtherKey->pEvents->free(itPseudoNoteOnEvent);
1301    
1302     } else dmsg(1,("Could not respawn voice, no free event left\n"));
1303     break; // done
1304     }
1305     }
1306     }
1307     if (bOtherKeysPressed) {
1308     if (pKey->Active) { // kill all voices on this key
1309     bShouldRelease = false; // no need to release, as we kill it here
1310     VoiceIterator itVoiceToBeKilled = pKey->pActiveVoices->first();
1311     VoiceIterator end = pKey->pActiveVoices->end();
1312     for (; itVoiceToBeKilled != end; ++itVoiceToBeKilled) {
1313 persson 2115 if (!(itVoiceToBeKilled->Type & Voice::type_release_trigger))
1314 iliev 2012 itVoiceToBeKilled->Kill(itNoteOffEventOnKeyList);
1315     }
1316     }
1317     } else pChannel->PortamentoPos = -1.0f;
1318     }
1319    
1320     // if no solo mode (the usual case) or if solo mode and no other key pressed, then release voices on this key if needed
1321     if (bShouldRelease) {
1322     itNoteOffEventOnKeyList->Type = Event::type_release; // transform event type
1323    
1324     // spawn release triggered voice(s) if needed
1325     if (pKey->ReleaseTrigger && pChannel->pInstrument) {
1326     TriggerReleaseVoices(pChannel, itNoteOffEventOnKeyList);
1327     pKey->ReleaseTrigger = false;
1328     }
1329     }
1330    
1331     // if neither a voice was spawned or postponed on this key then remove note off event from key again
1332     if (!pKey->Active && !pKey->VoiceTheftsQueued)
1333     pKey->pEvents->free(itNoteOffEventOnKeyList);
1334    
1335     pChannel->listeners.PostProcessNoteOff(iKey, vel);
1336     }
1337    
1338     /**
1339     * Reset all voices and disk thread and clear input event queue and all
1340     * control and status variables. This method is protected by a mutex.
1341     */
1342     virtual void ResetInternal() {
1343 persson 2427 LockGuard lock(ResetInternalMutex);
1344 iliev 2012
1345     // make sure that the engine does not get any sysex messages
1346     // while it's reseting
1347     bool sysexDisabled = MidiInputPort::RemoveSysexListener(this);
1348     SetVoiceCount(0);
1349     ActiveVoiceCountMax = 0;
1350    
1351     // reset voice stealing parameters
1352     pVoiceStealingQueue->clear();
1353     itLastStolenVoice = VoiceIterator();
1354     itLastStolenVoiceGlobally = VoiceIterator();
1355     iuiLastStolenKey = RTList<uint>::Iterator();
1356     iuiLastStolenKeyGlobally = RTList<uint>::Iterator();
1357     pLastStolenChannel = NULL;
1358    
1359     // reset all voices
1360     for (VoiceIterator iterVoice = pVoicePool->allocAppend(); iterVoice == pVoicePool->last(); iterVoice = pVoicePool->allocAppend()) {
1361     iterVoice->Reset();
1362     }
1363     pVoicePool->clear();
1364    
1365     // reset disk thread
1366     if (pDiskThread) pDiskThread->Reset();
1367    
1368     // delete all input events
1369     pEventQueue->init();
1370     pSysexBuffer->init();
1371     if (sysexDisabled) MidiInputPort::AddSysexListener(this);
1372     }
1373    
1374     /**
1375     * Kills all voices on an engine channel as soon as possible. Voices
1376     * won't get into release state, their volume level will be ramped down
1377     * as fast as possible.
1378     *
1379     * @param pEngineChannel - engine channel on which all voices should be killed
1380     * @param itKillEvent - event which caused this killing of all voices
1381     */
1382     virtual void KillAllVoices(EngineChannel* pEngineChannel, Pool<Event>::Iterator& itKillEvent) {
1383     EngineChannelBase<V, R, I>* pChannel = static_cast<EngineChannelBase<V, R, I>*>(pEngineChannel);
1384     int count = pChannel->KillAllVoices(itKillEvent);
1385     VoiceSpawnsLeft -= count; //FIXME: just a temporary workaround, we should check the cause in StealVoice() instead
1386     }
1387    
1388     /**
1389     * Allocates and triggers a new voice. This method will usually be
1390     * called by the ProcessNoteOn() method and by the voices itself
1391     * (e.g. to spawn further voices on the same key for layered sounds).
1392     *
1393     * @param pEngineChannel - engine channel on which this event occured on
1394     * @param itNoteOnEvent - key, velocity and time stamp of the event
1395     * @param iLayer - layer index for the new voice (optional - only
1396     * in case of layered sounds of course)
1397     * @param ReleaseTriggerVoice - if new voice is a release triggered voice
1398     * (optional, default = false)
1399     * @param VoiceStealing - if voice stealing should be performed
1400     * when there is no free voice
1401     * (optional, default = true)
1402     * @param HandleKeyGroupConflicts - if voices should be killed due to a
1403     * key group conflict
1404     * @returns pointer to new voice or NULL if there was no free voice or
1405     * if the voice wasn't triggered (for example when no region is
1406     * defined for the given key).
1407     */
1408     virtual PoolVoiceIterator LaunchVoice (
1409     EngineChannel* pEngineChannel,
1410     Pool<Event>::Iterator& itNoteOnEvent,
1411     int iLayer,
1412     bool ReleaseTriggerVoice,
1413     bool VoiceStealing,
1414     bool HandleKeyGroupConflicts
1415     ) = 0;
1416    
1417 iliev 2015 virtual int GetMinFadeOutSamples() { return MinFadeOutSamples; }
1418    
1419 iliev 2027 int InitNewVoice (
1420     EngineChannelBase<V, R, I>* pChannel,
1421     R* pRegion,
1422     Pool<Event>::Iterator& itNoteOnEvent,
1423     Voice::type_t VoiceType,
1424     int iLayer,
1425     int iKeyGroup,
1426     bool ReleaseTriggerVoice,
1427     bool VoiceStealing,
1428     typename Pool<V>::Iterator& itNewVoice
1429     ) {
1430     int key = itNoteOnEvent->Param.Note.Key;
1431     typename MidiKeyboardManager<V>::MidiKey* pKey = &pChannel->pMIDIKeyInfo[key];
1432     if (itNewVoice) {
1433     // launch the new voice
1434     if (itNewVoice->Trigger(pChannel, itNoteOnEvent, pChannel->Pitch, pRegion, VoiceType, iKeyGroup) < 0) {
1435     dmsg(4,("Voice not triggered\n"));
1436     pKey->pActiveVoices->free(itNewVoice);
1437     }
1438     else { // on success
1439     --VoiceSpawnsLeft;
1440     if (!pKey->Active) { // mark as active key
1441     pKey->Active = true;
1442     pKey->itSelf = pChannel->pActiveKeys->allocAppend();
1443     *pKey->itSelf = itNoteOnEvent->Param.Note.Key;
1444     }
1445 persson 2115 if (itNewVoice->Type & Voice::type_release_trigger_required) pKey->ReleaseTrigger = true; // mark key for the need of release triggered voice(s)
1446 iliev 2027 return 0; // success
1447     }
1448     }
1449     else if (VoiceStealing) {
1450     // try to steal one voice
1451     int result = StealVoice(pChannel, itNoteOnEvent);
1452     if (!result) { // voice stolen successfully
1453     // put note-on event into voice-stealing queue, so it will be reprocessed after killed voice died
1454     RTList<Event>::Iterator itStealEvent = pVoiceStealingQueue->allocAppend();
1455     if (itStealEvent) {
1456     *itStealEvent = *itNoteOnEvent; // copy event
1457     itStealEvent->Param.Note.Layer = iLayer;
1458     itStealEvent->Param.Note.ReleaseTrigger = ReleaseTriggerVoice;
1459     pKey->VoiceTheftsQueued++;
1460     }
1461     else dmsg(1,("Voice stealing queue full!\n"));
1462     }
1463     }
1464    
1465     return -1;
1466     }
1467 schoenebeck 2448
1468     /**
1469     * Checks whether scale tuning setting has been changed since last
1470     * time this method was called, if yes, it recalculates the pitch
1471     * for all active voices.
1472     */
1473     void ProcessScaleTuningChange() {
1474     const bool changed = ScaleTuningChanged.readAndReset();
1475     if (!changed) return;
1476    
1477     for (int i = 0; i < engineChannels.size(); i++) {
1478     EngineChannelBase<V, R, I>* channel =
1479     static_cast<EngineChannelBase<V, R, I>*>(engineChannels[i]);
1480     channel->OnScaleTuningChanged();
1481     }
1482     }
1483 iliev 2027
1484 iliev 2012 private:
1485     Pool<V>* pVoicePool; ///< Contains all voices that can be activated.
1486     Pool<RR*> SuspendedRegions;
1487     Mutex SuspendedRegionsMutex;
1488     Condition SuspensionChangeOngoing;
1489     RR* pPendingRegionSuspension;
1490     RR* pPendingRegionResumption;
1491     int iPendingStreamDeletions;
1492     };
1493    
1494     template <class V, class RR, class R, class D, class IM, class I>
1495     IM EngineBase<V, RR, R, D, IM, I>::instruments;
1496    
1497     } // namespace LinuxSampler
1498    
1499     #endif /* __LS_ENGINEBASE_H__ */
1500    

  ViewVC Help
Powered by ViewVC