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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 849 - (hide annotations) (download)
Sat Mar 25 13:05:59 2006 UTC (13 years, 6 months ago) by schoenebeck
File size: 77907 byte(s)
* added compile time option to disable processing of All-Notes-Off
  MIDI messages

1 schoenebeck 53 /***************************************************************************
2     * *
3     * LinuxSampler - modular, streaming capable sampler *
4     * *
5 schoenebeck 56 * Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck *
6 schoenebeck 829 * Copyright (C) 2005, 2006 Christian Schoenebeck *
7 schoenebeck 53 * *
8     * This program is free software; you can redistribute it and/or modify *
9     * it under the terms of the GNU General Public License as published by *
10     * the Free Software Foundation; either version 2 of the License, or *
11     * (at your option) any later version. *
12     * *
13     * This program is distributed in the hope that it will be useful, *
14     * but WITHOUT ANY WARRANTY; without even the implied warranty of *
15     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
16     * GNU General Public License for more details. *
17     * *
18     * You should have received a copy of the GNU General Public License *
19     * along with this program; if not, write to the Free Software *
20     * Foundation, Inc., 59 Temple Place, Suite 330, Boston, *
21     * MA 02111-1307 USA *
22     ***************************************************************************/
23    
24     #include <sstream>
25     #include "DiskThread.h"
26     #include "Voice.h"
27 schoenebeck 285 #include "EGADSR.h"
28 schoenebeck 420 #include "../EngineFactory.h"
29 schoenebeck 53
30     #include "Engine.h"
31    
32     namespace LinuxSampler { namespace gig {
33    
34 schoenebeck 411 InstrumentResourceManager Engine::instruments;
35 schoenebeck 53
36 schoenebeck 411 std::map<AudioOutputDevice*,Engine*> Engine::engines;
37    
38 schoenebeck 412 /**
39     * Get a gig::Engine object for the given gig::EngineChannel and the
40     * given AudioOutputDevice. All engine channels which are connected to
41     * the same audio output device will use the same engine instance. This
42     * method will be called by a gig::EngineChannel whenever it's
43     * connecting to a audio output device.
44     *
45     * @param pChannel - engine channel which acquires an engine object
46     * @param pDevice - the audio output device \a pChannel is connected to
47     */
48 schoenebeck 411 Engine* Engine::AcquireEngine(LinuxSampler::gig::EngineChannel* pChannel, AudioOutputDevice* pDevice) {
49 schoenebeck 412 Engine* pEngine = NULL;
50     // check if there's already an engine for the given audio output device
51 schoenebeck 411 if (engines.count(pDevice)) {
52 schoenebeck 412 dmsg(4,("Using existing gig::Engine.\n"));
53 persson 438 pEngine = engines[pDevice];
54 schoenebeck 412 } else { // create a new engine (and disk thread) instance for the given audio output device
55     dmsg(4,("Creating new gig::Engine.\n"));
56 schoenebeck 420 pEngine = (Engine*) EngineFactory::Create("gig");
57 schoenebeck 411 pEngine->Connect(pDevice);
58 persson 438 engines[pDevice] = pEngine;
59 schoenebeck 411 }
60 schoenebeck 412 // register engine channel to the engine instance
61 schoenebeck 460 pEngine->engineChannels.add(pChannel);
62     // remember index in the ArrayList
63     pChannel->iEngineIndexSelf = pEngine->engineChannels.size() - 1;
64 schoenebeck 412 dmsg(4,("This gig::Engine has now %d EngineChannels.\n",pEngine->engineChannels.size()));
65 schoenebeck 411 return pEngine;
66     }
67    
68 schoenebeck 412 /**
69     * Once an engine channel is disconnected from an audio output device,
70     * it wil immediately call this method to unregister itself from the
71     * engine instance and if that engine instance is not used by any other
72     * engine channel anymore, then that engine instance will be destroyed.
73     *
74     * @param pChannel - engine channel which wants to disconnect from it's
75     * engine instance
76     * @param pDevice - audio output device \a pChannel was connected to
77     */
78 schoenebeck 411 void Engine::FreeEngine(LinuxSampler::gig::EngineChannel* pChannel, AudioOutputDevice* pDevice) {
79 schoenebeck 412 dmsg(4,("Disconnecting EngineChannel from gig::Engine.\n"));
80 schoenebeck 411 Engine* pEngine = engines[pDevice];
81 schoenebeck 412 // unregister EngineChannel from the Engine instance
82     pEngine->engineChannels.remove(pChannel);
83     // if the used Engine instance is not used anymore, then destroy it
84     if (pEngine->engineChannels.empty()) {
85     pDevice->Disconnect(pEngine);
86     engines.erase(pDevice);
87     delete pEngine;
88     dmsg(4,("Destroying gig::Engine.\n"));
89     }
90     else dmsg(4,("This gig::Engine has now %d EngineChannels.\n",pEngine->engineChannels.size()));
91 schoenebeck 411 }
92    
93 schoenebeck 473 /**
94     * Constructor
95     */
96 schoenebeck 53 Engine::Engine() {
97     pAudioOutputDevice = NULL;
98     pDiskThread = NULL;
99     pEventGenerator = NULL;
100 schoenebeck 554 pSysexBuffer = new RingBuffer<uint8_t>(CONFIG_SYSEX_BUFFER_SIZE, 0);
101     pEventQueue = new RingBuffer<Event>(CONFIG_MAX_EVENTS_PER_FRAGMENT, 0);
102     pEventPool = new Pool<Event>(CONFIG_MAX_EVENTS_PER_FRAGMENT);
103     pVoicePool = new Pool<Voice>(CONFIG_MAX_VOICES);
104 schoenebeck 271 pVoiceStealingQueue = new RTList<Event>(pEventPool);
105 schoenebeck 460 pGlobalEvents = new RTList<Event>(pEventPool);
106 schoenebeck 271 for (RTList<Voice>::Iterator iterVoice = pVoicePool->allocAppend(); iterVoice == pVoicePool->last(); iterVoice = pVoicePool->allocAppend()) {
107     iterVoice->SetEngine(this);
108 schoenebeck 53 }
109     pVoicePool->clear();
110    
111     ResetInternal();
112 schoenebeck 659 ResetScaleTuning();
113 schoenebeck 53 }
114    
115 schoenebeck 473 /**
116     * Destructor
117     */
118 schoenebeck 53 Engine::~Engine() {
119 persson 846 MidiInputPort::RemoveSysexListener(this);
120 schoenebeck 53 if (pDiskThread) {
121 senkov 329 dmsg(1,("Stopping disk thread..."));
122 schoenebeck 53 pDiskThread->StopThread();
123     delete pDiskThread;
124 senkov 329 dmsg(1,("OK\n"));
125 schoenebeck 53 }
126     if (pEventQueue) delete pEventQueue;
127     if (pEventPool) delete pEventPool;
128 schoenebeck 411 if (pVoicePool) {
129     pVoicePool->clear();
130     delete pVoicePool;
131     }
132 schoenebeck 53 if (pEventGenerator) delete pEventGenerator;
133 schoenebeck 250 if (pVoiceStealingQueue) delete pVoiceStealingQueue;
134 schoenebeck 411 if (pSysexBuffer) delete pSysexBuffer;
135 schoenebeck 420 EngineFactory::Destroy(this);
136 schoenebeck 53 }
137    
138     void Engine::Enable() {
139     dmsg(3,("gig::Engine: enabling\n"));
140     EngineDisabled.PushAndUnlock(false, 2); // set condition object 'EngineDisabled' to false (wait max. 2s)
141 schoenebeck 64 dmsg(3,("gig::Engine: enabled (val=%d)\n", EngineDisabled.GetUnsafe()));
142 schoenebeck 53 }
143    
144     void Engine::Disable() {
145     dmsg(3,("gig::Engine: disabling\n"));
146     bool* pWasDisabled = EngineDisabled.PushAndUnlock(true, 2); // wait max. 2s
147     if (!pWasDisabled) dmsg(3,("gig::Engine warning: Timeout waiting to disable engine.\n"));
148     }
149    
150     void Engine::DisableAndLock() {
151     dmsg(3,("gig::Engine: disabling\n"));
152     bool* pWasDisabled = EngineDisabled.Push(true, 2); // wait max. 2s
153     if (!pWasDisabled) dmsg(3,("gig::Engine warning: Timeout waiting to disable engine.\n"));
154     }
155    
156     /**
157     * Reset all voices and disk thread and clear input event queue and all
158     * control and status variables.
159     */
160     void Engine::Reset() {
161     DisableAndLock();
162     ResetInternal();
163 schoenebeck 659 ResetScaleTuning();
164 schoenebeck 53 Enable();
165     }
166    
167     /**
168     * Reset all voices and disk thread and clear input event queue and all
169 persson 846 * control and status variables. This method is protected by a mutex.
170 schoenebeck 53 */
171     void Engine::ResetInternal() {
172 persson 846 ResetInternalMutex.Lock();
173    
174     // make sure that the engine does not get any sysex messages
175     // while it's reseting
176     bool sysexDisabled = MidiInputPort::RemoveSysexListener(this);
177 schoenebeck 53 ActiveVoiceCount = 0;
178     ActiveVoiceCountMax = 0;
179    
180 schoenebeck 250 // reset voice stealing parameters
181     pVoiceStealingQueue->clear();
182 schoenebeck 649 itLastStolenVoice = RTList<Voice>::Iterator();
183     itLastStolenVoiceGlobally = RTList<Voice>::Iterator();
184     iuiLastStolenKey = RTList<uint>::Iterator();
185     iuiLastStolenKeyGlobally = RTList<uint>::Iterator();
186     pLastStolenChannel = NULL;
187 schoenebeck 250
188 schoenebeck 53 // reset all voices
189 schoenebeck 271 for (RTList<Voice>::Iterator iterVoice = pVoicePool->allocAppend(); iterVoice == pVoicePool->last(); iterVoice = pVoicePool->allocAppend()) {
190     iterVoice->Reset();
191 schoenebeck 53 }
192     pVoicePool->clear();
193    
194     // reset disk thread
195     if (pDiskThread) pDiskThread->Reset();
196    
197     // delete all input events
198     pEventQueue->init();
199 schoenebeck 775 pSysexBuffer->init();
200 persson 846 if (sysexDisabled) MidiInputPort::AddSysexListener(this);
201     ResetInternalMutex.Unlock();
202 persson 438 }
203 schoenebeck 53
204 schoenebeck 473 /**
205 schoenebeck 659 * Reset to normal, chromatic scale (means equal tempered).
206     */
207     void Engine::ResetScaleTuning() {
208     memset(&ScaleTuning[0], 0x00, 12);
209     }
210    
211     /**
212 schoenebeck 473 * Connect this engine instance with the given audio output device.
213     * This method will be called when an Engine instance is created.
214     * All of the engine's data structures which are dependant to the used
215     * audio output device / driver will be (re)allocated and / or
216     * adjusted appropriately.
217     *
218     * @param pAudioOut - audio output device to connect to
219     */
220 schoenebeck 53 void Engine::Connect(AudioOutputDevice* pAudioOut) {
221     pAudioOutputDevice = pAudioOut;
222    
223     ResetInternal();
224    
225     // inform audio driver for the need of two channels
226     try {
227     pAudioOutputDevice->AcquireChannels(2); // gig engine only stereo
228     }
229     catch (AudioOutputException e) {
230     String msg = "Audio output device unable to provide 2 audio channels, cause: " + e.Message();
231     throw LinuxSamplerException(msg);
232     }
233 persson 438
234 schoenebeck 460 this->MaxSamplesPerCycle = pAudioOutputDevice->MaxSamplesPerCycle();
235     this->SampleRate = pAudioOutputDevice->SampleRate();
236 schoenebeck 225
237 schoenebeck 285 // FIXME: audio drivers with varying fragment sizes might be a problem here
238 schoenebeck 554 MaxFadeOutPos = MaxSamplesPerCycle - int(double(SampleRate) * CONFIG_EG_MIN_RELEASE_TIME) - 1;
239 schoenebeck 688 if (MaxFadeOutPos < 0) {
240     std::cerr << "gig::Engine: WARNING, CONFIG_EG_MIN_RELEASE_TIME "
241     << "too big for current audio fragment size & sampling rate! "
242 schoenebeck 690 << "May lead to click sounds if voice stealing chimes in!\n" << std::flush;
243 schoenebeck 688 // force volume ramp downs at the beginning of each fragment
244     MaxFadeOutPos = 0;
245     // lower minimum release time
246     const float minReleaseTime = (float) MaxSamplesPerCycle / (float) SampleRate;
247     for (RTList<Voice>::Iterator iterVoice = pVoicePool->allocAppend(); iterVoice == pVoicePool->last(); iterVoice = pVoicePool->allocAppend()) {
248 schoenebeck 738 iterVoice->EG1.CalculateFadeOutCoeff(minReleaseTime, SampleRate);
249 schoenebeck 688 }
250     pVoicePool->clear();
251     }
252 schoenebeck 285
253 schoenebeck 53 // (re)create disk thread
254     if (this->pDiskThread) {
255 senkov 329 dmsg(1,("Stopping disk thread..."));
256 schoenebeck 53 this->pDiskThread->StopThread();
257     delete this->pDiskThread;
258 senkov 329 dmsg(1,("OK\n"));
259 schoenebeck 53 }
260 schoenebeck 554 this->pDiskThread = new DiskThread(((pAudioOut->MaxSamplesPerCycle() << CONFIG_MAX_PITCH) << 1) + 6); //FIXME: assuming stereo
261 schoenebeck 53 if (!pDiskThread) {
262     dmsg(0,("gig::Engine new diskthread = NULL\n"));
263     exit(EXIT_FAILURE);
264     }
265    
266 schoenebeck 271 for (RTList<Voice>::Iterator iterVoice = pVoicePool->allocAppend(); iterVoice == pVoicePool->last(); iterVoice = pVoicePool->allocAppend()) {
267     iterVoice->pDiskThread = this->pDiskThread;
268 schoenebeck 53 dmsg(3,("d"));
269     }
270     pVoicePool->clear();
271    
272     // (re)create event generator
273     if (pEventGenerator) delete pEventGenerator;
274     pEventGenerator = new EventGenerator(pAudioOut->SampleRate());
275    
276     dmsg(1,("Starting disk thread..."));
277     pDiskThread->StartThread();
278     dmsg(1,("OK\n"));
279    
280 schoenebeck 271 for (RTList<Voice>::Iterator iterVoice = pVoicePool->allocAppend(); iterVoice == pVoicePool->last(); iterVoice = pVoicePool->allocAppend()) {
281     if (!iterVoice->pDiskThread) {
282 schoenebeck 53 dmsg(0,("Engine -> voice::trigger: !pDiskThread\n"));
283     exit(EXIT_FAILURE);
284     }
285     }
286     }
287    
288 schoenebeck 473 /**
289     * Clear all engine global event lists.
290     */
291 schoenebeck 412 void Engine::ClearEventLists() {
292 schoenebeck 460 pGlobalEvents->clear();
293 schoenebeck 412 }
294    
295 schoenebeck 53 /**
296 schoenebeck 460 * Copy all events from the engine's global input queue buffer to the
297     * engine's internal event list. This will be done at the beginning of
298     * each audio cycle (that is each RenderAudio() call) to distinguish
299     * all global events which have to be processed in the current audio
300     * cycle. These events are usually just SysEx messages. Every
301     * EngineChannel has it's own input event queue buffer and event list
302     * to handle common events like NoteOn, NoteOff and ControlChange
303     * events.
304 schoenebeck 412 *
305 schoenebeck 460 * @param Samples - number of sample points to be processed in the
306     * current audio cycle
307 schoenebeck 412 */
308 schoenebeck 460 void Engine::ImportEvents(uint Samples) {
309 schoenebeck 412 RingBuffer<Event>::NonVolatileReader eventQueueReader = pEventQueue->get_non_volatile_reader();
310     Event* pEvent;
311     while (true) {
312     // get next event from input event queue
313     if (!(pEvent = eventQueueReader.pop())) break;
314     // if younger event reached, ignore that and all subsequent ones for now
315     if (pEvent->FragmentPos() >= Samples) {
316     eventQueueReader--;
317     dmsg(2,("Younger Event, pos=%d ,Samples=%d!\n",pEvent->FragmentPos(),Samples));
318     pEvent->ResetFragmentPos();
319     break;
320     }
321     // copy event to internal event list
322 schoenebeck 460 if (pGlobalEvents->poolIsEmpty()) {
323 schoenebeck 412 dmsg(1,("Event pool emtpy!\n"));
324     break;
325     }
326 schoenebeck 460 *pGlobalEvents->allocAppend() = *pEvent;
327 schoenebeck 412 }
328     eventQueueReader.free(); // free all copied events from input queue
329 persson 438 }
330 schoenebeck 412
331     /**
332 schoenebeck 53 * Let this engine proceed to render the given amount of sample points. The
333     * calculated audio data of all voices of this engine will be placed into
334     * the engine's audio sum buffer which has to be copied and eventually be
335     * converted to the appropriate value range by the audio output class (e.g.
336     * AlsaIO or JackIO) right after.
337     *
338     * @param Samples - number of sample points to be rendered
339     * @returns 0 on success
340     */
341 schoenebeck 412 int Engine::RenderAudio(uint Samples) {
342 schoenebeck 53 dmsg(5,("RenderAudio(Samples=%d)\n", Samples));
343    
344 schoenebeck 412 // return if engine disabled
345 schoenebeck 53 if (EngineDisabled.Pop()) {
346     dmsg(5,("gig::Engine: engine disabled (val=%d)\n",EngineDisabled.GetUnsafe()));
347     return 0;
348     }
349    
350 schoenebeck 293 // update time of start and end of this audio fragment (as events' time stamps relate to this)
351     pEventGenerator->UpdateFragmentTime(Samples);
352    
353 schoenebeck 663 // We only allow a maximum of CONFIG_MAX_VOICES voices to be spawned
354     // in each audio fragment. All subsequent request for spawning new
355     // voices in the same audio fragment will be ignored.
356     VoiceSpawnsLeft = CONFIG_MAX_VOICES;
357    
358 schoenebeck 412 // get all events from the engine's global input event queue which belong to the current fragment
359     // (these are usually just SysEx messages)
360 schoenebeck 460 ImportEvents(Samples);
361 schoenebeck 412
362     // process engine global events (these are currently only MIDI System Exclusive messages)
363     {
364 schoenebeck 460 RTList<Event>::Iterator itEvent = pGlobalEvents->first();
365     RTList<Event>::Iterator end = pGlobalEvents->end();
366 schoenebeck 412 for (; itEvent != end; ++itEvent) {
367     switch (itEvent->Type) {
368     case Event::type_sysex:
369     dmsg(5,("Engine: Sysex received\n"));
370     ProcessSysex(itEvent);
371     break;
372     }
373     }
374 schoenebeck 53 }
375 schoenebeck 412
376     // reset internal voice counter (just for statistic of active voices)
377     ActiveVoiceCountTemp = 0;
378    
379 schoenebeck 466 // handle events on all engine channels
380 schoenebeck 460 for (int i = 0; i < engineChannels.size(); i++) {
381     if (!engineChannels[i]->pInstrument) continue; // ignore if no instrument loaded
382     ProcessEvents(engineChannels[i], Samples);
383 schoenebeck 466 }
384    
385     // render all 'normal', active voices on all engine channels
386     for (int i = 0; i < engineChannels.size(); i++) {
387     if (!engineChannels[i]->pInstrument) continue; // ignore if no instrument loaded
388 schoenebeck 460 RenderActiveVoices(engineChannels[i], Samples);
389 schoenebeck 412 }
390    
391 schoenebeck 460 // now that all ordinary voices on ALL engine channels are rendered, render new stolen voices
392     RenderStolenVoices(Samples);
393    
394     // handle cleanup on all engine channels for the next audio fragment
395     for (int i = 0; i < engineChannels.size(); i++) {
396     if (!engineChannels[i]->pInstrument) continue; // ignore if no instrument loaded
397     PostProcess(engineChannels[i]);
398     }
399    
400    
401     // empty the engine's event list for the next audio fragment
402     ClearEventLists();
403    
404     // reset voice stealing for the next audio fragment
405     pVoiceStealingQueue->clear();
406    
407 schoenebeck 412 // just some statistics about this engine instance
408     ActiveVoiceCount = ActiveVoiceCountTemp;
409     if (ActiveVoiceCount > ActiveVoiceCountMax) ActiveVoiceCountMax = ActiveVoiceCount;
410    
411 persson 630 FrameTime += Samples;
412    
413 schoenebeck 412 return 0;
414     }
415    
416 schoenebeck 473 /**
417     * Dispatch and handle all events in this audio fragment for the given
418     * engine channel.
419     *
420     * @param pEngineChannel - engine channel on which events should be
421     * processed
422     * @param Samples - amount of sample points to be processed in
423     * this audio fragment cycle
424     */
425 schoenebeck 460 void Engine::ProcessEvents(EngineChannel* pEngineChannel, uint Samples) {
426 schoenebeck 412 // get all events from the engine channels's input event queue which belong to the current fragment
427     // (these are the common events like NoteOn, NoteOff, ControlChange, etc.)
428 schoenebeck 460 pEngineChannel->ImportEvents(Samples);
429 schoenebeck 53
430     // process events
431 schoenebeck 271 {
432 schoenebeck 460 RTList<Event>::Iterator itEvent = pEngineChannel->pEvents->first();
433     RTList<Event>::Iterator end = pEngineChannel->pEvents->end();
434 schoenebeck 271 for (; itEvent != end; ++itEvent) {
435     switch (itEvent->Type) {
436     case Event::type_note_on:
437     dmsg(5,("Engine: Note on received\n"));
438 schoenebeck 412 ProcessNoteOn((EngineChannel*)itEvent->pEngineChannel, itEvent);
439 schoenebeck 271 break;
440     case Event::type_note_off:
441     dmsg(5,("Engine: Note off received\n"));
442 schoenebeck 412 ProcessNoteOff((EngineChannel*)itEvent->pEngineChannel, itEvent);
443 schoenebeck 271 break;
444     case Event::type_control_change:
445     dmsg(5,("Engine: MIDI CC received\n"));
446 schoenebeck 412 ProcessControlChange((EngineChannel*)itEvent->pEngineChannel, itEvent);
447 schoenebeck 271 break;
448     case Event::type_pitchbend:
449     dmsg(5,("Engine: Pitchbend received\n"));
450 schoenebeck 412 ProcessPitchbend((EngineChannel*)itEvent->pEngineChannel, itEvent);
451 schoenebeck 271 break;
452     }
453 schoenebeck 53 }
454     }
455 schoenebeck 649
456     // reset voice stealing for the next engine channel (or next audio fragment)
457     itLastStolenVoice = RTList<Voice>::Iterator();
458     itLastStolenVoiceGlobally = RTList<Voice>::Iterator();
459     iuiLastStolenKey = RTList<uint>::Iterator();
460     iuiLastStolenKeyGlobally = RTList<uint>::Iterator();
461     pLastStolenChannel = NULL;
462 schoenebeck 460 }
463 schoenebeck 53
464 schoenebeck 473 /**
465     * Render all 'normal' voices (that is voices which were not stolen in
466     * this fragment) on the given engine channel.
467     *
468     * @param pEngineChannel - engine channel on which audio should be
469     * rendered
470     * @param Samples - amount of sample points to be rendered in
471     * this audio fragment cycle
472     */
473 schoenebeck 460 void Engine::RenderActiveVoices(EngineChannel* pEngineChannel, uint Samples) {
474 iliev 716 #if !CONFIG_PROCESS_MUTED_CHANNELS
475 schoenebeck 705 if (pEngineChannel->GetMute()) return; // skip if sampler channel is muted
476 iliev 716 #endif
477 schoenebeck 705
478 schoenebeck 460 RTList<uint>::Iterator iuiKey = pEngineChannel->pActiveKeys->first();
479     RTList<uint>::Iterator end = pEngineChannel->pActiveKeys->end();
480     while (iuiKey != end) { // iterate through all active keys
481     midi_key_info_t* pKey = &pEngineChannel->pMIDIKeyInfo[*iuiKey];
482     ++iuiKey;
483 schoenebeck 53
484 schoenebeck 460 RTList<Voice>::Iterator itVoice = pKey->pActiveVoices->first();
485     RTList<Voice>::Iterator itVoicesEnd = pKey->pActiveVoices->end();
486     for (; itVoice != itVoicesEnd; ++itVoice) { // iterate through all voices on this key
487     // now render current voice
488     itVoice->Render(Samples);
489     if (itVoice->IsActive()) ActiveVoiceCountTemp++; // still active
490     else { // voice reached end, is now inactive
491     FreeVoice(pEngineChannel, itVoice); // remove voice from the list of active voices
492 schoenebeck 53 }
493     }
494     }
495 schoenebeck 460 }
496 schoenebeck 53
497 schoenebeck 473 /**
498     * Render all stolen voices (only voices which were stolen in this
499     * fragment) on the given engine channel. Stolen voices are rendered
500     * after all normal voices have been rendered; this is needed to render
501     * audio of those voices which were selected for voice stealing until
502     * the point were the stealing (that is the take over of the voice)
503     * actually happened.
504     *
505     * @param pEngineChannel - engine channel on which audio should be
506     * rendered
507     * @param Samples - amount of sample points to be rendered in
508     * this audio fragment cycle
509     */
510 schoenebeck 460 void Engine::RenderStolenVoices(uint Samples) {
511     RTList<Event>::Iterator itVoiceStealEvent = pVoiceStealingQueue->first();
512     RTList<Event>::Iterator end = pVoiceStealingQueue->end();
513     for (; itVoiceStealEvent != end; ++itVoiceStealEvent) {
514     EngineChannel* pEngineChannel = (EngineChannel*) itVoiceStealEvent->pEngineChannel;
515     Pool<Voice>::Iterator itNewVoice =
516 schoenebeck 668 LaunchVoice(pEngineChannel, itVoiceStealEvent, itVoiceStealEvent->Param.Note.Layer, itVoiceStealEvent->Param.Note.ReleaseTrigger, false, false);
517 schoenebeck 460 if (itNewVoice) {
518     itNewVoice->Render(Samples);
519     if (itNewVoice->IsActive()) ActiveVoiceCountTemp++; // still active
520     else { // voice reached end, is now inactive
521     FreeVoice(pEngineChannel, itNewVoice); // remove voice from the list of active voices
522 schoenebeck 250 }
523     }
524 schoenebeck 460 else dmsg(1,("gig::Engine: ERROR, voice stealing didn't work out!\n"));
525 schoenebeck 473
526     // we need to clear the key's event list explicitly here in case key was never active
527     midi_key_info_t* pKey = &pEngineChannel->pMIDIKeyInfo[itVoiceStealEvent->Param.Note.Key];
528     pKey->VoiceTheftsQueued--;
529     if (!pKey->Active && !pKey->VoiceTheftsQueued) pKey->pEvents->clear();
530 schoenebeck 250 }
531 schoenebeck 460 }
532 schoenebeck 250
533 schoenebeck 473 /**
534     * Free all keys which have turned inactive in this audio fragment, from
535     * the list of active keys and clear all event lists on that engine
536     * channel.
537     *
538     * @param pEngineChannel - engine channel to cleanup
539     */
540 schoenebeck 460 void Engine::PostProcess(EngineChannel* pEngineChannel) {
541 schoenebeck 287 // free all keys which have no active voices left
542     {
543 schoenebeck 411 RTList<uint>::Iterator iuiKey = pEngineChannel->pActiveKeys->first();
544     RTList<uint>::Iterator end = pEngineChannel->pActiveKeys->end();
545 schoenebeck 287 while (iuiKey != end) { // iterate through all active keys
546 schoenebeck 411 midi_key_info_t* pKey = &pEngineChannel->pMIDIKeyInfo[*iuiKey];
547 schoenebeck 287 ++iuiKey;
548 schoenebeck 411 if (pKey->pActiveVoices->isEmpty()) FreeKey(pEngineChannel, pKey);
549 schoenebeck 554 #if CONFIG_DEVMODE
550 schoenebeck 563 else { // just a sanity check for debugging
551 schoenebeck 287 RTList<Voice>::Iterator itVoice = pKey->pActiveVoices->first();
552     RTList<Voice>::Iterator itVoicesEnd = pKey->pActiveVoices->end();
553     for (; itVoice != itVoicesEnd; ++itVoice) { // iterate through all voices on this key
554     if (itVoice->itKillEvent) {
555     dmsg(1,("gig::Engine: ERROR, killed voice survived !!!\n"));
556     }
557     }
558     }
559 schoenebeck 554 #endif // CONFIG_DEVMODE
560 schoenebeck 287 }
561     }
562 schoenebeck 460
563     // empty the engine channel's own event lists
564     pEngineChannel->ClearEventLists();
565 schoenebeck 412 }
566 schoenebeck 287
567 schoenebeck 53 /**
568 schoenebeck 244 * Will be called by the MIDI input device whenever a MIDI system
569     * exclusive message has arrived.
570     *
571     * @param pData - pointer to sysex data
572     * @param Size - lenght of sysex data (in bytes)
573     */
574     void Engine::SendSysex(void* pData, uint Size) {
575 schoenebeck 246 Event event = pEventGenerator->CreateEvent();
576     event.Type = Event::type_sysex;
577     event.Param.Sysex.Size = Size;
578 schoenebeck 412 event.pEngineChannel = NULL; // as Engine global event
579 schoenebeck 244 if (pEventQueue->write_space() > 0) {
580     if (pSysexBuffer->write_space() >= Size) {
581     // copy sysex data to input buffer
582     uint toWrite = Size;
583     uint8_t* pPos = (uint8_t*) pData;
584     while (toWrite) {
585     const uint writeNow = RTMath::Min(toWrite, pSysexBuffer->write_space_to_end());
586     pSysexBuffer->write(pPos, writeNow);
587     toWrite -= writeNow;
588     pPos += writeNow;
589    
590     }
591     // finally place sysex event into input event queue
592     pEventQueue->push(&event);
593     }
594 schoenebeck 554 else dmsg(1,("Engine: Sysex message too large (%d byte) for input buffer (%d byte)!",Size,CONFIG_SYSEX_BUFFER_SIZE));
595 schoenebeck 244 }
596     else dmsg(1,("Engine: Input event queue full!"));
597     }
598    
599     /**
600 schoenebeck 53 * Assigns and triggers a new voice for the respective MIDI key.
601     *
602 schoenebeck 411 * @param pEngineChannel - engine channel on which this event occured on
603 schoenebeck 271 * @param itNoteOnEvent - key, velocity and time stamp of the event
604 schoenebeck 53 */
605 schoenebeck 411 void Engine::ProcessNoteOn(EngineChannel* pEngineChannel, Pool<Event>::Iterator& itNoteOnEvent) {
606 iliev 716 #if !CONFIG_PROCESS_MUTED_CHANNELS
607     if (pEngineChannel->GetMute()) return; // skip if sampler channel is muted
608     #endif
609 persson 438
610 schoenebeck 354 const int key = itNoteOnEvent->Param.Note.Key;
611 schoenebeck 829 midi_key_info_t* pKey = &pEngineChannel->pMIDIKeyInfo[key];
612 schoenebeck 354
613 schoenebeck 829 // move note on event to the key's own event list
614     RTList<Event>::Iterator itNoteOnEventOnKeyList = itNoteOnEvent.moveToEndOf(pKey->pEvents);
615    
616     // if Solo Mode then kill all already active voices
617     if (pEngineChannel->SoloMode) {
618     Pool<uint>::Iterator itYoungestKey = pEngineChannel->pActiveKeys->last();
619     if (itYoungestKey) {
620     const int iYoungestKey = *itYoungestKey;
621     const midi_key_info_t* pOtherKey = &pEngineChannel->pMIDIKeyInfo[iYoungestKey];
622     if (pOtherKey->Active) {
623     // get final portamento position of currently active voice
624     if (pEngineChannel->PortamentoMode) {
625     RTList<Voice>::Iterator itVoice = pOtherKey->pActiveVoices->last();
626     if (itVoice) itVoice->UpdatePortamentoPos(itNoteOnEventOnKeyList);
627     }
628     // kill all voices on the (other) key
629     RTList<Voice>::Iterator itVoiceToBeKilled = pOtherKey->pActiveVoices->first();
630     RTList<Voice>::Iterator end = pOtherKey->pActiveVoices->end();
631     for (; itVoiceToBeKilled != end; ++itVoiceToBeKilled) {
632     if (itVoiceToBeKilled->Type != Voice::type_release_trigger)
633     itVoiceToBeKilled->Kill(itNoteOnEventOnKeyList);
634     }
635     }
636     }
637     // set this key as 'currently active solo key'
638     pEngineChannel->SoloKey = key;
639     }
640    
641 schoenebeck 354 // Change key dimension value if key is in keyswitching area
642 schoenebeck 411 {
643     const ::gig::Instrument* pInstrument = pEngineChannel->pInstrument;
644     if (key >= pInstrument->DimensionKeyRange.low && key <= pInstrument->DimensionKeyRange.high)
645     pEngineChannel->CurrentKeyDimension = ((key - pInstrument->DimensionKeyRange.low) * 128) /
646     (pInstrument->DimensionKeyRange.high - pInstrument->DimensionKeyRange.low + 1);
647     }
648 schoenebeck 354
649 schoenebeck 53 pKey->KeyPressed = true; // the MIDI key was now pressed down
650 schoenebeck 829 pKey->Velocity = itNoteOnEventOnKeyList->Param.Note.Velocity;
651     pKey->NoteOnTime = FrameTime + itNoteOnEventOnKeyList->FragmentPos(); // will be used to calculate note length
652 schoenebeck 53
653     // cancel release process of voices on this key if needed
654 schoenebeck 411 if (pKey->Active && !pEngineChannel->SustainPedal) {
655 schoenebeck 271 RTList<Event>::Iterator itCancelReleaseEvent = pKey->pEvents->allocAppend();
656     if (itCancelReleaseEvent) {
657 schoenebeck 829 *itCancelReleaseEvent = *itNoteOnEventOnKeyList; // copy event
658 schoenebeck 271 itCancelReleaseEvent->Type = Event::type_cancel_release; // transform event type
659 schoenebeck 239 }
660     else dmsg(1,("Event pool emtpy!\n"));
661 schoenebeck 53 }
662    
663 schoenebeck 460 // allocate and trigger new voice(s) for the key
664     {
665     // first, get total amount of required voices (dependant on amount of layers)
666     ::gig::Region* pRegion = pEngineChannel->pInstrument->GetRegion(itNoteOnEventOnKeyList->Param.Note.Key);
667     if (pRegion) {
668     int voicesRequired = pRegion->Layers;
669     // now launch the required amount of voices
670     for (int i = 0; i < voicesRequired; i++)
671 schoenebeck 668 LaunchVoice(pEngineChannel, itNoteOnEventOnKeyList, i, false, true, true);
672 schoenebeck 460 }
673     }
674 persson 438
675 schoenebeck 473 // if neither a voice was spawned or postponed then remove note on event from key again
676     if (!pKey->Active && !pKey->VoiceTheftsQueued)
677     pKey->pEvents->free(itNoteOnEventOnKeyList);
678    
679 schoenebeck 829 if (!pEngineChannel->SoloMode || pEngineChannel->PortamentoPos < 0.0f) pEngineChannel->PortamentoPos = (float) key;
680 persson 438 pKey->RoundRobinIndex++;
681 schoenebeck 53 }
682    
683     /**
684     * Releases the voices on the given key if sustain pedal is not pressed.
685     * If sustain is pressed, the release of the note will be postponed until
686     * sustain pedal will be released or voice turned inactive by itself (e.g.
687     * due to completion of sample playback).
688     *
689 schoenebeck 411 * @param pEngineChannel - engine channel on which this event occured on
690 schoenebeck 271 * @param itNoteOffEvent - key, velocity and time stamp of the event
691 schoenebeck 53 */
692 schoenebeck 411 void Engine::ProcessNoteOff(EngineChannel* pEngineChannel, Pool<Event>::Iterator& itNoteOffEvent) {
693 iliev 716 #if !CONFIG_PROCESS_MUTED_CHANNELS
694 schoenebeck 705 if (pEngineChannel->GetMute()) return; // skip if sampler channel is muted
695 iliev 716 #endif
696 schoenebeck 705
697 schoenebeck 829 const int iKey = itNoteOffEvent->Param.Note.Key;
698     midi_key_info_t* pKey = &pEngineChannel->pMIDIKeyInfo[iKey];
699 schoenebeck 53 pKey->KeyPressed = false; // the MIDI key was now released
700    
701 schoenebeck 829 // move event to the key's own event list
702     RTList<Event>::Iterator itNoteOffEventOnKeyList = itNoteOffEvent.moveToEndOf(pKey->pEvents);
703 schoenebeck 242
704 schoenebeck 829 bool bShouldRelease = pKey->Active && ShouldReleaseVoice(pEngineChannel, itNoteOffEventOnKeyList->Param.Note.Key);
705 schoenebeck 271
706 schoenebeck 829 // in case Solo Mode is enabled, kill all voices on this key and respawn a voice on the highest pressed key (if any)
707     if (pEngineChannel->SoloMode) { //TODO: this feels like too much code just for handling solo mode :P
708     bool bOtherKeysPressed = false;
709     if (iKey == pEngineChannel->SoloKey) {
710     pEngineChannel->SoloKey = -1;
711     // if there's still a key pressed down, respawn a voice (group) on the highest key
712     for (int i = 127; i > 0; i--) {
713     midi_key_info_t* pOtherKey = &pEngineChannel->pMIDIKeyInfo[i];
714     if (pOtherKey->KeyPressed) {
715     bOtherKeysPressed = true;
716     // make the other key the new 'currently active solo key'
717     pEngineChannel->SoloKey = i;
718     // get final portamento position of currently active voice
719     if (pEngineChannel->PortamentoMode) {
720     RTList<Voice>::Iterator itVoice = pKey->pActiveVoices->first();
721     if (itVoice) itVoice->UpdatePortamentoPos(itNoteOffEventOnKeyList);
722     }
723     // create a pseudo note on event
724     RTList<Event>::Iterator itPseudoNoteOnEvent = pOtherKey->pEvents->allocAppend();
725     if (itPseudoNoteOnEvent) {
726     // copy event
727     *itPseudoNoteOnEvent = *itNoteOffEventOnKeyList;
728     // transform event to a note on event
729     itPseudoNoteOnEvent->Type = Event::type_note_on;
730     itPseudoNoteOnEvent->Param.Note.Key = i;
731     itPseudoNoteOnEvent->Param.Note.Velocity = pOtherKey->Velocity;
732     // allocate and trigger new voice(s) for the other key
733     {
734     // first, get total amount of required voices (dependant on amount of layers)
735     ::gig::Region* pRegion = pEngineChannel->pInstrument->GetRegion(i);
736     if (pRegion) {
737     int voicesRequired = pRegion->Layers;
738     // now launch the required amount of voices
739     for (int iLayer = 0; iLayer < voicesRequired; iLayer++)
740     LaunchVoice(pEngineChannel, itPseudoNoteOnEvent, iLayer, false, true, false);
741     }
742     }
743     // if neither a voice was spawned or postponed then remove note on event from key again
744     if (!pOtherKey->Active && !pOtherKey->VoiceTheftsQueued)
745     pOtherKey->pEvents->free(itPseudoNoteOnEvent);
746    
747     } else dmsg(1,("Could not respawn voice, no free event left\n"));
748     break; // done
749     }
750     }
751     }
752     if (bOtherKeysPressed) {
753     if (pKey->Active) { // kill all voices on this key
754     bShouldRelease = false; // no need to release, as we kill it here
755     RTList<Voice>::Iterator itVoiceToBeKilled = pKey->pActiveVoices->first();
756     RTList<Voice>::Iterator end = pKey->pActiveVoices->end();
757     for (; itVoiceToBeKilled != end; ++itVoiceToBeKilled) {
758     if (itVoiceToBeKilled->Type != Voice::type_release_trigger)
759     itVoiceToBeKilled->Kill(itNoteOffEventOnKeyList);
760     }
761     }
762     } else pEngineChannel->PortamentoPos = -1.0f;
763     }
764    
765     // if no solo mode (the usual case) or if solo mode and no other key pressed, then release voices on this key if needed
766     if (bShouldRelease) {
767     itNoteOffEventOnKeyList->Type = Event::type_release; // transform event type
768    
769 persson 497 // spawn release triggered voice(s) if needed
770 persson 630 if (pKey->ReleaseTrigger) {
771 persson 497 // first, get total amount of required voices (dependant on amount of layers)
772     ::gig::Region* pRegion = pEngineChannel->pInstrument->GetRegion(itNoteOffEventOnKeyList->Param.Note.Key);
773     if (pRegion) {
774     int voicesRequired = pRegion->Layers;
775 persson 630
776     // MIDI note-on velocity is used instead of note-off velocity
777     itNoteOffEventOnKeyList->Param.Note.Velocity = pKey->Velocity;
778    
779 persson 497 // now launch the required amount of voices
780     for (int i = 0; i < voicesRequired; i++)
781 schoenebeck 668 LaunchVoice(pEngineChannel, itNoteOffEventOnKeyList, i, true, false, false); //FIXME: for the moment we don't perform voice stealing for release triggered samples
782 persson 497 }
783     pKey->ReleaseTrigger = false;
784 schoenebeck 460 }
785 schoenebeck 829 }
786 persson 497
787 schoenebeck 829 // if neither a voice was spawned or postponed on this key then remove note off event from key again
788     if (!pKey->Active && !pKey->VoiceTheftsQueued)
789     pKey->pEvents->free(itNoteOffEventOnKeyList);
790 schoenebeck 53 }
791    
792     /**
793 schoenebeck 738 * Moves pitchbend event from the general (input) event list to the engine
794     * channel's event list. It will actually processed later by the
795     * respective voice.
796 schoenebeck 53 *
797 schoenebeck 411 * @param pEngineChannel - engine channel on which this event occured on
798 schoenebeck 271 * @param itPitchbendEvent - absolute pitch value and time stamp of the event
799 schoenebeck 53 */
800 schoenebeck 411 void Engine::ProcessPitchbend(EngineChannel* pEngineChannel, Pool<Event>::Iterator& itPitchbendEvent) {
801     pEngineChannel->Pitch = itPitchbendEvent->Param.Pitch.Pitch; // store current pitch value
802 schoenebeck 53 }
803    
804     /**
805 schoenebeck 233 * Allocates and triggers a new voice. This method will usually be
806     * called by the ProcessNoteOn() method and by the voices itself
807     * (e.g. to spawn further voices on the same key for layered sounds).
808     *
809 schoenebeck 411 * @param pEngineChannel - engine channel on which this event occured on
810 schoenebeck 271 * @param itNoteOnEvent - key, velocity and time stamp of the event
811 schoenebeck 242 * @param iLayer - layer index for the new voice (optional - only
812     * in case of layered sounds of course)
813     * @param ReleaseTriggerVoice - if new voice is a release triggered voice
814     * (optional, default = false)
815 schoenebeck 250 * @param VoiceStealing - if voice stealing should be performed
816     * when there is no free voice
817     * (optional, default = true)
818 schoenebeck 668 * @param HandleKeyGroupConflicts - if voices should be killed due to a
819     * key group conflict
820 schoenebeck 250 * @returns pointer to new voice or NULL if there was no free voice or
821 schoenebeck 354 * if the voice wasn't triggered (for example when no region is
822     * defined for the given key).
823 schoenebeck 233 */
824 schoenebeck 668 Pool<Voice>::Iterator Engine::LaunchVoice(EngineChannel* pEngineChannel, Pool<Event>::Iterator& itNoteOnEvent, int iLayer, bool ReleaseTriggerVoice, bool VoiceStealing, bool HandleKeyGroupConflicts) {
825 schoenebeck 669 int MIDIKey = itNoteOnEvent->Param.Note.Key;
826     midi_key_info_t* pKey = &pEngineChannel->pMIDIKeyInfo[MIDIKey];
827     ::gig::Region* pRegion = pEngineChannel->pInstrument->GetRegion(MIDIKey);
828 schoenebeck 233
829 schoenebeck 668 // if nothing defined for this key
830     if (!pRegion) return Pool<Voice>::Iterator(); // nothing to do
831    
832 schoenebeck 669 // only mark the first voice of a layered voice (group) to be in a
833     // key group, so the layered voices won't kill each other
834     int iKeyGroup = (iLayer == 0 && !ReleaseTriggerVoice) ? pRegion->KeyGroup : 0;
835    
836 schoenebeck 668 // handle key group (a.k.a. exclusive group) conflicts
837     if (HandleKeyGroupConflicts) {
838     if (iKeyGroup) { // if this voice / key belongs to a key group
839     uint** ppKeyGroup = &pEngineChannel->ActiveKeyGroups[iKeyGroup];
840     if (*ppKeyGroup) { // if there's already an active key in that key group
841     midi_key_info_t* pOtherKey = &pEngineChannel->pMIDIKeyInfo[**ppKeyGroup];
842     // kill all voices on the (other) key
843     RTList<Voice>::Iterator itVoiceToBeKilled = pOtherKey->pActiveVoices->first();
844     RTList<Voice>::Iterator end = pOtherKey->pActiveVoices->end();
845     for (; itVoiceToBeKilled != end; ++itVoiceToBeKilled) {
846     if (itVoiceToBeKilled->Type != Voice::type_release_trigger) {
847     itVoiceToBeKilled->Kill(itNoteOnEvent);
848     --VoiceSpawnsLeft; //FIXME: just a hack, we should better check in StealVoice() if the voice was killed due to key conflict
849     }
850     }
851     }
852     }
853     }
854    
855 schoenebeck 669 Voice::type_t VoiceType = Voice::type_normal;
856    
857     // get current dimension values to select the right dimension region
858     //TODO: for stolen voices this dimension region selection block is processed twice, this should be changed
859     //FIXME: controller values for selecting the dimension region here are currently not sample accurate
860     uint DimValues[8] = { 0 };
861     for (int i = pRegion->Dimensions - 1; i >= 0; i--) {
862     switch (pRegion->pDimensionDefinitions[i].dimension) {
863     case ::gig::dimension_samplechannel:
864     DimValues[i] = 0; //TODO: we currently ignore this dimension
865     break;
866     case ::gig::dimension_layer:
867     DimValues[i] = iLayer;
868     break;
869     case ::gig::dimension_velocity:
870     DimValues[i] = itNoteOnEvent->Param.Note.Velocity;
871     break;
872     case ::gig::dimension_channelaftertouch:
873     DimValues[i] = 0; //TODO: we currently ignore this dimension
874     break;
875     case ::gig::dimension_releasetrigger:
876     VoiceType = (ReleaseTriggerVoice) ? Voice::type_release_trigger : (!iLayer) ? Voice::type_release_trigger_required : Voice::type_normal;
877     DimValues[i] = (uint) ReleaseTriggerVoice;
878     break;
879     case ::gig::dimension_keyboard:
880     DimValues[i] = (uint) pEngineChannel->CurrentKeyDimension;
881     break;
882     case ::gig::dimension_roundrobin:
883     DimValues[i] = (uint) pEngineChannel->pMIDIKeyInfo[MIDIKey].RoundRobinIndex; // incremented for each note on
884     break;
885     case ::gig::dimension_random:
886     RandomSeed = RandomSeed * 1103515245 + 12345; // classic pseudo random number generator
887     DimValues[i] = (uint) RandomSeed >> (32 - pRegion->pDimensionDefinitions[i].bits); // highest bits are most random
888     break;
889     case ::gig::dimension_modwheel:
890     DimValues[i] = pEngineChannel->ControllerTable[1];
891     break;
892     case ::gig::dimension_breath:
893     DimValues[i] = pEngineChannel->ControllerTable[2];
894     break;
895     case ::gig::dimension_foot:
896     DimValues[i] = pEngineChannel->ControllerTable[4];
897     break;
898     case ::gig::dimension_portamentotime:
899     DimValues[i] = pEngineChannel->ControllerTable[5];
900     break;
901     case ::gig::dimension_effect1:
902     DimValues[i] = pEngineChannel->ControllerTable[12];
903     break;
904     case ::gig::dimension_effect2:
905     DimValues[i] = pEngineChannel->ControllerTable[13];
906     break;
907     case ::gig::dimension_genpurpose1:
908     DimValues[i] = pEngineChannel->ControllerTable[16];
909     break;
910     case ::gig::dimension_genpurpose2:
911     DimValues[i] = pEngineChannel->ControllerTable[17];
912     break;
913     case ::gig::dimension_genpurpose3:
914     DimValues[i] = pEngineChannel->ControllerTable[18];
915     break;
916     case ::gig::dimension_genpurpose4:
917     DimValues[i] = pEngineChannel->ControllerTable[19];
918     break;
919     case ::gig::dimension_sustainpedal:
920     DimValues[i] = pEngineChannel->ControllerTable[64];
921     break;
922     case ::gig::dimension_portamento:
923     DimValues[i] = pEngineChannel->ControllerTable[65];
924     break;
925     case ::gig::dimension_sostenutopedal:
926     DimValues[i] = pEngineChannel->ControllerTable[66];
927     break;
928     case ::gig::dimension_softpedal:
929     DimValues[i] = pEngineChannel->ControllerTable[67];
930     break;
931     case ::gig::dimension_genpurpose5:
932     DimValues[i] = pEngineChannel->ControllerTable[80];
933     break;
934     case ::gig::dimension_genpurpose6:
935     DimValues[i] = pEngineChannel->ControllerTable[81];
936     break;
937     case ::gig::dimension_genpurpose7:
938     DimValues[i] = pEngineChannel->ControllerTable[82];
939     break;
940     case ::gig::dimension_genpurpose8:
941     DimValues[i] = pEngineChannel->ControllerTable[83];
942     break;
943     case ::gig::dimension_effect1depth:
944     DimValues[i] = pEngineChannel->ControllerTable[91];
945     break;
946     case ::gig::dimension_effect2depth:
947     DimValues[i] = pEngineChannel->ControllerTable[92];
948     break;
949     case ::gig::dimension_effect3depth:
950     DimValues[i] = pEngineChannel->ControllerTable[93];
951     break;
952     case ::gig::dimension_effect4depth:
953     DimValues[i] = pEngineChannel->ControllerTable[94];
954     break;
955     case ::gig::dimension_effect5depth:
956     DimValues[i] = pEngineChannel->ControllerTable[95];
957     break;
958     case ::gig::dimension_none:
959     std::cerr << "gig::Engine::LaunchVoice() Error: dimension=none\n" << std::flush;
960     break;
961     default:
962     std::cerr << "gig::Engine::LaunchVoice() Error: Unknown dimension\n" << std::flush;
963     }
964     }
965     ::gig::DimensionRegion* pDimRgn = pRegion->GetDimensionRegionByValue(DimValues);
966    
967     // no need to continue if sample is silent
968     if (!pDimRgn->pSample || !pDimRgn->pSample->SamplesTotal) return Pool<Voice>::Iterator();
969    
970 schoenebeck 233 // allocate a new voice for the key
971 schoenebeck 271 Pool<Voice>::Iterator itNewVoice = pKey->pActiveVoices->allocAppend();
972     if (itNewVoice) {
973 schoenebeck 233 // launch the new voice
974 schoenebeck 669 if (itNewVoice->Trigger(pEngineChannel, itNoteOnEvent, pEngineChannel->Pitch, pDimRgn, VoiceType, iKeyGroup) < 0) {
975 schoenebeck 354 dmsg(4,("Voice not triggered\n"));
976 schoenebeck 271 pKey->pActiveVoices->free(itNewVoice);
977 schoenebeck 233 }
978 schoenebeck 239 else { // on success
979 schoenebeck 663 --VoiceSpawnsLeft;
980 schoenebeck 239 if (!pKey->Active) { // mark as active key
981     pKey->Active = true;
982 schoenebeck 411 pKey->itSelf = pEngineChannel->pActiveKeys->allocAppend();
983 schoenebeck 271 *pKey->itSelf = itNoteOnEvent->Param.Note.Key;
984 schoenebeck 239 }
985 schoenebeck 271 if (itNewVoice->KeyGroup) {
986 schoenebeck 668 uint** ppKeyGroup = &pEngineChannel->ActiveKeyGroups[itNewVoice->KeyGroup];
987 schoenebeck 271 *ppKeyGroup = &*pKey->itSelf; // put key as the (new) active key to its key group
988 schoenebeck 239 }
989 schoenebeck 271 if (itNewVoice->Type == Voice::type_release_trigger_required) pKey->ReleaseTrigger = true; // mark key for the need of release triggered voice(s)
990     return itNewVoice; // success
991 schoenebeck 233 }
992     }
993 schoenebeck 285 else if (VoiceStealing) {
994 schoenebeck 460 // try to steal one voice
995 schoenebeck 473 int result = StealVoice(pEngineChannel, itNoteOnEvent);
996     if (!result) { // voice stolen successfully
997     // put note-on event into voice-stealing queue, so it will be reprocessed after killed voice died
998     RTList<Event>::Iterator itStealEvent = pVoiceStealingQueue->allocAppend();
999     if (itStealEvent) {
1000     *itStealEvent = *itNoteOnEvent; // copy event
1001     itStealEvent->Param.Note.Layer = iLayer;
1002     itStealEvent->Param.Note.ReleaseTrigger = ReleaseTriggerVoice;
1003     pKey->VoiceTheftsQueued++;
1004     }
1005     else dmsg(1,("Voice stealing queue full!\n"));
1006 schoenebeck 285 }
1007     }
1008    
1009 schoenebeck 271 return Pool<Voice>::Iterator(); // no free voice or error
1010 schoenebeck 233 }
1011    
1012     /**
1013 schoenebeck 250 * Will be called by LaunchVoice() method in case there are no free
1014     * voices left. This method will select and kill one old voice for
1015     * voice stealing and postpone the note-on event until the selected
1016     * voice actually died.
1017     *
1018 schoenebeck 411 * @param pEngineChannel - engine channel on which this event occured on
1019 schoenebeck 285 * @param itNoteOnEvent - key, velocity and time stamp of the event
1020 schoenebeck 473 * @returns 0 on success, a value < 0 if no active voice could be picked for voice stealing
1021 schoenebeck 250 */
1022 schoenebeck 473 int Engine::StealVoice(EngineChannel* pEngineChannel, Pool<Event>::Iterator& itNoteOnEvent) {
1023 schoenebeck 663 if (VoiceSpawnsLeft <= 0) {
1024 schoenebeck 554 dmsg(1,("Max. voice thefts per audio fragment reached (you may raise CONFIG_MAX_VOICES).\n"));
1025 schoenebeck 473 return -1;
1026 schoenebeck 460 }
1027 schoenebeck 271 if (!pEventPool->poolIsEmpty()) {
1028 schoenebeck 250
1029 schoenebeck 460 RTList<Voice>::Iterator itSelectedVoice;
1030 schoenebeck 250
1031     // Select one voice for voice stealing
1032 schoenebeck 554 switch (CONFIG_VOICE_STEAL_ALGO) {
1033 schoenebeck 250
1034     // try to pick the oldest voice on the key where the new
1035     // voice should be spawned, if there is no voice on that
1036 schoenebeck 563 // key, or no voice left to kill, then procceed with
1037 schoenebeck 250 // 'oldestkey' algorithm
1038 schoenebeck 460 case voice_steal_algo_oldestvoiceonkey: {
1039     midi_key_info_t* pSelectedKey = &pEngineChannel->pMIDIKeyInfo[itNoteOnEvent->Param.Note.Key];
1040 schoenebeck 563 itSelectedVoice = pSelectedKey->pActiveVoices->first();
1041     // proceed iterating if voice was created in this fragment cycle
1042 schoenebeck 663 while (itSelectedVoice && !itSelectedVoice->IsStealable()) ++itSelectedVoice;
1043 schoenebeck 563 // if we haven't found a voice then proceed with algorithm 'oldestkey'
1044 schoenebeck 663 if (itSelectedVoice && itSelectedVoice->IsStealable()) break;
1045 schoenebeck 250 } // no break - intentional !
1046    
1047     // try to pick the oldest voice on the oldest active key
1048 schoenebeck 563 // from the same engine channel
1049 schoenebeck 460 // (caution: must stay after 'oldestvoiceonkey' algorithm !)
1050 schoenebeck 250 case voice_steal_algo_oldestkey: {
1051 schoenebeck 649 // if we already stole in this fragment, try to proceed on same key
1052 schoenebeck 460 if (this->itLastStolenVoice) {
1053     itSelectedVoice = this->itLastStolenVoice;
1054 schoenebeck 649 do {
1055     ++itSelectedVoice;
1056 schoenebeck 663 } while (itSelectedVoice && !itSelectedVoice->IsStealable()); // proceed iterating if voice was created in this fragment cycle
1057 schoenebeck 649 // found a "stealable" voice ?
1058 schoenebeck 663 if (itSelectedVoice && itSelectedVoice->IsStealable()) {
1059 schoenebeck 649 // remember which voice we stole, so we can simply proceed on next voice stealing
1060     this->itLastStolenVoice = itSelectedVoice;
1061 schoenebeck 460 break; // selection succeeded
1062 schoenebeck 250 }
1063     }
1064 schoenebeck 649 // get (next) oldest key
1065     RTList<uint>::Iterator iuiSelectedKey = (this->iuiLastStolenKey) ? ++this->iuiLastStolenKey : pEngineChannel->pActiveKeys->first();
1066     while (iuiSelectedKey) {
1067     midi_key_info_t* pSelectedKey = &pEngineChannel->pMIDIKeyInfo[*iuiSelectedKey];
1068 schoenebeck 659 itSelectedVoice = pSelectedKey->pActiveVoices->first();
1069 schoenebeck 649 // proceed iterating if voice was created in this fragment cycle
1070 schoenebeck 663 while (itSelectedVoice && !itSelectedVoice->IsStealable()) ++itSelectedVoice;
1071 schoenebeck 649 // found a "stealable" voice ?
1072 schoenebeck 663 if (itSelectedVoice && itSelectedVoice->IsStealable()) {
1073 schoenebeck 649 // remember which voice on which key we stole, so we can simply proceed on next voice stealing
1074     this->iuiLastStolenKey = iuiSelectedKey;
1075     this->itLastStolenVoice = itSelectedVoice;
1076     break; // selection succeeded
1077     }
1078     ++iuiSelectedKey; // get next oldest key
1079     }
1080 schoenebeck 250 break;
1081     }
1082    
1083     // don't steal anything
1084     case voice_steal_algo_none:
1085     default: {
1086     dmsg(1,("No free voice (voice stealing disabled)!\n"));
1087 schoenebeck 473 return -1;
1088 schoenebeck 250 }
1089     }
1090    
1091 schoenebeck 563 // if we couldn't steal a voice from the same engine channel then
1092     // steal oldest voice on the oldest key from any other engine channel
1093 schoenebeck 649 // (the smaller engine channel number, the higher priority)
1094 schoenebeck 663 if (!itSelectedVoice || !itSelectedVoice->IsStealable()) {
1095 schoenebeck 649 EngineChannel* pSelectedChannel;
1096     int iChannelIndex;
1097     // select engine channel
1098     if (pLastStolenChannel) {
1099     pSelectedChannel = pLastStolenChannel;
1100     iChannelIndex = pSelectedChannel->iEngineIndexSelf;
1101     } else { // pick the engine channel followed by this engine channel
1102     iChannelIndex = (pEngineChannel->iEngineIndexSelf + 1) % engineChannels.size();
1103     pSelectedChannel = engineChannels[iChannelIndex];
1104     }
1105 schoenebeck 663
1106     // if we already stole in this fragment, try to proceed on same key
1107     if (this->itLastStolenVoiceGlobally) {
1108     itSelectedVoice = this->itLastStolenVoiceGlobally;
1109     do {
1110     ++itSelectedVoice;
1111     } while (itSelectedVoice && !itSelectedVoice->IsStealable()); // proceed iterating if voice was created in this fragment cycle
1112     }
1113    
1114     #if CONFIG_DEVMODE
1115     EngineChannel* pBegin = pSelectedChannel; // to detect endless loop
1116     #endif // CONFIG_DEVMODE
1117    
1118     // did we find a 'stealable' voice?
1119     if (itSelectedVoice && itSelectedVoice->IsStealable()) {
1120     // remember which voice we stole, so we can simply proceed on next voice stealing
1121     this->itLastStolenVoiceGlobally = itSelectedVoice;
1122     } else while (true) { // iterate through engine channels
1123 schoenebeck 649 // get (next) oldest key
1124 schoenebeck 663 RTList<uint>::Iterator iuiSelectedKey = (this->iuiLastStolenKeyGlobally) ? ++this->iuiLastStolenKeyGlobally : pSelectedChannel->pActiveKeys->first();
1125     this->iuiLastStolenKeyGlobally = RTList<uint>::Iterator(); // to prevent endless loop (see line above)
1126 schoenebeck 649 while (iuiSelectedKey) {
1127 schoenebeck 663 midi_key_info_t* pSelectedKey = &pSelectedChannel->pMIDIKeyInfo[*iuiSelectedKey];
1128 schoenebeck 649 itSelectedVoice = pSelectedKey->pActiveVoices->first();
1129     // proceed iterating if voice was created in this fragment cycle
1130 schoenebeck 663 while (itSelectedVoice && !itSelectedVoice->IsStealable()) ++itSelectedVoice;
1131 schoenebeck 649 // found a "stealable" voice ?
1132 schoenebeck 663 if (itSelectedVoice && itSelectedVoice->IsStealable()) {
1133 schoenebeck 649 // remember which voice on which key on which engine channel we stole, so we can simply proceed on next voice stealing
1134     this->iuiLastStolenKeyGlobally = iuiSelectedKey;
1135     this->itLastStolenVoiceGlobally = itSelectedVoice;
1136     this->pLastStolenChannel = pSelectedChannel;
1137 schoenebeck 665 goto stealable_voice_found; // selection succeeded
1138 schoenebeck 649 }
1139     ++iuiSelectedKey; // get next key on current engine channel
1140     }
1141     // get next engine channel
1142 schoenebeck 460 iChannelIndex = (iChannelIndex + 1) % engineChannels.size();
1143 schoenebeck 649 pSelectedChannel = engineChannels[iChannelIndex];
1144 schoenebeck 663
1145     #if CONFIG_DEVMODE
1146     if (pSelectedChannel == pBegin) {
1147     dmsg(1,("FATAL ERROR: voice stealing endless loop!\n"));
1148     dmsg(1,("VoiceSpawnsLeft=%d.\n", VoiceSpawnsLeft));
1149     dmsg(1,("Exiting.\n"));
1150     exit(-1);
1151     }
1152     #endif // CONFIG_DEVMODE
1153 schoenebeck 460 }
1154     }
1155    
1156 schoenebeck 665 // jump point if a 'stealable' voice was found
1157     stealable_voice_found:
1158    
1159 schoenebeck 563 #if CONFIG_DEVMODE
1160 schoenebeck 473 if (!itSelectedVoice->IsActive()) {
1161     dmsg(1,("gig::Engine: ERROR, tried to steal a voice which was not active !!!\n"));
1162     return -1;
1163     }
1164 schoenebeck 563 #endif // CONFIG_DEVMODE
1165 schoenebeck 287
1166 schoenebeck 250 // now kill the selected voice
1167 schoenebeck 659 itSelectedVoice->Kill(itNoteOnEvent);
1168 schoenebeck 460
1169 schoenebeck 663 --VoiceSpawnsLeft;
1170 schoenebeck 473
1171     return 0; // success
1172 schoenebeck 250 }
1173 schoenebeck 473 else {
1174     dmsg(1,("Event pool emtpy!\n"));
1175     return -1;
1176     }
1177 schoenebeck 250 }
1178    
1179     /**
1180 schoenebeck 285 * Removes the given voice from the MIDI key's list of active voices.
1181     * This method will be called when a voice went inactive, e.g. because
1182     * it finished to playback its sample, finished its release stage or
1183     * just was killed.
1184 schoenebeck 53 *
1185 schoenebeck 411 * @param pEngineChannel - engine channel on which this event occured on
1186 schoenebeck 285 * @param itVoice - points to the voice to be freed
1187 schoenebeck 53 */
1188 schoenebeck 411 void Engine::FreeVoice(EngineChannel* pEngineChannel, Pool<Voice>::Iterator& itVoice) {
1189 schoenebeck 271 if (itVoice) {
1190 schoenebeck 411 midi_key_info_t* pKey = &pEngineChannel->pMIDIKeyInfo[itVoice->MIDIKey];
1191 schoenebeck 53
1192 schoenebeck 271 uint keygroup = itVoice->KeyGroup;
1193    
1194 schoenebeck 53 // free the voice object
1195 schoenebeck 271 pVoicePool->free(itVoice);
1196 schoenebeck 53
1197 schoenebeck 287 // if no other voices left and member of a key group, remove from key group
1198     if (pKey->pActiveVoices->isEmpty() && keygroup) {
1199 schoenebeck 411 uint** ppKeyGroup = &pEngineChannel->ActiveKeyGroups[keygroup];
1200 schoenebeck 287 if (*ppKeyGroup == &*pKey->itSelf) *ppKeyGroup = NULL; // remove key from key group
1201 schoenebeck 53 }
1202     }
1203 schoenebeck 285 else std::cerr << "Couldn't release voice! (!itVoice)\n" << std::flush;
1204 schoenebeck 53 }
1205    
1206     /**
1207 schoenebeck 287 * Called when there's no more voice left on a key, this call will
1208     * update the key info respectively.
1209     *
1210 schoenebeck 411 * @param pEngineChannel - engine channel on which this event occured on
1211 schoenebeck 287 * @param pKey - key which is now inactive
1212     */
1213 schoenebeck 411 void Engine::FreeKey(EngineChannel* pEngineChannel, midi_key_info_t* pKey) {
1214 schoenebeck 287 if (pKey->pActiveVoices->isEmpty()) {
1215     pKey->Active = false;
1216 schoenebeck 411 pEngineChannel->pActiveKeys->free(pKey->itSelf); // remove key from list of active keys
1217 schoenebeck 287 pKey->itSelf = RTList<uint>::Iterator();
1218     pKey->ReleaseTrigger = false;
1219     pKey->pEvents->clear();
1220     dmsg(3,("Key has no more voices now\n"));
1221     }
1222     else dmsg(1,("gig::Engine: Oops, tried to free a key which contains voices.\n"));
1223     }
1224    
1225     /**
1226 schoenebeck 53 * Reacts on supported control change commands (e.g. pitch bend wheel,
1227     * modulation wheel, aftertouch).
1228     *
1229 schoenebeck 411 * @param pEngineChannel - engine channel on which this event occured on
1230 schoenebeck 271 * @param itControlChangeEvent - controller, value and time stamp of the event
1231 schoenebeck 53 */
1232 schoenebeck 411 void Engine::ProcessControlChange(EngineChannel* pEngineChannel, Pool<Event>::Iterator& itControlChangeEvent) {
1233 schoenebeck 271 dmsg(4,("Engine::ContinuousController cc=%d v=%d\n", itControlChangeEvent->Param.CC.Controller, itControlChangeEvent->Param.CC.Value));
1234 schoenebeck 53
1235 schoenebeck 473 // update controller value in the engine channel's controller table
1236     pEngineChannel->ControllerTable[itControlChangeEvent->Param.CC.Controller] = itControlChangeEvent->Param.CC.Value;
1237    
1238 schoenebeck 769 switch (itControlChangeEvent->Param.CC.Controller) {
1239 schoenebeck 829 case 5: { // portamento time
1240     pEngineChannel->PortamentoTime = (float) itControlChangeEvent->Param.CC.Value / 127.0f * (float) CONFIG_PORTAMENTO_TIME_MAX + (float) CONFIG_PORTAMENTO_TIME_MIN;
1241     break;
1242     }
1243 schoenebeck 424 case 7: { // volume
1244     //TODO: not sample accurate yet
1245 persson 831 pEngineChannel->GlobalVolume = VolumeCurve[itControlChangeEvent->Param.CC.Value] * CONFIG_GLOBAL_ATTENUATION;
1246 schoenebeck 660 pEngineChannel->bStatusChanged = true; // engine channel status has changed, so set notify flag
1247 schoenebeck 424 break;
1248     }
1249     case 10: { // panpot
1250     //TODO: not sample accurate yet
1251 persson 831 pEngineChannel->GlobalPanLeft = PanCurve[128 - itControlChangeEvent->Param.CC.Value];
1252     pEngineChannel->GlobalPanRight = PanCurve[itControlChangeEvent->Param.CC.Value];
1253 schoenebeck 424 break;
1254     }
1255     case 64: { // sustain
1256 schoenebeck 769 if (itControlChangeEvent->Param.CC.Value >= 64 && !pEngineChannel->SustainPedal) {
1257 iliev 776 dmsg(4,("DAMPER (RIGHT) PEDAL DOWN\n"));
1258 schoenebeck 411 pEngineChannel->SustainPedal = true;
1259 schoenebeck 53
1260 iliev 716 #if !CONFIG_PROCESS_MUTED_CHANNELS
1261 schoenebeck 705 if (pEngineChannel->GetMute()) return; // skip if sampler channel is muted
1262 iliev 716 #endif
1263 schoenebeck 705
1264 schoenebeck 53 // cancel release process of voices if necessary
1265 schoenebeck 411 RTList<uint>::Iterator iuiKey = pEngineChannel->pActiveKeys->first();
1266 schoenebeck 473 for (; iuiKey; ++iuiKey) {
1267     midi_key_info_t* pKey = &pEngineChannel->pMIDIKeyInfo[*iuiKey];
1268     if (!pKey->KeyPressed) {
1269     RTList<Event>::Iterator itNewEvent = pKey->pEvents->allocAppend();
1270     if (itNewEvent) {
1271 schoenebeck 769 *itNewEvent = *itControlChangeEvent; // copy event to the key's own event list
1272 schoenebeck 473 itNewEvent->Type = Event::type_cancel_release; // transform event type
1273 schoenebeck 53 }
1274 schoenebeck 473 else dmsg(1,("Event pool emtpy!\n"));
1275 schoenebeck 53 }
1276     }
1277     }
1278 schoenebeck 769 if (itControlChangeEvent->Param.CC.Value < 64 && pEngineChannel->SustainPedal) {
1279 iliev 776 dmsg(4,("DAMPER (RIGHT) PEDAL UP\n"));
1280 schoenebeck 411 pEngineChannel->SustainPedal = false;
1281 schoenebeck 53
1282 iliev 716 #if !CONFIG_PROCESS_MUTED_CHANNELS
1283 schoenebeck 705 if (pEngineChannel->GetMute()) return; // skip if sampler channel is muted
1284 iliev 716 #endif
1285 schoenebeck 705
1286 schoenebeck 53 // release voices if their respective key is not pressed
1287 schoenebeck 411 RTList<uint>::Iterator iuiKey = pEngineChannel->pActiveKeys->first();
1288 schoenebeck 473 for (; iuiKey; ++iuiKey) {
1289     midi_key_info_t* pKey = &pEngineChannel->pMIDIKeyInfo[*iuiKey];
1290 iliev 776 if (!pKey->KeyPressed && ShouldReleaseVoice(pEngineChannel, *iuiKey)) {
1291 schoenebeck 473 RTList<Event>::Iterator itNewEvent = pKey->pEvents->allocAppend();
1292     if (itNewEvent) {
1293 schoenebeck 769 *itNewEvent = *itControlChangeEvent; // copy event to the key's own event list
1294 schoenebeck 473 itNewEvent->Type = Event::type_release; // transform event type
1295 schoenebeck 53 }
1296 schoenebeck 473 else dmsg(1,("Event pool emtpy!\n"));
1297 schoenebeck 53 }
1298     }
1299     }
1300     break;
1301     }
1302 schoenebeck 829 case 65: { // portamento on / off
1303     KillAllVoices(pEngineChannel, itControlChangeEvent);
1304     pEngineChannel->PortamentoMode = itControlChangeEvent->Param.CC.Value >= 64;
1305     break;
1306     }
1307 iliev 776 case 66: { // sostenuto
1308     if (itControlChangeEvent->Param.CC.Value >= 64 && !pEngineChannel->SostenutoPedal) {
1309     dmsg(4,("SOSTENUTO (CENTER) PEDAL DOWN\n"));
1310     pEngineChannel->SostenutoPedal = true;
1311 schoenebeck 53
1312 iliev 776 #if !CONFIG_PROCESS_MUTED_CHANNELS
1313     if (pEngineChannel->GetMute()) return; // skip if sampler channel is muted
1314     #endif
1315 schoenebeck 53
1316 iliev 776 SostenutoKeyCount = 0;
1317     // Remeber the pressed keys
1318     RTList<uint>::Iterator iuiKey = pEngineChannel->pActiveKeys->first();
1319     for (; iuiKey; ++iuiKey) {
1320     midi_key_info_t* pKey = &pEngineChannel->pMIDIKeyInfo[*iuiKey];
1321     if (pKey->KeyPressed && SostenutoKeyCount < 128) SostenutoKeys[SostenutoKeyCount++] = *iuiKey;
1322     }
1323     }
1324     if (itControlChangeEvent->Param.CC.Value < 64 && pEngineChannel->SostenutoPedal) {
1325     dmsg(4,("SOSTENUTO (CENTER) PEDAL UP\n"));
1326     pEngineChannel->SostenutoPedal = false;
1327    
1328     #if !CONFIG_PROCESS_MUTED_CHANNELS
1329     if (pEngineChannel->GetMute()) return; // skip if sampler channel is muted
1330     #endif
1331    
1332     // release voices if the damper pedal is up and their respective key is not pressed
1333     for (int i = 0; i < SostenutoKeyCount; i++) {
1334     midi_key_info_t* pKey = &pEngineChannel->pMIDIKeyInfo[SostenutoKeys[i]];
1335     if (!pKey->KeyPressed && !pEngineChannel->SustainPedal) {
1336     RTList<Event>::Iterator itNewEvent = pKey->pEvents->allocAppend();
1337     if (itNewEvent) {
1338     *itNewEvent = *itControlChangeEvent; // copy event to the key's own event list
1339     itNewEvent->Type = Event::type_release; // transform event type
1340     }
1341     else dmsg(1,("Event pool emtpy!\n"));
1342     }
1343     }
1344     }
1345     break;
1346     }
1347    
1348    
1349 schoenebeck 473 // Channel Mode Messages
1350    
1351     case 120: { // all sound off
1352 schoenebeck 769 KillAllVoices(pEngineChannel, itControlChangeEvent);
1353 schoenebeck 473 break;
1354     }
1355     case 121: { // reset all controllers
1356     pEngineChannel->ResetControllers();
1357     break;
1358     }
1359     case 123: { // all notes off
1360 schoenebeck 849 #if CONFIG_PROCESS_ALL_NOTES_OFF
1361 schoenebeck 769 ReleaseAllVoices(pEngineChannel, itControlChangeEvent);
1362 schoenebeck 849 #endif // CONFIG_PROCESS_ALL_NOTES_OFF
1363 schoenebeck 473 break;
1364     }
1365 schoenebeck 829 case 126: { // mono mode on
1366     KillAllVoices(pEngineChannel, itControlChangeEvent);
1367     pEngineChannel->SoloMode = true;
1368     break;
1369     }
1370     case 127: { // poly mode on
1371     KillAllVoices(pEngineChannel, itControlChangeEvent);
1372     pEngineChannel->SoloMode = false;
1373     break;
1374     }
1375 schoenebeck 473 }
1376 schoenebeck 53 }
1377    
1378     /**
1379 schoenebeck 244 * Reacts on MIDI system exclusive messages.
1380     *
1381 schoenebeck 271 * @param itSysexEvent - sysex data size and time stamp of the sysex event
1382 schoenebeck 244 */
1383 schoenebeck 271 void Engine::ProcessSysex(Pool<Event>::Iterator& itSysexEvent) {
1384 schoenebeck 244 RingBuffer<uint8_t>::NonVolatileReader reader = pSysexBuffer->get_non_volatile_reader();
1385    
1386     uint8_t exclusive_status, id;
1387     if (!reader.pop(&exclusive_status)) goto free_sysex_data;
1388     if (!reader.pop(&id)) goto free_sysex_data;
1389     if (exclusive_status != 0xF0) goto free_sysex_data;
1390    
1391     switch (id) {
1392     case 0x41: { // Roland
1393 schoenebeck 493 dmsg(3,("Roland Sysex\n"));
1394 schoenebeck 244 uint8_t device_id, model_id, cmd_id;
1395     if (!reader.pop(&device_id)) goto free_sysex_data;
1396     if (!reader.pop(&model_id)) goto free_sysex_data;
1397     if (!reader.pop(&cmd_id)) goto free_sysex_data;
1398     if (model_id != 0x42 /*GS*/) goto free_sysex_data;
1399     if (cmd_id != 0x12 /*DT1*/) goto free_sysex_data;
1400    
1401     // command address
1402     uint8_t addr[3]; // 2 byte addr MSB, followed by 1 byte addr LSB)
1403     const RingBuffer<uint8_t>::NonVolatileReader checksum_reader = reader; // so we can calculate the check sum later
1404     if (reader.read(&addr[0], 3) != 3) goto free_sysex_data;
1405     if (addr[0] == 0x40 && addr[1] == 0x00) { // System Parameters
1406 schoenebeck 493 dmsg(3,("\tSystem Parameter\n"));
1407 schoenebeck 244 }
1408     else if (addr[0] == 0x40 && addr[1] == 0x01) { // Common Parameters
1409 schoenebeck 493 dmsg(3,("\tCommon Parameter\n"));
1410 schoenebeck 244 }
1411     else if (addr[0] == 0x40 && (addr[1] & 0xf0) == 0x10) { // Part Parameters (1)
1412 schoenebeck 493 dmsg(3,("\tPart Parameter\n"));
1413     switch (addr[2]) {
1414 schoenebeck 244 case 0x40: { // scale tuning
1415 schoenebeck 493 dmsg(3,("\t\tScale Tuning\n"));
1416 schoenebeck 244 uint8_t scale_tunes[12]; // detuning of all 12 semitones of an octave
1417     if (reader.read(&scale_tunes[0], 12) != 12) goto free_sysex_data;
1418     uint8_t checksum;
1419 schoenebeck 493 if (!reader.pop(&checksum)) goto free_sysex_data;
1420 schoenebeck 563 #if CONFIG_ASSERT_GS_SYSEX_CHECKSUM
1421     if (GSCheckSum(checksum_reader, 12)) goto free_sysex_data;
1422     #endif // CONFIG_ASSERT_GS_SYSEX_CHECKSUM
1423 schoenebeck 244 for (int i = 0; i < 12; i++) scale_tunes[i] -= 64;
1424     AdjustScale((int8_t*) scale_tunes);
1425 schoenebeck 493 dmsg(3,("\t\t\tNew scale applied.\n"));
1426 schoenebeck 244 break;
1427     }
1428     }
1429     }
1430     else if (addr[0] == 0x40 && (addr[1] & 0xf0) == 0x20) { // Part Parameters (2)
1431     }
1432     else if (addr[0] == 0x41) { // Drum Setup Parameters
1433     }
1434     break;
1435     }
1436     }
1437    
1438     free_sysex_data: // finally free sysex data
1439 schoenebeck 271 pSysexBuffer->increment_read_ptr(itSysexEvent->Param.Sysex.Size);
1440 schoenebeck 244 }
1441    
1442     /**
1443     * Calculates the Roland GS sysex check sum.
1444     *
1445     * @param AddrReader - reader which currently points to the first GS
1446     * command address byte of the GS sysex message in
1447     * question
1448     * @param DataSize - size of the GS message data (in bytes)
1449     */
1450     uint8_t Engine::GSCheckSum(const RingBuffer<uint8_t>::NonVolatileReader AddrReader, uint DataSize) {
1451     RingBuffer<uint8_t>::NonVolatileReader reader = AddrReader;
1452     uint bytes = 3 /*addr*/ + DataSize;
1453     uint8_t addr_and_data[bytes];
1454     reader.read(&addr_and_data[0], bytes);
1455     uint8_t sum = 0;
1456     for (uint i = 0; i < bytes; i++) sum += addr_and_data[i];
1457     return 128 - sum % 128;
1458     }
1459    
1460     /**
1461     * Allows to tune each of the twelve semitones of an octave.
1462     *
1463     * @param ScaleTunes - detuning of all twelve semitones (in cents)
1464     */
1465     void Engine::AdjustScale(int8_t ScaleTunes[12]) {
1466     memcpy(&this->ScaleTuning[0], &ScaleTunes[0], 12); //TODO: currently not sample accurate
1467     }
1468    
1469     /**
1470 schoenebeck 473 * Releases all voices on an engine channel. All voices will go into
1471     * the release stage and thus it might take some time (e.g. dependant to
1472     * their envelope release time) until they actually die.
1473     *
1474     * @param pEngineChannel - engine channel on which all voices should be released
1475     * @param itReleaseEvent - event which caused this releasing of all voices
1476     */
1477     void Engine::ReleaseAllVoices(EngineChannel* pEngineChannel, Pool<Event>::Iterator& itReleaseEvent) {
1478     RTList<uint>::Iterator iuiKey = pEngineChannel->pActiveKeys->first();
1479     while (iuiKey) {
1480     midi_key_info_t* pKey = &pEngineChannel->pMIDIKeyInfo[*iuiKey];
1481     ++iuiKey;
1482     // append a 'release' event to the key's own event list
1483     RTList<Event>::Iterator itNewEvent = pKey->pEvents->allocAppend();
1484     if (itNewEvent) {
1485     *itNewEvent = *itReleaseEvent; // copy original event (to the key's event list)
1486     itNewEvent->Type = Event::type_release; // transform event type
1487     }
1488     else dmsg(1,("Event pool emtpy!\n"));
1489     }
1490     }
1491    
1492     /**
1493     * Kills all voices on an engine channel as soon as possible. Voices
1494     * won't get into release state, their volume level will be ramped down
1495     * as fast as possible.
1496     *
1497     * @param pEngineChannel - engine channel on which all voices should be killed
1498     * @param itKillEvent - event which caused this killing of all voices
1499     */
1500     void Engine::KillAllVoices(EngineChannel* pEngineChannel, Pool<Event>::Iterator& itKillEvent) {
1501     RTList<uint>::Iterator iuiKey = pEngineChannel->pActiveKeys->first();
1502     RTList<uint>::Iterator end = pEngineChannel->pActiveKeys->end();
1503     while (iuiKey != end) { // iterate through all active keys
1504     midi_key_info_t* pKey = &pEngineChannel->pMIDIKeyInfo[*iuiKey];
1505     ++iuiKey;
1506     RTList<Voice>::Iterator itVoice = pKey->pActiveVoices->first();
1507     RTList<Voice>::Iterator itVoicesEnd = pKey->pActiveVoices->end();
1508     for (; itVoice != itVoicesEnd; ++itVoice) { // iterate through all voices on this key
1509     itVoice->Kill(itKillEvent);
1510 schoenebeck 663 --VoiceSpawnsLeft; //FIXME: just a temporary workaround, we should check the cause in StealVoice() instead
1511 schoenebeck 473 }
1512     }
1513     }
1514    
1515 iliev 776 /**
1516     * Determines whether the specified voice should be released.
1517     *
1518     * @param pEngineChannel - The engine channel on which the voice should be checked
1519     * @param Key - The key number
1520     * @returns true if the specified should be released, false otherwise.
1521     */
1522     bool Engine::ShouldReleaseVoice(EngineChannel* pEngineChannel, int Key) {
1523     if (pEngineChannel->SustainPedal) return false;
1524    
1525     if (pEngineChannel->SostenutoPedal) {
1526     for (int i = 0; i < SostenutoKeyCount; i++)
1527     if (Key == SostenutoKeys[i]) return false;
1528     }
1529    
1530     return true;
1531     }
1532    
1533 schoenebeck 53 uint Engine::VoiceCount() {
1534     return ActiveVoiceCount;
1535     }
1536    
1537     uint Engine::VoiceCountMax() {
1538     return ActiveVoiceCountMax;
1539     }
1540    
1541     bool Engine::DiskStreamSupported() {
1542     return true;
1543     }
1544    
1545     uint Engine::DiskStreamCount() {
1546     return (pDiskThread) ? pDiskThread->ActiveStreamCount : 0;
1547     }
1548    
1549     uint Engine::DiskStreamCountMax() {
1550     return (pDiskThread) ? pDiskThread->ActiveStreamCountMax : 0;
1551     }
1552    
1553     String Engine::DiskStreamBufferFillBytes() {
1554     return pDiskThread->GetBufferFillBytes();
1555     }
1556    
1557     String Engine::DiskStreamBufferFillPercentage() {
1558     return pDiskThread->GetBufferFillPercentage();
1559     }
1560    
1561 senkov 112 String Engine::EngineName() {
1562 schoenebeck 475 return LS_GIG_ENGINE_NAME;
1563 senkov 112 }
1564    
1565 schoenebeck 53 String Engine::Description() {
1566     return "Gigasampler Engine";
1567     }
1568    
1569     String Engine::Version() {
1570 schoenebeck 849 String s = "$Revision: 1.61 $";
1571 schoenebeck 123 return s.substr(11, s.size() - 13); // cut dollar signs, spaces and CVS macro keyword
1572 schoenebeck 53 }
1573    
1574 persson 831 // static constant initializers
1575     const float* Engine::VolumeCurve(InitVolumeCurve());
1576     const float* Engine::PanCurve(InitPanCurve());
1577 persson 832 const float* Engine::CrossfadeCurve(InitCrossfadeCurve());
1578 persson 831
1579     float* Engine::InitVolumeCurve() {
1580     // line-segment approximation
1581     const float segments[] = {
1582     0, 0, 2, 0.0046, 16, 0.016, 31, 0.051, 45, 0.115, 54.5, 0.2,
1583     64.5, 0.39, 74, 0.74, 92, 1.03, 114, 1.94, 119.2, 2.2, 127, 2.2
1584     };
1585     return InitCurve(segments);
1586     }
1587    
1588     float* Engine::InitPanCurve() {
1589     // line-segment approximation
1590     const float segments[] = {
1591     0, 0, 1, 0,
1592     2, 0.05, 31.5, 0.7, 51, 0.851, 74.5, 1.12,
1593     127, 1.41, 128, 1.41
1594     };
1595     return InitCurve(segments, 129);
1596     }
1597    
1598 persson 832 float* Engine::InitCrossfadeCurve() {
1599     // line-segment approximation
1600     const float segments[] = {
1601     0, 0, 1, 0.03, 10, 0.1, 51, 0.58, 127, 1
1602     };
1603     return InitCurve(segments);
1604     }
1605    
1606 persson 831 float* Engine::InitCurve(const float* segments, int size) {
1607     float* y = new float[size];
1608     for (int x = 0 ; x < size ; x++) {
1609     if (x > segments[2]) segments += 2;
1610     y[x] = segments[1] + (x - segments[0]) *
1611     (segments[3] - segments[1]) / (segments[2] - segments[0]);
1612     }
1613     return y;
1614     }
1615    
1616 schoenebeck 53 }} // namespace LinuxSampler::gig

  ViewVC Help
Powered by ViewVC