/[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 287 - (hide annotations) (download)
Sat Oct 16 17:38:03 2004 UTC (15 years, 4 months ago) by schoenebeck
File size: 49384 byte(s)
* fixed segfault which occured whenever a voice stole a voice and was in
  turn killed in the same audio fragment, to fix that the MIDI key
  informations are now updated only after all voices were processed

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 53 * *
7     * This program is free software; you can redistribute it and/or modify *
8     * it under the terms of the GNU General Public License as published by *
9     * the Free Software Foundation; either version 2 of the License, or *
10     * (at your option) any later version. *
11     * *
12     * This program is distributed in the hope that it will be useful, *
13     * but WITHOUT ANY WARRANTY; without even the implied warranty of *
14     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
15     * GNU General Public License for more details. *
16     * *
17     * You should have received a copy of the GNU General Public License *
18     * along with this program; if not, write to the Free Software *
19     * Foundation, Inc., 59 Temple Place, Suite 330, Boston, *
20     * MA 02111-1307 USA *
21     ***************************************************************************/
22    
23     #include <sstream>
24     #include "DiskThread.h"
25     #include "Voice.h"
26 schoenebeck 285 #include "EGADSR.h"
27 schoenebeck 53
28     #include "Engine.h"
29    
30     namespace LinuxSampler { namespace gig {
31    
32     InstrumentResourceManager Engine::Instruments;
33    
34     Engine::Engine() {
35     pRIFF = NULL;
36     pGig = NULL;
37     pInstrument = NULL;
38     pAudioOutputDevice = NULL;
39     pDiskThread = NULL;
40     pEventGenerator = NULL;
41 schoenebeck 244 pSysexBuffer = new RingBuffer<uint8_t>(SYSEX_BUFFER_SIZE, 0);
42     pEventQueue = new RingBuffer<Event>(MAX_EVENTS_PER_FRAGMENT, 0);
43 schoenebeck 271 pEventPool = new Pool<Event>(MAX_EVENTS_PER_FRAGMENT);
44     pVoicePool = new Pool<Voice>(MAX_AUDIO_VOICES);
45     pActiveKeys = new Pool<uint>(128);
46     pVoiceStealingQueue = new RTList<Event>(pEventPool);
47     pEvents = new RTList<Event>(pEventPool);
48     pCCEvents = new RTList<Event>(pEventPool);
49 schoenebeck 53 for (uint i = 0; i < Event::destination_count; i++) {
50 schoenebeck 271 pSynthesisEvents[i] = new RTList<Event>(pEventPool);
51 schoenebeck 53 }
52     for (uint i = 0; i < 128; i++) {
53 schoenebeck 271 pMIDIKeyInfo[i].pActiveVoices = new RTList<Voice>(pVoicePool);
54 schoenebeck 242 pMIDIKeyInfo[i].KeyPressed = false;
55     pMIDIKeyInfo[i].Active = false;
56     pMIDIKeyInfo[i].ReleaseTrigger = false;
57 schoenebeck 271 pMIDIKeyInfo[i].pEvents = new RTList<Event>(pEventPool);
58 schoenebeck 53 }
59 schoenebeck 271 for (RTList<Voice>::Iterator iterVoice = pVoicePool->allocAppend(); iterVoice == pVoicePool->last(); iterVoice = pVoicePool->allocAppend()) {
60     iterVoice->SetEngine(this);
61 schoenebeck 53 }
62     pVoicePool->clear();
63    
64     pSynthesisParameters[0] = NULL; // we allocate when an audio device is connected
65 schoenebeck 80 pBasicFilterParameters = NULL;
66     pMainFilterParameters = NULL;
67 schoenebeck 123
68 senkov 112 InstrumentIdx = -1;
69 capela 133 InstrumentStat = -1;
70 schoenebeck 53
71 schoenebeck 225 AudioDeviceChannelLeft = -1;
72     AudioDeviceChannelRight = -1;
73    
74 schoenebeck 53 ResetInternal();
75     }
76    
77     Engine::~Engine() {
78     if (pDiskThread) {
79     pDiskThread->StopThread();
80     delete pDiskThread;
81     }
82     if (pGig) delete pGig;
83     if (pRIFF) delete pRIFF;
84     for (uint i = 0; i < 128; i++) {
85     if (pMIDIKeyInfo[i].pActiveVoices) delete pMIDIKeyInfo[i].pActiveVoices;
86     if (pMIDIKeyInfo[i].pEvents) delete pMIDIKeyInfo[i].pEvents;
87     }
88     for (uint i = 0; i < Event::destination_count; i++) {
89     if (pSynthesisEvents[i]) delete pSynthesisEvents[i];
90     }
91     delete[] pSynthesisEvents;
92     if (pEvents) delete pEvents;
93     if (pCCEvents) delete pCCEvents;
94     if (pEventQueue) delete pEventQueue;
95     if (pEventPool) delete pEventPool;
96     if (pVoicePool) delete pVoicePool;
97     if (pActiveKeys) delete pActiveKeys;
98 schoenebeck 244 if (pSysexBuffer) delete pSysexBuffer;
99 schoenebeck 53 if (pEventGenerator) delete pEventGenerator;
100 schoenebeck 80 if (pMainFilterParameters) delete[] pMainFilterParameters;
101     if (pBasicFilterParameters) delete[] pBasicFilterParameters;
102 schoenebeck 53 if (pSynthesisParameters[0]) delete[] pSynthesisParameters[0];
103 schoenebeck 250 if (pVoiceStealingQueue) delete pVoiceStealingQueue;
104 schoenebeck 53 }
105    
106     void Engine::Enable() {
107     dmsg(3,("gig::Engine: enabling\n"));
108     EngineDisabled.PushAndUnlock(false, 2); // set condition object 'EngineDisabled' to false (wait max. 2s)
109 schoenebeck 64 dmsg(3,("gig::Engine: enabled (val=%d)\n", EngineDisabled.GetUnsafe()));
110 schoenebeck 53 }
111    
112     void Engine::Disable() {
113     dmsg(3,("gig::Engine: disabling\n"));
114     bool* pWasDisabled = EngineDisabled.PushAndUnlock(true, 2); // wait max. 2s
115     if (!pWasDisabled) dmsg(3,("gig::Engine warning: Timeout waiting to disable engine.\n"));
116     }
117    
118     void Engine::DisableAndLock() {
119     dmsg(3,("gig::Engine: disabling\n"));
120     bool* pWasDisabled = EngineDisabled.Push(true, 2); // wait max. 2s
121     if (!pWasDisabled) dmsg(3,("gig::Engine warning: Timeout waiting to disable engine.\n"));
122     }
123    
124     /**
125     * Reset all voices and disk thread and clear input event queue and all
126     * control and status variables.
127     */
128     void Engine::Reset() {
129     DisableAndLock();
130    
131     //if (pAudioOutputDevice->IsPlaying()) { // if already running
132     /*
133     // signal audio thread not to enter render part anymore
134     SuspensionRequested = true;
135     // sleep until wakened by audio thread
136     pthread_mutex_lock(&__render_state_mutex);
137     pthread_cond_wait(&__render_exit_condition, &__render_state_mutex);
138     pthread_mutex_unlock(&__render_state_mutex);
139     */
140     //}
141    
142     //if (wasplaying) pAudioOutputDevice->Stop();
143    
144     ResetInternal();
145    
146     // signal audio thread to continue with rendering
147     //SuspensionRequested = false;
148     Enable();
149     }
150    
151     /**
152     * Reset all voices and disk thread and clear input event queue and all
153     * control and status variables. This method is not thread safe!
154     */
155     void Engine::ResetInternal() {
156     Pitch = 0;
157     SustainPedal = false;
158     ActiveVoiceCount = 0;
159     ActiveVoiceCountMax = 0;
160 schoenebeck 225 GlobalVolume = 1.0;
161 schoenebeck 53
162 schoenebeck 250 // reset voice stealing parameters
163 schoenebeck 271 itLastStolenVoice = RTList<Voice>::Iterator();
164     iuiLastStolenKey = RTList<uint>::Iterator();
165 schoenebeck 250 pVoiceStealingQueue->clear();
166    
167 schoenebeck 244 // reset to normal chromatic scale (means equal temper)
168     memset(&ScaleTuning[0], 0x00, 12);
169    
170 schoenebeck 53 // set all MIDI controller values to zero
171     memset(ControllerTable, 0x00, 128);
172    
173     // reset key info
174     for (uint i = 0; i < 128; i++) {
175     pMIDIKeyInfo[i].pActiveVoices->clear();
176     pMIDIKeyInfo[i].pEvents->clear();
177 schoenebeck 242 pMIDIKeyInfo[i].KeyPressed = false;
178     pMIDIKeyInfo[i].Active = false;
179     pMIDIKeyInfo[i].ReleaseTrigger = false;
180 schoenebeck 271 pMIDIKeyInfo[i].itSelf = Pool<uint>::Iterator();
181 schoenebeck 53 }
182    
183 schoenebeck 239 // reset all key groups
184     map<uint,uint*>::iterator iter = ActiveKeyGroups.begin();
185     for (; iter != ActiveKeyGroups.end(); iter++) iter->second = NULL;
186    
187 schoenebeck 53 // reset all voices
188 schoenebeck 271 for (RTList<Voice>::Iterator iterVoice = pVoicePool->allocAppend(); iterVoice == pVoicePool->last(); iterVoice = pVoicePool->allocAppend()) {
189     iterVoice->Reset();
190 schoenebeck 53 }
191     pVoicePool->clear();
192    
193     // free all active keys
194     pActiveKeys->clear();
195    
196     // reset disk thread
197     if (pDiskThread) pDiskThread->Reset();
198    
199     // delete all input events
200     pEventQueue->init();
201     }
202    
203     /**
204     * Load an instrument from a .gig file.
205     *
206     * @param FileName - file name of the Gigasampler instrument file
207     * @param Instrument - index of the instrument in the .gig file
208     * @throws LinuxSamplerException on error
209     * @returns detailed description of the method call result
210     */
211     void Engine::LoadInstrument(const char* FileName, uint Instrument) {
212    
213     DisableAndLock();
214    
215     ResetInternal(); // reset engine
216    
217     // free old instrument
218     if (pInstrument) {
219     // give old instrument back to instrument manager
220     Instruments.HandBack(pInstrument, this);
221     }
222    
223 capela 133 InstrumentFile = FileName;
224     InstrumentIdx = Instrument;
225     InstrumentStat = 0;
226 senkov 112
227 schoenebeck 239 // delete all key groups
228     ActiveKeyGroups.clear();
229    
230 schoenebeck 53 // request gig instrument from instrument manager
231     try {
232     instrument_id_t instrid;
233     instrid.FileName = FileName;
234     instrid.iInstrument = Instrument;
235     pInstrument = Instruments.Borrow(instrid, this);
236     if (!pInstrument) {
237 capela 133 InstrumentStat = -1;
238 schoenebeck 53 dmsg(1,("no instrument loaded!!!\n"));
239     exit(EXIT_FAILURE);
240     }
241     }
242     catch (RIFF::Exception e) {
243 capela 133 InstrumentStat = -2;
244 schoenebeck 53 String msg = "gig::Engine error: Failed to load instrument, cause: " + e.Message;
245     throw LinuxSamplerException(msg);
246     }
247     catch (InstrumentResourceManagerException e) {
248 capela 133 InstrumentStat = -3;
249 schoenebeck 53 String msg = "gig::Engine error: Failed to load instrument, cause: " + e.Message();
250     throw LinuxSamplerException(msg);
251     }
252     catch (...) {
253 capela 133 InstrumentStat = -4;
254 schoenebeck 53 throw LinuxSamplerException("gig::Engine error: Failed to load instrument, cause: Unknown exception while trying to parse gig file.");
255     }
256    
257 schoenebeck 239 // rebuild ActiveKeyGroups map with key groups of current instrument
258     for (::gig::Region* pRegion = pInstrument->GetFirstRegion(); pRegion; pRegion = pInstrument->GetNextRegion())
259     if (pRegion->KeyGroup) ActiveKeyGroups[pRegion->KeyGroup] = NULL;
260    
261 capela 133 InstrumentStat = 100;
262 senkov 112
263 schoenebeck 53 // inform audio driver for the need of two channels
264     try {
265     if (pAudioOutputDevice) pAudioOutputDevice->AcquireChannels(2); // gig Engine only stereo
266     }
267     catch (AudioOutputException e) {
268     String msg = "Audio output device unable to provide 2 audio channels, cause: " + e.Message();
269     throw LinuxSamplerException(msg);
270     }
271    
272     Enable();
273     }
274    
275     /**
276     * Will be called by the InstrumentResourceManager when the instrument
277     * we are currently using in this engine is going to be updated, so we
278     * can stop playback before that happens.
279     */
280     void Engine::ResourceToBeUpdated(::gig::Instrument* pResource, void*& pUpdateArg) {
281     dmsg(3,("gig::Engine: Received instrument update message.\n"));
282     DisableAndLock();
283     ResetInternal();
284     this->pInstrument = NULL;
285     }
286    
287     /**
288     * Will be called by the InstrumentResourceManager when the instrument
289     * update process was completed, so we can continue with playback.
290     */
291     void Engine::ResourceUpdated(::gig::Instrument* pOldResource, ::gig::Instrument* pNewResource, void* pUpdateArg) {
292 schoenebeck 239 this->pInstrument = pNewResource; //TODO: there are couple of engine parameters we should update here as well if the instrument was updated (see LoadInstrument())
293 schoenebeck 53 Enable();
294     }
295    
296     void Engine::Connect(AudioOutputDevice* pAudioOut) {
297     pAudioOutputDevice = pAudioOut;
298    
299     ResetInternal();
300    
301     // inform audio driver for the need of two channels
302     try {
303     pAudioOutputDevice->AcquireChannels(2); // gig engine only stereo
304     }
305     catch (AudioOutputException e) {
306     String msg = "Audio output device unable to provide 2 audio channels, cause: " + e.Message();
307     throw LinuxSamplerException(msg);
308     }
309    
310 schoenebeck 225 this->AudioDeviceChannelLeft = 0;
311     this->AudioDeviceChannelRight = 1;
312     this->pOutputLeft = pAudioOutputDevice->Channel(0)->Buffer();
313     this->pOutputRight = pAudioOutputDevice->Channel(1)->Buffer();
314     this->MaxSamplesPerCycle = pAudioOutputDevice->MaxSamplesPerCycle();
315     this->SampleRate = pAudioOutputDevice->SampleRate();
316    
317 schoenebeck 285 // FIXME: audio drivers with varying fragment sizes might be a problem here
318     MaxFadeOutPos = MaxSamplesPerCycle - int(double(SampleRate) * EG_MIN_RELEASE_TIME) - 1;
319     if (MaxFadeOutPos < 0)
320     throw LinuxSamplerException("EG_MIN_RELEASE_TIME in EGADSR.h to big for current audio fragment size / sampling rate!");
321    
322 schoenebeck 53 // (re)create disk thread
323     if (this->pDiskThread) {
324     this->pDiskThread->StopThread();
325     delete this->pDiskThread;
326     }
327     this->pDiskThread = new DiskThread(((pAudioOut->MaxSamplesPerCycle() << MAX_PITCH) << 1) + 6); //FIXME: assuming stereo
328     if (!pDiskThread) {
329     dmsg(0,("gig::Engine new diskthread = NULL\n"));
330     exit(EXIT_FAILURE);
331     }
332    
333 schoenebeck 271 for (RTList<Voice>::Iterator iterVoice = pVoicePool->allocAppend(); iterVoice == pVoicePool->last(); iterVoice = pVoicePool->allocAppend()) {
334     iterVoice->pDiskThread = this->pDiskThread;
335 schoenebeck 53 dmsg(3,("d"));
336     }
337     pVoicePool->clear();
338    
339     // (re)create event generator
340     if (pEventGenerator) delete pEventGenerator;
341     pEventGenerator = new EventGenerator(pAudioOut->SampleRate());
342    
343     // (re)allocate synthesis parameter matrix
344     if (pSynthesisParameters[0]) delete[] pSynthesisParameters[0];
345     pSynthesisParameters[0] = new float[Event::destination_count * pAudioOut->MaxSamplesPerCycle()];
346     for (int dst = 1; dst < Event::destination_count; dst++)
347     pSynthesisParameters[dst] = pSynthesisParameters[dst - 1] + pAudioOut->MaxSamplesPerCycle();
348    
349 schoenebeck 80 // (re)allocate biquad filter parameter sequence
350     if (pBasicFilterParameters) delete[] pBasicFilterParameters;
351     if (pMainFilterParameters) delete[] pMainFilterParameters;
352     pBasicFilterParameters = new biquad_param_t[pAudioOut->MaxSamplesPerCycle()];
353     pMainFilterParameters = new biquad_param_t[pAudioOut->MaxSamplesPerCycle()];
354    
355 schoenebeck 53 dmsg(1,("Starting disk thread..."));
356     pDiskThread->StartThread();
357     dmsg(1,("OK\n"));
358    
359 schoenebeck 271 for (RTList<Voice>::Iterator iterVoice = pVoicePool->allocAppend(); iterVoice == pVoicePool->last(); iterVoice = pVoicePool->allocAppend()) {
360     if (!iterVoice->pDiskThread) {
361 schoenebeck 53 dmsg(0,("Engine -> voice::trigger: !pDiskThread\n"));
362     exit(EXIT_FAILURE);
363     }
364     }
365     }
366    
367     void Engine::DisconnectAudioOutputDevice() {
368     if (pAudioOutputDevice) { // if clause to prevent disconnect loops
369     AudioOutputDevice* olddevice = pAudioOutputDevice;
370     pAudioOutputDevice = NULL;
371     olddevice->Disconnect(this);
372 schoenebeck 225 AudioDeviceChannelLeft = -1;
373     AudioDeviceChannelRight = -1;
374 schoenebeck 53 }
375     }
376    
377     /**
378     * Let this engine proceed to render the given amount of sample points. The
379     * calculated audio data of all voices of this engine will be placed into
380     * the engine's audio sum buffer which has to be copied and eventually be
381     * converted to the appropriate value range by the audio output class (e.g.
382     * AlsaIO or JackIO) right after.
383     *
384     * @param Samples - number of sample points to be rendered
385     * @returns 0 on success
386     */
387     int Engine::RenderAudio(uint Samples) {
388     dmsg(5,("RenderAudio(Samples=%d)\n", Samples));
389    
390     // return if no instrument loaded or engine disabled
391     if (EngineDisabled.Pop()) {
392     dmsg(5,("gig::Engine: engine disabled (val=%d)\n",EngineDisabled.GetUnsafe()));
393     return 0;
394     }
395     if (!pInstrument) {
396     dmsg(5,("gig::Engine: no instrument loaded\n"));
397     return 0;
398     }
399    
400    
401     // empty the event lists for the new fragment
402     pEvents->clear();
403     pCCEvents->clear();
404     for (uint i = 0; i < Event::destination_count; i++) {
405     pSynthesisEvents[i]->clear();
406     }
407 schoenebeck 271 {
408     RTList<uint>::Iterator iuiKey = pActiveKeys->first();
409     RTList<uint>::Iterator end = pActiveKeys->end();
410     for(; iuiKey != end; ++iuiKey) {
411     pMIDIKeyInfo[*iuiKey].pEvents->clear(); // free all events on the key
412     }
413 schoenebeck 250 }
414 schoenebeck 53
415     // read and copy events from input queue
416     Event event = pEventGenerator->CreateEvent();
417     while (true) {
418 schoenebeck 271 if (!pEventQueue->pop(&event) || pEvents->poolIsEmpty()) break;
419     *pEvents->allocAppend() = event;
420 schoenebeck 53 }
421    
422    
423     // update time of start and end of this audio fragment (as events' time stamps relate to this)
424     pEventGenerator->UpdateFragmentTime(Samples);
425    
426    
427     // process events
428 schoenebeck 271 {
429     RTList<Event>::Iterator itEvent = pEvents->first();
430     RTList<Event>::Iterator end = pEvents->end();
431     for (; itEvent != end; ++itEvent) {
432     switch (itEvent->Type) {
433     case Event::type_note_on:
434     dmsg(5,("Engine: Note on received\n"));
435     ProcessNoteOn(itEvent);
436     break;
437     case Event::type_note_off:
438     dmsg(5,("Engine: Note off received\n"));
439     ProcessNoteOff(itEvent);
440     break;
441     case Event::type_control_change:
442     dmsg(5,("Engine: MIDI CC received\n"));
443     ProcessControlChange(itEvent);
444     break;
445     case Event::type_pitchbend:
446     dmsg(5,("Engine: Pitchbend received\n"));
447     ProcessPitchbend(itEvent);
448     break;
449     case Event::type_sysex:
450     dmsg(5,("Engine: Sysex received\n"));
451     ProcessSysex(itEvent);
452     break;
453     }
454 schoenebeck 53 }
455     }
456    
457    
458     int active_voices = 0;
459    
460 schoenebeck 271 // render audio from all active voices
461     {
462     RTList<uint>::Iterator iuiKey = pActiveKeys->first();
463     RTList<uint>::Iterator end = pActiveKeys->end();
464     while (iuiKey != end) { // iterate through all active keys
465     midi_key_info_t* pKey = &pMIDIKeyInfo[*iuiKey];
466     ++iuiKey;
467 schoenebeck 53
468 schoenebeck 271 RTList<Voice>::Iterator itVoice = pKey->pActiveVoices->first();
469     RTList<Voice>::Iterator itVoicesEnd = pKey->pActiveVoices->end();
470     for (; itVoice != itVoicesEnd; ++itVoice) { // iterate through all voices on this key
471     // now render current voice
472     itVoice->Render(Samples);
473     if (itVoice->IsActive()) active_voices++; // still active
474     else { // voice reached end, is now inactive
475 schoenebeck 285 FreeVoice(itVoice); // remove voice from the list of active voices
476 schoenebeck 271 }
477 schoenebeck 53 }
478     }
479     }
480    
481    
482 schoenebeck 250 // now render all postponed voices from voice stealing
483 schoenebeck 271 {
484     RTList<Event>::Iterator itVoiceStealEvent = pVoiceStealingQueue->first();
485     RTList<Event>::Iterator end = pVoiceStealingQueue->end();
486     for (; itVoiceStealEvent != end; ++itVoiceStealEvent) {
487     Pool<Voice>::Iterator itNewVoice = LaunchVoice(itVoiceStealEvent, itVoiceStealEvent->Param.Note.Layer, itVoiceStealEvent->Param.Note.ReleaseTrigger, false);
488     if (itNewVoice) {
489 schoenebeck 285 for (; itNewVoice; itNewVoice = itNewVoice->itChildVoice) {
490     itNewVoice->Render(Samples);
491     if (itNewVoice->IsActive()) active_voices++; // still active
492     else { // voice reached end, is now inactive
493     FreeVoice(itNewVoice); // remove voice from the list of active voices
494     }
495 schoenebeck 271 }
496 schoenebeck 250 }
497 schoenebeck 287 else dmsg(1,("gig::Engine: ERROR, voice stealing didn't work out!\n"));
498 schoenebeck 250 }
499     }
500     // reset voice stealing for the new fragment
501     pVoiceStealingQueue->clear();
502 schoenebeck 271 itLastStolenVoice = RTList<Voice>::Iterator();
503     iuiLastStolenKey = RTList<uint>::Iterator();
504 schoenebeck 250
505    
506 schoenebeck 287 // free all keys which have no active voices left
507     {
508     RTList<uint>::Iterator iuiKey = pActiveKeys->first();
509     RTList<uint>::Iterator end = pActiveKeys->end();
510     while (iuiKey != end) { // iterate through all active keys
511     midi_key_info_t* pKey = &pMIDIKeyInfo[*iuiKey];
512     ++iuiKey;
513     if (pKey->pActiveVoices->isEmpty()) FreeKey(pKey);
514     #if DEVMODE
515     else { // FIXME: should be removed before the final release (purpose: just a sanity check for debugging)
516     RTList<Voice>::Iterator itVoice = pKey->pActiveVoices->first();
517     RTList<Voice>::Iterator itVoicesEnd = pKey->pActiveVoices->end();
518     for (; itVoice != itVoicesEnd; ++itVoice) { // iterate through all voices on this key
519     if (itVoice->itKillEvent) {
520     dmsg(1,("gig::Engine: ERROR, killed voice survived !!!\n"));
521     }
522     }
523     }
524     #endif // DEVMODE
525     }
526     }
527    
528    
529 schoenebeck 53 // write that to the disk thread class so that it can print it
530     // on the console for debugging purposes
531     ActiveVoiceCount = active_voices;
532     if (ActiveVoiceCount > ActiveVoiceCountMax) ActiveVoiceCountMax = ActiveVoiceCount;
533    
534    
535     return 0;
536     }
537    
538     /**
539     * Will be called by the MIDIIn Thread to let the audio thread trigger a new
540     * voice for the given key.
541     *
542     * @param Key - MIDI key number of the triggered key
543     * @param Velocity - MIDI velocity value of the triggered key
544     */
545     void Engine::SendNoteOn(uint8_t Key, uint8_t Velocity) {
546 schoenebeck 246 Event event = pEventGenerator->CreateEvent();
547     event.Type = Event::type_note_on;
548     event.Param.Note.Key = Key;
549     event.Param.Note.Velocity = Velocity;
550 schoenebeck 53 if (this->pEventQueue->write_space() > 0) this->pEventQueue->push(&event);
551     else dmsg(1,("Engine: Input event queue full!"));
552     }
553    
554     /**
555     * Will be called by the MIDIIn Thread to signal the audio thread to release
556     * voice(s) on the given key.
557     *
558     * @param Key - MIDI key number of the released key
559     * @param Velocity - MIDI release velocity value of the released key
560     */
561     void Engine::SendNoteOff(uint8_t Key, uint8_t Velocity) {
562 schoenebeck 246 Event event = pEventGenerator->CreateEvent();
563     event.Type = Event::type_note_off;
564     event.Param.Note.Key = Key;
565     event.Param.Note.Velocity = Velocity;
566 schoenebeck 53 if (this->pEventQueue->write_space() > 0) this->pEventQueue->push(&event);
567     else dmsg(1,("Engine: Input event queue full!"));
568     }
569    
570     /**
571     * Will be called by the MIDIIn Thread to signal the audio thread to change
572     * the pitch value for all voices.
573     *
574     * @param Pitch - MIDI pitch value (-8192 ... +8191)
575     */
576     void Engine::SendPitchbend(int Pitch) {
577 schoenebeck 246 Event event = pEventGenerator->CreateEvent();
578     event.Type = Event::type_pitchbend;
579     event.Param.Pitch.Pitch = Pitch;
580 schoenebeck 53 if (this->pEventQueue->write_space() > 0) this->pEventQueue->push(&event);
581     else dmsg(1,("Engine: Input event queue full!"));
582     }
583    
584     /**
585     * Will be called by the MIDIIn Thread to signal the audio thread that a
586     * continuous controller value has changed.
587     *
588     * @param Controller - MIDI controller number of the occured control change
589     * @param Value - value of the control change
590     */
591     void Engine::SendControlChange(uint8_t Controller, uint8_t Value) {
592 schoenebeck 246 Event event = pEventGenerator->CreateEvent();
593     event.Type = Event::type_control_change;
594     event.Param.CC.Controller = Controller;
595     event.Param.CC.Value = Value;
596 schoenebeck 53 if (this->pEventQueue->write_space() > 0) this->pEventQueue->push(&event);
597     else dmsg(1,("Engine: Input event queue full!"));
598     }
599    
600     /**
601 schoenebeck 244 * Will be called by the MIDI input device whenever a MIDI system
602     * exclusive message has arrived.
603     *
604     * @param pData - pointer to sysex data
605     * @param Size - lenght of sysex data (in bytes)
606     */
607     void Engine::SendSysex(void* pData, uint Size) {
608 schoenebeck 246 Event event = pEventGenerator->CreateEvent();
609     event.Type = Event::type_sysex;
610     event.Param.Sysex.Size = Size;
611 schoenebeck 244 if (pEventQueue->write_space() > 0) {
612     if (pSysexBuffer->write_space() >= Size) {
613     // copy sysex data to input buffer
614     uint toWrite = Size;
615     uint8_t* pPos = (uint8_t*) pData;
616     while (toWrite) {
617     const uint writeNow = RTMath::Min(toWrite, pSysexBuffer->write_space_to_end());
618     pSysexBuffer->write(pPos, writeNow);
619     toWrite -= writeNow;
620     pPos += writeNow;
621    
622     }
623     // finally place sysex event into input event queue
624     pEventQueue->push(&event);
625     }
626     else dmsg(1,("Engine: Sysex message too large (%d byte) for input buffer (%d byte)!",Size,SYSEX_BUFFER_SIZE));
627     }
628     else dmsg(1,("Engine: Input event queue full!"));
629     }
630    
631     /**
632 schoenebeck 53 * Assigns and triggers a new voice for the respective MIDI key.
633     *
634 schoenebeck 271 * @param itNoteOnEvent - key, velocity and time stamp of the event
635 schoenebeck 53 */
636 schoenebeck 271 void Engine::ProcessNoteOn(Pool<Event>::Iterator& itNoteOnEvent) {
637     midi_key_info_t* pKey = &pMIDIKeyInfo[itNoteOnEvent->Param.Note.Key];
638 schoenebeck 53
639     pKey->KeyPressed = true; // the MIDI key was now pressed down
640    
641     // cancel release process of voices on this key if needed
642     if (pKey->Active && !SustainPedal) {
643 schoenebeck 271 RTList<Event>::Iterator itCancelReleaseEvent = pKey->pEvents->allocAppend();
644     if (itCancelReleaseEvent) {
645     *itCancelReleaseEvent = *itNoteOnEvent; // copy event
646     itCancelReleaseEvent->Type = Event::type_cancel_release; // transform event type
647 schoenebeck 239 }
648     else dmsg(1,("Event pool emtpy!\n"));
649 schoenebeck 53 }
650    
651 schoenebeck 271 // move note on event to the key's own event list
652     RTList<Event>::Iterator itNoteOnEventOnKeyList = itNoteOnEvent.moveToEndOf(pKey->pEvents);
653    
654 schoenebeck 233 // allocate and trigger a new voice for the key
655 schoenebeck 287 LaunchVoice(itNoteOnEventOnKeyList, 0, false, true);
656 schoenebeck 53 }
657    
658     /**
659     * Releases the voices on the given key if sustain pedal is not pressed.
660     * If sustain is pressed, the release of the note will be postponed until
661     * sustain pedal will be released or voice turned inactive by itself (e.g.
662     * due to completion of sample playback).
663     *
664 schoenebeck 271 * @param itNoteOffEvent - key, velocity and time stamp of the event
665 schoenebeck 53 */
666 schoenebeck 271 void Engine::ProcessNoteOff(Pool<Event>::Iterator& itNoteOffEvent) {
667     midi_key_info_t* pKey = &pMIDIKeyInfo[itNoteOffEvent->Param.Note.Key];
668 schoenebeck 53
669     pKey->KeyPressed = false; // the MIDI key was now released
670    
671     // release voices on this key if needed
672     if (pKey->Active && !SustainPedal) {
673 schoenebeck 271 itNoteOffEvent->Type = Event::type_release; // transform event type
674 schoenebeck 53 }
675 schoenebeck 242
676 schoenebeck 271 // move event to the key's own event list
677     RTList<Event>::Iterator itNoteOffEventOnKeyList = itNoteOffEvent.moveToEndOf(pKey->pEvents);
678    
679 schoenebeck 242 // spawn release triggered voice(s) if needed
680     if (pKey->ReleaseTrigger) {
681 schoenebeck 287 LaunchVoice(itNoteOffEventOnKeyList, 0, true, false); //FIXME: for the moment we don't perform voice stealing for release triggered samples
682 schoenebeck 242 pKey->ReleaseTrigger = false;
683     }
684 schoenebeck 53 }
685    
686     /**
687     * Moves pitchbend event from the general (input) event list to the pitch
688     * event list.
689     *
690 schoenebeck 271 * @param itPitchbendEvent - absolute pitch value and time stamp of the event
691 schoenebeck 53 */
692 schoenebeck 271 void Engine::ProcessPitchbend(Pool<Event>::Iterator& itPitchbendEvent) {
693     this->Pitch = itPitchbendEvent->Param.Pitch.Pitch; // store current pitch value
694     itPitchbendEvent.moveToEndOf(pSynthesisEvents[Event::destination_vco]);
695 schoenebeck 53 }
696    
697     /**
698 schoenebeck 233 * Allocates and triggers a new voice. This method will usually be
699     * called by the ProcessNoteOn() method and by the voices itself
700     * (e.g. to spawn further voices on the same key for layered sounds).
701     *
702 schoenebeck 271 * @param itNoteOnEvent - key, velocity and time stamp of the event
703 schoenebeck 242 * @param iLayer - layer index for the new voice (optional - only
704     * in case of layered sounds of course)
705     * @param ReleaseTriggerVoice - if new voice is a release triggered voice
706     * (optional, default = false)
707 schoenebeck 250 * @param VoiceStealing - if voice stealing should be performed
708     * when there is no free voice
709     * (optional, default = true)
710     * @returns pointer to new voice or NULL if there was no free voice or
711     * if an error occured while trying to trigger the new voice
712 schoenebeck 233 */
713 schoenebeck 271 Pool<Voice>::Iterator Engine::LaunchVoice(Pool<Event>::Iterator& itNoteOnEvent, int iLayer, bool ReleaseTriggerVoice, bool VoiceStealing) {
714     midi_key_info_t* pKey = &pMIDIKeyInfo[itNoteOnEvent->Param.Note.Key];
715 schoenebeck 233
716     // allocate a new voice for the key
717 schoenebeck 271 Pool<Voice>::Iterator itNewVoice = pKey->pActiveVoices->allocAppend();
718     if (itNewVoice) {
719 schoenebeck 233 // launch the new voice
720 schoenebeck 287 if (itNewVoice->Trigger(itNoteOnEvent, this->Pitch, this->pInstrument, iLayer, ReleaseTriggerVoice, VoiceStealing) < 0) {
721 schoenebeck 233 dmsg(1,("Triggering new voice failed!\n"));
722 schoenebeck 271 pKey->pActiveVoices->free(itNewVoice);
723 schoenebeck 233 }
724 schoenebeck 239 else { // on success
725     uint** ppKeyGroup = NULL;
726 schoenebeck 271 if (itNewVoice->KeyGroup) { // if this voice / key belongs to a key group
727     ppKeyGroup = &ActiveKeyGroups[itNewVoice->KeyGroup];
728 schoenebeck 239 if (*ppKeyGroup) { // if there's already an active key in that key group
729     midi_key_info_t* pOtherKey = &pMIDIKeyInfo[**ppKeyGroup];
730     // kill all voices on the (other) key
731 schoenebeck 271 RTList<Voice>::Iterator itVoiceToBeKilled = pOtherKey->pActiveVoices->first();
732     RTList<Voice>::Iterator end = pOtherKey->pActiveVoices->end();
733     for (; itVoiceToBeKilled != end; ++itVoiceToBeKilled) {
734     if (itVoiceToBeKilled->Type != Voice::type_release_trigger) itVoiceToBeKilled->Kill(itNoteOnEvent);
735 schoenebeck 242 }
736 schoenebeck 239 }
737     }
738     if (!pKey->Active) { // mark as active key
739     pKey->Active = true;
740 schoenebeck 271 pKey->itSelf = pActiveKeys->allocAppend();
741     *pKey->itSelf = itNoteOnEvent->Param.Note.Key;
742 schoenebeck 239 }
743 schoenebeck 271 if (itNewVoice->KeyGroup) {
744     *ppKeyGroup = &*pKey->itSelf; // put key as the (new) active key to its key group
745 schoenebeck 239 }
746 schoenebeck 271 if (itNewVoice->Type == Voice::type_release_trigger_required) pKey->ReleaseTrigger = true; // mark key for the need of release triggered voice(s)
747     return itNewVoice; // success
748 schoenebeck 233 }
749     }
750 schoenebeck 285 else if (VoiceStealing) {
751     // first, get total amount of required voices (dependant on amount of layers)
752     ::gig::Region* pRegion = pInstrument->GetRegion(itNoteOnEvent->Param.Note.Key);
753     if (!pRegion) return Pool<Voice>::Iterator(); // nothing defined for this MIDI key, so no voice needed
754     int voicesRequired = pRegion->Layers;
755 schoenebeck 250
756 schoenebeck 285 // now steal the (remaining) amount of voices
757     for (int i = iLayer; i < voicesRequired; i++)
758     StealVoice(itNoteOnEvent);
759    
760     // put note-on event into voice-stealing queue, so it will be reprocessed after killed voice died
761     RTList<Event>::Iterator itStealEvent = pVoiceStealingQueue->allocAppend();
762     if (itStealEvent) {
763     *itStealEvent = *itNoteOnEvent; // copy event
764     itStealEvent->Param.Note.Layer = iLayer;
765     itStealEvent->Param.Note.ReleaseTrigger = ReleaseTriggerVoice;
766     }
767     else dmsg(1,("Voice stealing queue full!\n"));
768     }
769    
770 schoenebeck 271 return Pool<Voice>::Iterator(); // no free voice or error
771 schoenebeck 233 }
772    
773     /**
774 schoenebeck 250 * Will be called by LaunchVoice() method in case there are no free
775     * voices left. This method will select and kill one old voice for
776     * voice stealing and postpone the note-on event until the selected
777     * voice actually died.
778     *
779 schoenebeck 285 * @param itNoteOnEvent - key, velocity and time stamp of the event
780 schoenebeck 250 */
781 schoenebeck 285 void Engine::StealVoice(Pool<Event>::Iterator& itNoteOnEvent) {
782 schoenebeck 271 if (!pEventPool->poolIsEmpty()) {
783 schoenebeck 250
784 schoenebeck 271 RTList<uint>::Iterator iuiOldestKey;
785     RTList<Voice>::Iterator itOldestVoice;
786 schoenebeck 250
787     // Select one voice for voice stealing
788     switch (VOICE_STEAL_ALGORITHM) {
789    
790     // try to pick the oldest voice on the key where the new
791     // voice should be spawned, if there is no voice on that
792     // key, or no voice left to kill there, then procceed with
793     // 'oldestkey' algorithm
794     case voice_steal_algo_keymask: {
795 schoenebeck 271 midi_key_info_t* pOldestKey = &pMIDIKeyInfo[itNoteOnEvent->Param.Note.Key];
796     if (itLastStolenVoice) {
797     itOldestVoice = itLastStolenVoice;
798     ++itOldestVoice;
799 schoenebeck 250 }
800     else { // no voice stolen in this audio fragment cycle yet
801 schoenebeck 271 itOldestVoice = pOldestKey->pActiveVoices->first();
802 schoenebeck 250 }
803 schoenebeck 271 if (itOldestVoice) {
804     iuiOldestKey = pOldestKey->itSelf;
805 schoenebeck 250 break; // selection succeeded
806     }
807     } // no break - intentional !
808    
809     // try to pick the oldest voice on the oldest active key
810     // (caution: must stay after 'keymask' algorithm !)
811     case voice_steal_algo_oldestkey: {
812 schoenebeck 271 if (itLastStolenVoice) {
813     midi_key_info_t* pOldestKey = &pMIDIKeyInfo[*iuiLastStolenKey];
814     itOldestVoice = itLastStolenVoice;
815     ++itOldestVoice;
816     if (!itOldestVoice) {
817     iuiOldestKey = iuiLastStolenKey;
818     ++iuiOldestKey;
819     if (iuiOldestKey) {
820     midi_key_info_t* pOldestKey = &pMIDIKeyInfo[*iuiOldestKey];
821     itOldestVoice = pOldestKey->pActiveVoices->first();
822 schoenebeck 250 }
823 schoenebeck 285 else {
824     dmsg(1,("gig::Engine: Warning, too less voices, even for voice stealing! - Better recompile with higher MAX_AUDIO_VOICES.\n"));
825 schoenebeck 250 return;
826     }
827     }
828 schoenebeck 271 else iuiOldestKey = iuiLastStolenKey;
829 schoenebeck 250 }
830     else { // no voice stolen in this audio fragment cycle yet
831 schoenebeck 271 iuiOldestKey = pActiveKeys->first();
832     midi_key_info_t* pOldestKey = &pMIDIKeyInfo[*iuiOldestKey];
833     itOldestVoice = pOldestKey->pActiveVoices->first();
834 schoenebeck 250 }
835     break;
836     }
837    
838     // don't steal anything
839     case voice_steal_algo_none:
840     default: {
841     dmsg(1,("No free voice (voice stealing disabled)!\n"));
842     return;
843     }
844     }
845    
846 schoenebeck 287 //FIXME: can be removed, just a sanity check for debugging
847     if (!itOldestVoice->IsActive()) dmsg(1,("gig::Engine: ERROR, tried to steal a voice which was not active !!!\n"));
848    
849 schoenebeck 250 // now kill the selected voice
850 schoenebeck 271 itOldestVoice->Kill(itNoteOnEvent);
851 schoenebeck 250 // remember which voice on which key we stole, so we can simply proceed for the next voice stealing
852 schoenebeck 271 this->itLastStolenVoice = itOldestVoice;
853     this->iuiLastStolenKey = iuiOldestKey;
854 schoenebeck 250 }
855     else dmsg(1,("Event pool emtpy!\n"));
856     }
857    
858     /**
859 schoenebeck 285 * Removes the given voice from the MIDI key's list of active voices.
860     * This method will be called when a voice went inactive, e.g. because
861     * it finished to playback its sample, finished its release stage or
862     * just was killed.
863 schoenebeck 53 *
864 schoenebeck 285 * @param itVoice - points to the voice to be freed
865 schoenebeck 53 */
866 schoenebeck 285 void Engine::FreeVoice(Pool<Voice>::Iterator& itVoice) {
867 schoenebeck 271 if (itVoice) {
868     midi_key_info_t* pKey = &pMIDIKeyInfo[itVoice->MIDIKey];
869 schoenebeck 53
870 schoenebeck 271 uint keygroup = itVoice->KeyGroup;
871    
872 schoenebeck 53 // free the voice object
873 schoenebeck 271 pVoicePool->free(itVoice);
874 schoenebeck 53
875 schoenebeck 287 // if no other voices left and member of a key group, remove from key group
876     if (pKey->pActiveVoices->isEmpty() && keygroup) {
877     uint** ppKeyGroup = &ActiveKeyGroups[keygroup];
878     if (*ppKeyGroup == &*pKey->itSelf) *ppKeyGroup = NULL; // remove key from key group
879 schoenebeck 53 }
880     }
881 schoenebeck 285 else std::cerr << "Couldn't release voice! (!itVoice)\n" << std::flush;
882 schoenebeck 53 }
883    
884     /**
885 schoenebeck 287 * Called when there's no more voice left on a key, this call will
886     * update the key info respectively.
887     *
888     * @param pKey - key which is now inactive
889     */
890     void Engine::FreeKey(midi_key_info_t* pKey) {
891     if (pKey->pActiveVoices->isEmpty()) {
892     pKey->Active = false;
893     pActiveKeys->free(pKey->itSelf); // remove key from list of active keys
894     pKey->itSelf = RTList<uint>::Iterator();
895     pKey->ReleaseTrigger = false;
896     pKey->pEvents->clear();
897     dmsg(3,("Key has no more voices now\n"));
898     }
899     else dmsg(1,("gig::Engine: Oops, tried to free a key which contains voices.\n"));
900     }
901    
902     /**
903 schoenebeck 53 * Reacts on supported control change commands (e.g. pitch bend wheel,
904     * modulation wheel, aftertouch).
905     *
906 schoenebeck 271 * @param itControlChangeEvent - controller, value and time stamp of the event
907 schoenebeck 53 */
908 schoenebeck 271 void Engine::ProcessControlChange(Pool<Event>::Iterator& itControlChangeEvent) {
909     dmsg(4,("Engine::ContinuousController cc=%d v=%d\n", itControlChangeEvent->Param.CC.Controller, itControlChangeEvent->Param.CC.Value));
910 schoenebeck 53
911 schoenebeck 271 switch (itControlChangeEvent->Param.CC.Controller) {
912 schoenebeck 53 case 64: {
913 schoenebeck 271 if (itControlChangeEvent->Param.CC.Value >= 64 && !SustainPedal) {
914 schoenebeck 53 dmsg(4,("PEDAL DOWN\n"));
915     SustainPedal = true;
916    
917     // cancel release process of voices if necessary
918 schoenebeck 271 RTList<uint>::Iterator iuiKey = pActiveKeys->first();
919     if (iuiKey) {
920     itControlChangeEvent->Type = Event::type_cancel_release; // transform event type
921     while (iuiKey) {
922     midi_key_info_t* pKey = &pMIDIKeyInfo[*iuiKey];
923     ++iuiKey;
924 schoenebeck 53 if (!pKey->KeyPressed) {
925 schoenebeck 271 RTList<Event>::Iterator itNewEvent = pKey->pEvents->allocAppend();
926     if (itNewEvent) *itNewEvent = *itControlChangeEvent; // copy event to the key's own event list
927 schoenebeck 53 else dmsg(1,("Event pool emtpy!\n"));
928     }
929     }
930     }
931     }
932 schoenebeck 271 if (itControlChangeEvent->Param.CC.Value < 64 && SustainPedal) {
933 schoenebeck 53 dmsg(4,("PEDAL UP\n"));
934     SustainPedal = false;
935    
936     // release voices if their respective key is not pressed
937 schoenebeck 271 RTList<uint>::Iterator iuiKey = pActiveKeys->first();
938     if (iuiKey) {
939     itControlChangeEvent->Type = Event::type_release; // transform event type
940     while (iuiKey) {
941     midi_key_info_t* pKey = &pMIDIKeyInfo[*iuiKey];
942     ++iuiKey;
943 schoenebeck 53 if (!pKey->KeyPressed) {
944 schoenebeck 271 RTList<Event>::Iterator itNewEvent = pKey->pEvents->allocAppend();
945     if (itNewEvent) *itNewEvent = *itControlChangeEvent; // copy event to the key's own event list
946 schoenebeck 53 else dmsg(1,("Event pool emtpy!\n"));
947     }
948     }
949     }
950     }
951     break;
952     }
953     }
954    
955     // update controller value in the engine's controller table
956 schoenebeck 271 ControllerTable[itControlChangeEvent->Param.CC.Controller] = itControlChangeEvent->Param.CC.Value;
957 schoenebeck 53
958     // move event from the unsorted event list to the control change event list
959 schoenebeck 271 itControlChangeEvent.moveToEndOf(pCCEvents);
960 schoenebeck 53 }
961    
962     /**
963 schoenebeck 244 * Reacts on MIDI system exclusive messages.
964     *
965 schoenebeck 271 * @param itSysexEvent - sysex data size and time stamp of the sysex event
966 schoenebeck 244 */
967 schoenebeck 271 void Engine::ProcessSysex(Pool<Event>::Iterator& itSysexEvent) {
968 schoenebeck 244 RingBuffer<uint8_t>::NonVolatileReader reader = pSysexBuffer->get_non_volatile_reader();
969    
970     uint8_t exclusive_status, id;
971     if (!reader.pop(&exclusive_status)) goto free_sysex_data;
972     if (!reader.pop(&id)) goto free_sysex_data;
973     if (exclusive_status != 0xF0) goto free_sysex_data;
974    
975     switch (id) {
976     case 0x41: { // Roland
977     uint8_t device_id, model_id, cmd_id;
978     if (!reader.pop(&device_id)) goto free_sysex_data;
979     if (!reader.pop(&model_id)) goto free_sysex_data;
980     if (!reader.pop(&cmd_id)) goto free_sysex_data;
981     if (model_id != 0x42 /*GS*/) goto free_sysex_data;
982     if (cmd_id != 0x12 /*DT1*/) goto free_sysex_data;
983    
984     // command address
985     uint8_t addr[3]; // 2 byte addr MSB, followed by 1 byte addr LSB)
986     const RingBuffer<uint8_t>::NonVolatileReader checksum_reader = reader; // so we can calculate the check sum later
987     if (reader.read(&addr[0], 3) != 3) goto free_sysex_data;
988     if (addr[0] == 0x40 && addr[1] == 0x00) { // System Parameters
989     }
990     else if (addr[0] == 0x40 && addr[1] == 0x01) { // Common Parameters
991     }
992     else if (addr[0] == 0x40 && (addr[1] & 0xf0) == 0x10) { // Part Parameters (1)
993     switch (addr[3]) {
994     case 0x40: { // scale tuning
995     uint8_t scale_tunes[12]; // detuning of all 12 semitones of an octave
996     if (reader.read(&scale_tunes[0], 12) != 12) goto free_sysex_data;
997     uint8_t checksum;
998     if (!reader.pop(&checksum)) goto free_sysex_data;
999     if (GSCheckSum(checksum_reader, 12) != checksum) goto free_sysex_data;
1000     for (int i = 0; i < 12; i++) scale_tunes[i] -= 64;
1001     AdjustScale((int8_t*) scale_tunes);
1002     break;
1003     }
1004     }
1005     }
1006     else if (addr[0] == 0x40 && (addr[1] & 0xf0) == 0x20) { // Part Parameters (2)
1007     }
1008     else if (addr[0] == 0x41) { // Drum Setup Parameters
1009     }
1010     break;
1011     }
1012     }
1013    
1014     free_sysex_data: // finally free sysex data
1015 schoenebeck 271 pSysexBuffer->increment_read_ptr(itSysexEvent->Param.Sysex.Size);
1016 schoenebeck 244 }
1017    
1018     /**
1019     * Calculates the Roland GS sysex check sum.
1020     *
1021     * @param AddrReader - reader which currently points to the first GS
1022     * command address byte of the GS sysex message in
1023     * question
1024     * @param DataSize - size of the GS message data (in bytes)
1025     */
1026     uint8_t Engine::GSCheckSum(const RingBuffer<uint8_t>::NonVolatileReader AddrReader, uint DataSize) {
1027     RingBuffer<uint8_t>::NonVolatileReader reader = AddrReader;
1028     uint bytes = 3 /*addr*/ + DataSize;
1029     uint8_t addr_and_data[bytes];
1030     reader.read(&addr_and_data[0], bytes);
1031     uint8_t sum = 0;
1032     for (uint i = 0; i < bytes; i++) sum += addr_and_data[i];
1033     return 128 - sum % 128;
1034     }
1035    
1036     /**
1037     * Allows to tune each of the twelve semitones of an octave.
1038     *
1039     * @param ScaleTunes - detuning of all twelve semitones (in cents)
1040     */
1041     void Engine::AdjustScale(int8_t ScaleTunes[12]) {
1042     memcpy(&this->ScaleTuning[0], &ScaleTunes[0], 12); //TODO: currently not sample accurate
1043     }
1044    
1045     /**
1046 schoenebeck 53 * Initialize the parameter sequence for the modulation destination given by
1047     * by 'dst' with the constant value given by val.
1048     */
1049     void Engine::ResetSynthesisParameters(Event::destination_t dst, float val) {
1050     int maxsamples = pAudioOutputDevice->MaxSamplesPerCycle();
1051 schoenebeck 80 float* m = &pSynthesisParameters[dst][0];
1052     for (int i = 0; i < maxsamples; i += 4) {
1053     m[i] = val;
1054     m[i+1] = val;
1055     m[i+2] = val;
1056     m[i+3] = val;
1057     }
1058 schoenebeck 53 }
1059    
1060     float Engine::Volume() {
1061     return GlobalVolume;
1062     }
1063    
1064     void Engine::Volume(float f) {
1065     GlobalVolume = f;
1066     }
1067    
1068 schoenebeck 225 uint Engine::Channels() {
1069     return 2;
1070     }
1071    
1072     void Engine::SetOutputChannel(uint EngineAudioChannel, uint AudioDeviceChannel) {
1073     AudioChannel* pChannel = pAudioOutputDevice->Channel(AudioDeviceChannel);
1074     if (!pChannel) throw AudioOutputException("Invalid audio output device channel " + ToString(AudioDeviceChannel));
1075     switch (EngineAudioChannel) {
1076     case 0: // left output channel
1077     pOutputLeft = pChannel->Buffer();
1078     AudioDeviceChannelLeft = AudioDeviceChannel;
1079     break;
1080     case 1: // right output channel
1081     pOutputRight = pChannel->Buffer();
1082     AudioDeviceChannelRight = AudioDeviceChannel;
1083     break;
1084     default:
1085     throw AudioOutputException("Invalid engine audio channel " + ToString(EngineAudioChannel));
1086     }
1087     }
1088    
1089     int Engine::OutputChannel(uint EngineAudioChannel) {
1090     switch (EngineAudioChannel) {
1091     case 0: // left channel
1092     return AudioDeviceChannelLeft;
1093     case 1: // right channel
1094     return AudioDeviceChannelRight;
1095     default:
1096     throw AudioOutputException("Invalid engine audio channel " + ToString(EngineAudioChannel));
1097     }
1098     }
1099    
1100 schoenebeck 53 uint Engine::VoiceCount() {
1101     return ActiveVoiceCount;
1102     }
1103    
1104     uint Engine::VoiceCountMax() {
1105     return ActiveVoiceCountMax;
1106     }
1107    
1108     bool Engine::DiskStreamSupported() {
1109     return true;
1110     }
1111    
1112     uint Engine::DiskStreamCount() {
1113     return (pDiskThread) ? pDiskThread->ActiveStreamCount : 0;
1114     }
1115    
1116     uint Engine::DiskStreamCountMax() {
1117     return (pDiskThread) ? pDiskThread->ActiveStreamCountMax : 0;
1118     }
1119    
1120     String Engine::DiskStreamBufferFillBytes() {
1121     return pDiskThread->GetBufferFillBytes();
1122     }
1123    
1124     String Engine::DiskStreamBufferFillPercentage() {
1125     return pDiskThread->GetBufferFillPercentage();
1126     }
1127    
1128 senkov 112 String Engine::EngineName() {
1129     return "GigEngine";
1130     }
1131    
1132     String Engine::InstrumentFileName() {
1133     return InstrumentFile;
1134     }
1135    
1136     int Engine::InstrumentIndex() {
1137     return InstrumentIdx;
1138     }
1139    
1140 capela 133 int Engine::InstrumentStatus() {
1141     return InstrumentStat;
1142     }
1143    
1144 schoenebeck 53 String Engine::Description() {
1145     return "Gigasampler Engine";
1146     }
1147    
1148     String Engine::Version() {
1149 schoenebeck 287 String s = "$Revision: 1.17 $";
1150 schoenebeck 123 return s.substr(11, s.size() - 13); // cut dollar signs, spaces and CVS macro keyword
1151 schoenebeck 53 }
1152    
1153     }} // namespace LinuxSampler::gig

  ViewVC Help
Powered by ViewVC