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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 285 - (show annotations) (download)
Thu Oct 14 21:31:26 2004 UTC (19 years, 5 months ago) by schoenebeck
File size: 47655 byte(s)
* bunch of bugfixes (e.g. segfault on voice stealing)

1 /***************************************************************************
2 * *
3 * LinuxSampler - modular, streaming capable sampler *
4 * *
5 * Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck *
6 * *
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 #include "EGADSR.h"
27
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 pSysexBuffer = new RingBuffer<uint8_t>(SYSEX_BUFFER_SIZE, 0);
42 pEventQueue = new RingBuffer<Event>(MAX_EVENTS_PER_FRAGMENT, 0);
43 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 for (uint i = 0; i < Event::destination_count; i++) {
50 pSynthesisEvents[i] = new RTList<Event>(pEventPool);
51 }
52 for (uint i = 0; i < 128; i++) {
53 pMIDIKeyInfo[i].pActiveVoices = new RTList<Voice>(pVoicePool);
54 pMIDIKeyInfo[i].KeyPressed = false;
55 pMIDIKeyInfo[i].Active = false;
56 pMIDIKeyInfo[i].ReleaseTrigger = false;
57 pMIDIKeyInfo[i].pEvents = new RTList<Event>(pEventPool);
58 }
59 for (RTList<Voice>::Iterator iterVoice = pVoicePool->allocAppend(); iterVoice == pVoicePool->last(); iterVoice = pVoicePool->allocAppend()) {
60 iterVoice->SetEngine(this);
61 }
62 pVoicePool->clear();
63
64 pSynthesisParameters[0] = NULL; // we allocate when an audio device is connected
65 pBasicFilterParameters = NULL;
66 pMainFilterParameters = NULL;
67
68 InstrumentIdx = -1;
69 InstrumentStat = -1;
70
71 AudioDeviceChannelLeft = -1;
72 AudioDeviceChannelRight = -1;
73
74 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 if (pSysexBuffer) delete pSysexBuffer;
99 if (pEventGenerator) delete pEventGenerator;
100 if (pMainFilterParameters) delete[] pMainFilterParameters;
101 if (pBasicFilterParameters) delete[] pBasicFilterParameters;
102 if (pSynthesisParameters[0]) delete[] pSynthesisParameters[0];
103 if (pVoiceStealingQueue) delete pVoiceStealingQueue;
104 }
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 dmsg(3,("gig::Engine: enabled (val=%d)\n", EngineDisabled.GetUnsafe()));
110 }
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 GlobalVolume = 1.0;
161
162 // reset voice stealing parameters
163 itLastStolenVoice = RTList<Voice>::Iterator();
164 iuiLastStolenKey = RTList<uint>::Iterator();
165 pVoiceStealingQueue->clear();
166
167 // reset to normal chromatic scale (means equal temper)
168 memset(&ScaleTuning[0], 0x00, 12);
169
170 // 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 pMIDIKeyInfo[i].KeyPressed = false;
178 pMIDIKeyInfo[i].Active = false;
179 pMIDIKeyInfo[i].ReleaseTrigger = false;
180 pMIDIKeyInfo[i].itSelf = Pool<uint>::Iterator();
181 }
182
183 // reset all key groups
184 map<uint,uint*>::iterator iter = ActiveKeyGroups.begin();
185 for (; iter != ActiveKeyGroups.end(); iter++) iter->second = NULL;
186
187 // reset all voices
188 for (RTList<Voice>::Iterator iterVoice = pVoicePool->allocAppend(); iterVoice == pVoicePool->last(); iterVoice = pVoicePool->allocAppend()) {
189 iterVoice->Reset();
190 }
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 InstrumentFile = FileName;
224 InstrumentIdx = Instrument;
225 InstrumentStat = 0;
226
227 // delete all key groups
228 ActiveKeyGroups.clear();
229
230 // 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 InstrumentStat = -1;
238 dmsg(1,("no instrument loaded!!!\n"));
239 exit(EXIT_FAILURE);
240 }
241 }
242 catch (RIFF::Exception e) {
243 InstrumentStat = -2;
244 String msg = "gig::Engine error: Failed to load instrument, cause: " + e.Message;
245 throw LinuxSamplerException(msg);
246 }
247 catch (InstrumentResourceManagerException e) {
248 InstrumentStat = -3;
249 String msg = "gig::Engine error: Failed to load instrument, cause: " + e.Message();
250 throw LinuxSamplerException(msg);
251 }
252 catch (...) {
253 InstrumentStat = -4;
254 throw LinuxSamplerException("gig::Engine error: Failed to load instrument, cause: Unknown exception while trying to parse gig file.");
255 }
256
257 // 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 InstrumentStat = 100;
262
263 // 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 this->pInstrument = pNewResource; //TODO: there are couple of engine parameters we should update here as well if the instrument was updated (see LoadInstrument())
293 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 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 // 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 // (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 for (RTList<Voice>::Iterator iterVoice = pVoicePool->allocAppend(); iterVoice == pVoicePool->last(); iterVoice = pVoicePool->allocAppend()) {
334 iterVoice->pDiskThread = this->pDiskThread;
335 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 // (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 dmsg(1,("Starting disk thread..."));
356 pDiskThread->StartThread();
357 dmsg(1,("OK\n"));
358
359 for (RTList<Voice>::Iterator iterVoice = pVoicePool->allocAppend(); iterVoice == pVoicePool->last(); iterVoice = pVoicePool->allocAppend()) {
360 if (!iterVoice->pDiskThread) {
361 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 AudioDeviceChannelLeft = -1;
373 AudioDeviceChannelRight = -1;
374 }
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 {
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 }
414
415 // read and copy events from input queue
416 Event event = pEventGenerator->CreateEvent();
417 while (true) {
418 if (!pEventQueue->pop(&event) || pEvents->poolIsEmpty()) break;
419 *pEvents->allocAppend() = event;
420 }
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 {
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 }
455 }
456
457
458 int active_voices = 0;
459
460 // 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
468 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 FreeVoice(itVoice); // remove voice from the list of active voices
476 }
477 }
478 }
479 }
480
481
482 // now render all postponed voices from voice stealing
483 {
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 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 }
496 }
497 else dmsg(1,("Ouch, voice stealing didn't work out!\n"));
498 }
499 }
500 // reset voice stealing for the new fragment
501 pVoiceStealingQueue->clear();
502 itLastStolenVoice = RTList<Voice>::Iterator();
503 iuiLastStolenKey = RTList<uint>::Iterator();
504
505
506 // write that to the disk thread class so that it can print it
507 // on the console for debugging purposes
508 ActiveVoiceCount = active_voices;
509 if (ActiveVoiceCount > ActiveVoiceCountMax) ActiveVoiceCountMax = ActiveVoiceCount;
510
511
512 return 0;
513 }
514
515 /**
516 * Will be called by the MIDIIn Thread to let the audio thread trigger a new
517 * voice for the given key.
518 *
519 * @param Key - MIDI key number of the triggered key
520 * @param Velocity - MIDI velocity value of the triggered key
521 */
522 void Engine::SendNoteOn(uint8_t Key, uint8_t Velocity) {
523 Event event = pEventGenerator->CreateEvent();
524 event.Type = Event::type_note_on;
525 event.Param.Note.Key = Key;
526 event.Param.Note.Velocity = Velocity;
527 if (this->pEventQueue->write_space() > 0) this->pEventQueue->push(&event);
528 else dmsg(1,("Engine: Input event queue full!"));
529 }
530
531 /**
532 * Will be called by the MIDIIn Thread to signal the audio thread to release
533 * voice(s) on the given key.
534 *
535 * @param Key - MIDI key number of the released key
536 * @param Velocity - MIDI release velocity value of the released key
537 */
538 void Engine::SendNoteOff(uint8_t Key, uint8_t Velocity) {
539 Event event = pEventGenerator->CreateEvent();
540 event.Type = Event::type_note_off;
541 event.Param.Note.Key = Key;
542 event.Param.Note.Velocity = Velocity;
543 if (this->pEventQueue->write_space() > 0) this->pEventQueue->push(&event);
544 else dmsg(1,("Engine: Input event queue full!"));
545 }
546
547 /**
548 * Will be called by the MIDIIn Thread to signal the audio thread to change
549 * the pitch value for all voices.
550 *
551 * @param Pitch - MIDI pitch value (-8192 ... +8191)
552 */
553 void Engine::SendPitchbend(int Pitch) {
554 Event event = pEventGenerator->CreateEvent();
555 event.Type = Event::type_pitchbend;
556 event.Param.Pitch.Pitch = Pitch;
557 if (this->pEventQueue->write_space() > 0) this->pEventQueue->push(&event);
558 else dmsg(1,("Engine: Input event queue full!"));
559 }
560
561 /**
562 * Will be called by the MIDIIn Thread to signal the audio thread that a
563 * continuous controller value has changed.
564 *
565 * @param Controller - MIDI controller number of the occured control change
566 * @param Value - value of the control change
567 */
568 void Engine::SendControlChange(uint8_t Controller, uint8_t Value) {
569 Event event = pEventGenerator->CreateEvent();
570 event.Type = Event::type_control_change;
571 event.Param.CC.Controller = Controller;
572 event.Param.CC.Value = Value;
573 if (this->pEventQueue->write_space() > 0) this->pEventQueue->push(&event);
574 else dmsg(1,("Engine: Input event queue full!"));
575 }
576
577 /**
578 * Will be called by the MIDI input device whenever a MIDI system
579 * exclusive message has arrived.
580 *
581 * @param pData - pointer to sysex data
582 * @param Size - lenght of sysex data (in bytes)
583 */
584 void Engine::SendSysex(void* pData, uint Size) {
585 Event event = pEventGenerator->CreateEvent();
586 event.Type = Event::type_sysex;
587 event.Param.Sysex.Size = Size;
588 if (pEventQueue->write_space() > 0) {
589 if (pSysexBuffer->write_space() >= Size) {
590 // copy sysex data to input buffer
591 uint toWrite = Size;
592 uint8_t* pPos = (uint8_t*) pData;
593 while (toWrite) {
594 const uint writeNow = RTMath::Min(toWrite, pSysexBuffer->write_space_to_end());
595 pSysexBuffer->write(pPos, writeNow);
596 toWrite -= writeNow;
597 pPos += writeNow;
598
599 }
600 // finally place sysex event into input event queue
601 pEventQueue->push(&event);
602 }
603 else dmsg(1,("Engine: Sysex message too large (%d byte) for input buffer (%d byte)!",Size,SYSEX_BUFFER_SIZE));
604 }
605 else dmsg(1,("Engine: Input event queue full!"));
606 }
607
608 /**
609 * Assigns and triggers a new voice for the respective MIDI key.
610 *
611 * @param itNoteOnEvent - key, velocity and time stamp of the event
612 */
613 void Engine::ProcessNoteOn(Pool<Event>::Iterator& itNoteOnEvent) {
614 midi_key_info_t* pKey = &pMIDIKeyInfo[itNoteOnEvent->Param.Note.Key];
615
616 pKey->KeyPressed = true; // the MIDI key was now pressed down
617
618 // cancel release process of voices on this key if needed
619 if (pKey->Active && !SustainPedal) {
620 RTList<Event>::Iterator itCancelReleaseEvent = pKey->pEvents->allocAppend();
621 if (itCancelReleaseEvent) {
622 *itCancelReleaseEvent = *itNoteOnEvent; // copy event
623 itCancelReleaseEvent->Type = Event::type_cancel_release; // transform event type
624 }
625 else dmsg(1,("Event pool emtpy!\n"));
626 }
627
628 // move note on event to the key's own event list
629 RTList<Event>::Iterator itNoteOnEventOnKeyList = itNoteOnEvent.moveToEndOf(pKey->pEvents);
630
631 // allocate and trigger a new voice for the key
632 LaunchVoice(itNoteOnEventOnKeyList);
633 }
634
635 /**
636 * Releases the voices on the given key if sustain pedal is not pressed.
637 * If sustain is pressed, the release of the note will be postponed until
638 * sustain pedal will be released or voice turned inactive by itself (e.g.
639 * due to completion of sample playback).
640 *
641 * @param itNoteOffEvent - key, velocity and time stamp of the event
642 */
643 void Engine::ProcessNoteOff(Pool<Event>::Iterator& itNoteOffEvent) {
644 midi_key_info_t* pKey = &pMIDIKeyInfo[itNoteOffEvent->Param.Note.Key];
645
646 pKey->KeyPressed = false; // the MIDI key was now released
647
648 // release voices on this key if needed
649 if (pKey->Active && !SustainPedal) {
650 itNoteOffEvent->Type = Event::type_release; // transform event type
651 }
652
653 // move event to the key's own event list
654 RTList<Event>::Iterator itNoteOffEventOnKeyList = itNoteOffEvent.moveToEndOf(pKey->pEvents);
655
656 // spawn release triggered voice(s) if needed
657 if (pKey->ReleaseTrigger) {
658 LaunchVoice(itNoteOffEventOnKeyList, 0, true);
659 pKey->ReleaseTrigger = false;
660 }
661 }
662
663 /**
664 * Moves pitchbend event from the general (input) event list to the pitch
665 * event list.
666 *
667 * @param itPitchbendEvent - absolute pitch value and time stamp of the event
668 */
669 void Engine::ProcessPitchbend(Pool<Event>::Iterator& itPitchbendEvent) {
670 this->Pitch = itPitchbendEvent->Param.Pitch.Pitch; // store current pitch value
671 itPitchbendEvent.moveToEndOf(pSynthesisEvents[Event::destination_vco]);
672 }
673
674 /**
675 * Allocates and triggers a new voice. This method will usually be
676 * called by the ProcessNoteOn() method and by the voices itself
677 * (e.g. to spawn further voices on the same key for layered sounds).
678 *
679 * @param itNoteOnEvent - key, velocity and time stamp of the event
680 * @param iLayer - layer index for the new voice (optional - only
681 * in case of layered sounds of course)
682 * @param ReleaseTriggerVoice - if new voice is a release triggered voice
683 * (optional, default = false)
684 * @param VoiceStealing - if voice stealing should be performed
685 * when there is no free voice
686 * (optional, default = true)
687 * @returns pointer to new voice or NULL if there was no free voice or
688 * if an error occured while trying to trigger the new voice
689 */
690 Pool<Voice>::Iterator Engine::LaunchVoice(Pool<Event>::Iterator& itNoteOnEvent, int iLayer, bool ReleaseTriggerVoice, bool VoiceStealing) {
691 midi_key_info_t* pKey = &pMIDIKeyInfo[itNoteOnEvent->Param.Note.Key];
692
693 // allocate a new voice for the key
694 Pool<Voice>::Iterator itNewVoice = pKey->pActiveVoices->allocAppend();
695 if (itNewVoice) {
696 // launch the new voice
697 if (itNewVoice->Trigger(itNoteOnEvent, this->Pitch, this->pInstrument, iLayer, ReleaseTriggerVoice) < 0) {
698 dmsg(1,("Triggering new voice failed!\n"));
699 pKey->pActiveVoices->free(itNewVoice);
700 }
701 else { // on success
702 uint** ppKeyGroup = NULL;
703 if (itNewVoice->KeyGroup) { // if this voice / key belongs to a key group
704 ppKeyGroup = &ActiveKeyGroups[itNewVoice->KeyGroup];
705 if (*ppKeyGroup) { // if there's already an active key in that key group
706 midi_key_info_t* pOtherKey = &pMIDIKeyInfo[**ppKeyGroup];
707 // kill all voices on the (other) key
708 RTList<Voice>::Iterator itVoiceToBeKilled = pOtherKey->pActiveVoices->first();
709 RTList<Voice>::Iterator end = pOtherKey->pActiveVoices->end();
710 for (; itVoiceToBeKilled != end; ++itVoiceToBeKilled) {
711 if (itVoiceToBeKilled->Type != Voice::type_release_trigger) itVoiceToBeKilled->Kill(itNoteOnEvent);
712 }
713 }
714 }
715 if (!pKey->Active) { // mark as active key
716 pKey->Active = true;
717 pKey->itSelf = pActiveKeys->allocAppend();
718 *pKey->itSelf = itNoteOnEvent->Param.Note.Key;
719 }
720 if (itNewVoice->KeyGroup) {
721 *ppKeyGroup = &*pKey->itSelf; // put key as the (new) active key to its key group
722 }
723 if (itNewVoice->Type == Voice::type_release_trigger_required) pKey->ReleaseTrigger = true; // mark key for the need of release triggered voice(s)
724 return itNewVoice; // success
725 }
726 }
727 else if (VoiceStealing) {
728 // first, get total amount of required voices (dependant on amount of layers)
729 ::gig::Region* pRegion = pInstrument->GetRegion(itNoteOnEvent->Param.Note.Key);
730 if (!pRegion) return Pool<Voice>::Iterator(); // nothing defined for this MIDI key, so no voice needed
731 int voicesRequired = pRegion->Layers;
732
733 // now steal the (remaining) amount of voices
734 for (int i = iLayer; i < voicesRequired; i++)
735 StealVoice(itNoteOnEvent);
736
737 // put note-on event into voice-stealing queue, so it will be reprocessed after killed voice died
738 RTList<Event>::Iterator itStealEvent = pVoiceStealingQueue->allocAppend();
739 if (itStealEvent) {
740 *itStealEvent = *itNoteOnEvent; // copy event
741 itStealEvent->Param.Note.Layer = iLayer;
742 itStealEvent->Param.Note.ReleaseTrigger = ReleaseTriggerVoice;
743 }
744 else dmsg(1,("Voice stealing queue full!\n"));
745 }
746
747 return Pool<Voice>::Iterator(); // no free voice or error
748 }
749
750 /**
751 * Will be called by LaunchVoice() method in case there are no free
752 * voices left. This method will select and kill one old voice for
753 * voice stealing and postpone the note-on event until the selected
754 * voice actually died.
755 *
756 * @param itNoteOnEvent - key, velocity and time stamp of the event
757 */
758 void Engine::StealVoice(Pool<Event>::Iterator& itNoteOnEvent) {
759 if (!pEventPool->poolIsEmpty()) {
760
761 RTList<uint>::Iterator iuiOldestKey;
762 RTList<Voice>::Iterator itOldestVoice;
763
764 // Select one voice for voice stealing
765 switch (VOICE_STEAL_ALGORITHM) {
766
767 // try to pick the oldest voice on the key where the new
768 // voice should be spawned, if there is no voice on that
769 // key, or no voice left to kill there, then procceed with
770 // 'oldestkey' algorithm
771 case voice_steal_algo_keymask: {
772 midi_key_info_t* pOldestKey = &pMIDIKeyInfo[itNoteOnEvent->Param.Note.Key];
773 if (itLastStolenVoice) {
774 itOldestVoice = itLastStolenVoice;
775 ++itOldestVoice;
776 }
777 else { // no voice stolen in this audio fragment cycle yet
778 itOldestVoice = pOldestKey->pActiveVoices->first();
779 }
780 if (itOldestVoice) {
781 iuiOldestKey = pOldestKey->itSelf;
782 break; // selection succeeded
783 }
784 } // no break - intentional !
785
786 // try to pick the oldest voice on the oldest active key
787 // (caution: must stay after 'keymask' algorithm !)
788 case voice_steal_algo_oldestkey: {
789 if (itLastStolenVoice) {
790 midi_key_info_t* pOldestKey = &pMIDIKeyInfo[*iuiLastStolenKey];
791 itOldestVoice = itLastStolenVoice;
792 ++itOldestVoice;
793 if (!itOldestVoice) {
794 iuiOldestKey = iuiLastStolenKey;
795 ++iuiOldestKey;
796 if (iuiOldestKey) {
797 midi_key_info_t* pOldestKey = &pMIDIKeyInfo[*iuiOldestKey];
798 itOldestVoice = pOldestKey->pActiveVoices->first();
799 }
800 else {
801 dmsg(1,("gig::Engine: Warning, too less voices, even for voice stealing! - Better recompile with higher MAX_AUDIO_VOICES.\n"));
802 return;
803 }
804 }
805 else iuiOldestKey = iuiLastStolenKey;
806 }
807 else { // no voice stolen in this audio fragment cycle yet
808 iuiOldestKey = pActiveKeys->first();
809 midi_key_info_t* pOldestKey = &pMIDIKeyInfo[*iuiOldestKey];
810 itOldestVoice = pOldestKey->pActiveVoices->first();
811 }
812 break;
813 }
814
815 // don't steal anything
816 case voice_steal_algo_none:
817 default: {
818 dmsg(1,("No free voice (voice stealing disabled)!\n"));
819 return;
820 }
821 }
822
823 // now kill the selected voice
824 itOldestVoice->Kill(itNoteOnEvent);
825 // remember which voice on which key we stole, so we can simply proceed for the next voice stealing
826 this->itLastStolenVoice = itOldestVoice;
827 this->iuiLastStolenKey = iuiOldestKey;
828 }
829 else dmsg(1,("Event pool emtpy!\n"));
830 }
831
832 /**
833 * Removes the given voice from the MIDI key's list of active voices.
834 * This method will be called when a voice went inactive, e.g. because
835 * it finished to playback its sample, finished its release stage or
836 * just was killed.
837 *
838 * @param itVoice - points to the voice to be freed
839 */
840 void Engine::FreeVoice(Pool<Voice>::Iterator& itVoice) {
841 if (itVoice) {
842 midi_key_info_t* pKey = &pMIDIKeyInfo[itVoice->MIDIKey];
843
844 uint keygroup = itVoice->KeyGroup;
845
846 // free the voice object
847 pVoicePool->free(itVoice);
848
849 // check if there are no voices left on the MIDI key and update the key info if so
850 if (pKey->pActiveVoices->isEmpty()) {
851 if (keygroup) { // if voice / key belongs to a key group
852 uint** ppKeyGroup = &ActiveKeyGroups[keygroup];
853 if (*ppKeyGroup == &*pKey->itSelf) *ppKeyGroup = NULL; // remove key from key group
854 }
855 pKey->Active = false;
856 pActiveKeys->free(pKey->itSelf); // remove key from list of active keys
857 pKey->itSelf = RTList<uint>::Iterator();
858 pKey->ReleaseTrigger = false;
859 pKey->pEvents->clear();
860 dmsg(3,("Key has no more voices now\n"));
861 }
862 }
863 else std::cerr << "Couldn't release voice! (!itVoice)\n" << std::flush;
864 }
865
866 /**
867 * Reacts on supported control change commands (e.g. pitch bend wheel,
868 * modulation wheel, aftertouch).
869 *
870 * @param itControlChangeEvent - controller, value and time stamp of the event
871 */
872 void Engine::ProcessControlChange(Pool<Event>::Iterator& itControlChangeEvent) {
873 dmsg(4,("Engine::ContinuousController cc=%d v=%d\n", itControlChangeEvent->Param.CC.Controller, itControlChangeEvent->Param.CC.Value));
874
875 switch (itControlChangeEvent->Param.CC.Controller) {
876 case 64: {
877 if (itControlChangeEvent->Param.CC.Value >= 64 && !SustainPedal) {
878 dmsg(4,("PEDAL DOWN\n"));
879 SustainPedal = true;
880
881 // cancel release process of voices if necessary
882 RTList<uint>::Iterator iuiKey = pActiveKeys->first();
883 if (iuiKey) {
884 itControlChangeEvent->Type = Event::type_cancel_release; // transform event type
885 while (iuiKey) {
886 midi_key_info_t* pKey = &pMIDIKeyInfo[*iuiKey];
887 ++iuiKey;
888 if (!pKey->KeyPressed) {
889 RTList<Event>::Iterator itNewEvent = pKey->pEvents->allocAppend();
890 if (itNewEvent) *itNewEvent = *itControlChangeEvent; // copy event to the key's own event list
891 else dmsg(1,("Event pool emtpy!\n"));
892 }
893 }
894 }
895 }
896 if (itControlChangeEvent->Param.CC.Value < 64 && SustainPedal) {
897 dmsg(4,("PEDAL UP\n"));
898 SustainPedal = false;
899
900 // release voices if their respective key is not pressed
901 RTList<uint>::Iterator iuiKey = pActiveKeys->first();
902 if (iuiKey) {
903 itControlChangeEvent->Type = Event::type_release; // transform event type
904 while (iuiKey) {
905 midi_key_info_t* pKey = &pMIDIKeyInfo[*iuiKey];
906 ++iuiKey;
907 if (!pKey->KeyPressed) {
908 RTList<Event>::Iterator itNewEvent = pKey->pEvents->allocAppend();
909 if (itNewEvent) *itNewEvent = *itControlChangeEvent; // copy event to the key's own event list
910 else dmsg(1,("Event pool emtpy!\n"));
911 }
912 }
913 }
914 }
915 break;
916 }
917 }
918
919 // update controller value in the engine's controller table
920 ControllerTable[itControlChangeEvent->Param.CC.Controller] = itControlChangeEvent->Param.CC.Value;
921
922 // move event from the unsorted event list to the control change event list
923 itControlChangeEvent.moveToEndOf(pCCEvents);
924 }
925
926 /**
927 * Reacts on MIDI system exclusive messages.
928 *
929 * @param itSysexEvent - sysex data size and time stamp of the sysex event
930 */
931 void Engine::ProcessSysex(Pool<Event>::Iterator& itSysexEvent) {
932 RingBuffer<uint8_t>::NonVolatileReader reader = pSysexBuffer->get_non_volatile_reader();
933
934 uint8_t exclusive_status, id;
935 if (!reader.pop(&exclusive_status)) goto free_sysex_data;
936 if (!reader.pop(&id)) goto free_sysex_data;
937 if (exclusive_status != 0xF0) goto free_sysex_data;
938
939 switch (id) {
940 case 0x41: { // Roland
941 uint8_t device_id, model_id, cmd_id;
942 if (!reader.pop(&device_id)) goto free_sysex_data;
943 if (!reader.pop(&model_id)) goto free_sysex_data;
944 if (!reader.pop(&cmd_id)) goto free_sysex_data;
945 if (model_id != 0x42 /*GS*/) goto free_sysex_data;
946 if (cmd_id != 0x12 /*DT1*/) goto free_sysex_data;
947
948 // command address
949 uint8_t addr[3]; // 2 byte addr MSB, followed by 1 byte addr LSB)
950 const RingBuffer<uint8_t>::NonVolatileReader checksum_reader = reader; // so we can calculate the check sum later
951 if (reader.read(&addr[0], 3) != 3) goto free_sysex_data;
952 if (addr[0] == 0x40 && addr[1] == 0x00) { // System Parameters
953 }
954 else if (addr[0] == 0x40 && addr[1] == 0x01) { // Common Parameters
955 }
956 else if (addr[0] == 0x40 && (addr[1] & 0xf0) == 0x10) { // Part Parameters (1)
957 switch (addr[3]) {
958 case 0x40: { // scale tuning
959 uint8_t scale_tunes[12]; // detuning of all 12 semitones of an octave
960 if (reader.read(&scale_tunes[0], 12) != 12) goto free_sysex_data;
961 uint8_t checksum;
962 if (!reader.pop(&checksum)) goto free_sysex_data;
963 if (GSCheckSum(checksum_reader, 12) != checksum) goto free_sysex_data;
964 for (int i = 0; i < 12; i++) scale_tunes[i] -= 64;
965 AdjustScale((int8_t*) scale_tunes);
966 break;
967 }
968 }
969 }
970 else if (addr[0] == 0x40 && (addr[1] & 0xf0) == 0x20) { // Part Parameters (2)
971 }
972 else if (addr[0] == 0x41) { // Drum Setup Parameters
973 }
974 break;
975 }
976 }
977
978 free_sysex_data: // finally free sysex data
979 pSysexBuffer->increment_read_ptr(itSysexEvent->Param.Sysex.Size);
980 }
981
982 /**
983 * Calculates the Roland GS sysex check sum.
984 *
985 * @param AddrReader - reader which currently points to the first GS
986 * command address byte of the GS sysex message in
987 * question
988 * @param DataSize - size of the GS message data (in bytes)
989 */
990 uint8_t Engine::GSCheckSum(const RingBuffer<uint8_t>::NonVolatileReader AddrReader, uint DataSize) {
991 RingBuffer<uint8_t>::NonVolatileReader reader = AddrReader;
992 uint bytes = 3 /*addr*/ + DataSize;
993 uint8_t addr_and_data[bytes];
994 reader.read(&addr_and_data[0], bytes);
995 uint8_t sum = 0;
996 for (uint i = 0; i < bytes; i++) sum += addr_and_data[i];
997 return 128 - sum % 128;
998 }
999
1000 /**
1001 * Allows to tune each of the twelve semitones of an octave.
1002 *
1003 * @param ScaleTunes - detuning of all twelve semitones (in cents)
1004 */
1005 void Engine::AdjustScale(int8_t ScaleTunes[12]) {
1006 memcpy(&this->ScaleTuning[0], &ScaleTunes[0], 12); //TODO: currently not sample accurate
1007 }
1008
1009 /**
1010 * Initialize the parameter sequence for the modulation destination given by
1011 * by 'dst' with the constant value given by val.
1012 */
1013 void Engine::ResetSynthesisParameters(Event::destination_t dst, float val) {
1014 int maxsamples = pAudioOutputDevice->MaxSamplesPerCycle();
1015 float* m = &pSynthesisParameters[dst][0];
1016 for (int i = 0; i < maxsamples; i += 4) {
1017 m[i] = val;
1018 m[i+1] = val;
1019 m[i+2] = val;
1020 m[i+3] = val;
1021 }
1022 }
1023
1024 float Engine::Volume() {
1025 return GlobalVolume;
1026 }
1027
1028 void Engine::Volume(float f) {
1029 GlobalVolume = f;
1030 }
1031
1032 uint Engine::Channels() {
1033 return 2;
1034 }
1035
1036 void Engine::SetOutputChannel(uint EngineAudioChannel, uint AudioDeviceChannel) {
1037 AudioChannel* pChannel = pAudioOutputDevice->Channel(AudioDeviceChannel);
1038 if (!pChannel) throw AudioOutputException("Invalid audio output device channel " + ToString(AudioDeviceChannel));
1039 switch (EngineAudioChannel) {
1040 case 0: // left output channel
1041 pOutputLeft = pChannel->Buffer();
1042 AudioDeviceChannelLeft = AudioDeviceChannel;
1043 break;
1044 case 1: // right output channel
1045 pOutputRight = pChannel->Buffer();
1046 AudioDeviceChannelRight = AudioDeviceChannel;
1047 break;
1048 default:
1049 throw AudioOutputException("Invalid engine audio channel " + ToString(EngineAudioChannel));
1050 }
1051 }
1052
1053 int Engine::OutputChannel(uint EngineAudioChannel) {
1054 switch (EngineAudioChannel) {
1055 case 0: // left channel
1056 return AudioDeviceChannelLeft;
1057 case 1: // right channel
1058 return AudioDeviceChannelRight;
1059 default:
1060 throw AudioOutputException("Invalid engine audio channel " + ToString(EngineAudioChannel));
1061 }
1062 }
1063
1064 uint Engine::VoiceCount() {
1065 return ActiveVoiceCount;
1066 }
1067
1068 uint Engine::VoiceCountMax() {
1069 return ActiveVoiceCountMax;
1070 }
1071
1072 bool Engine::DiskStreamSupported() {
1073 return true;
1074 }
1075
1076 uint Engine::DiskStreamCount() {
1077 return (pDiskThread) ? pDiskThread->ActiveStreamCount : 0;
1078 }
1079
1080 uint Engine::DiskStreamCountMax() {
1081 return (pDiskThread) ? pDiskThread->ActiveStreamCountMax : 0;
1082 }
1083
1084 String Engine::DiskStreamBufferFillBytes() {
1085 return pDiskThread->GetBufferFillBytes();
1086 }
1087
1088 String Engine::DiskStreamBufferFillPercentage() {
1089 return pDiskThread->GetBufferFillPercentage();
1090 }
1091
1092 String Engine::EngineName() {
1093 return "GigEngine";
1094 }
1095
1096 String Engine::InstrumentFileName() {
1097 return InstrumentFile;
1098 }
1099
1100 int Engine::InstrumentIndex() {
1101 return InstrumentIdx;
1102 }
1103
1104 int Engine::InstrumentStatus() {
1105 return InstrumentStat;
1106 }
1107
1108 String Engine::Description() {
1109 return "Gigasampler Engine";
1110 }
1111
1112 String Engine::Version() {
1113 String s = "$Revision: 1.16 $";
1114 return s.substr(11, s.size() - 13); // cut dollar signs, spaces and CVS macro keyword
1115 }
1116
1117 }} // namespace LinuxSampler::gig

  ViewVC Help
Powered by ViewVC