2013-12-08 22:44:43 +01:00
|
|
|
/*
|
|
|
|
* Author: Harry van Haaren 2013
|
|
|
|
* harryhaaren@gmail.com
|
|
|
|
*
|
|
|
|
* This program is free software: you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
*/
|
2013-04-20 12:37:36 +02:00
|
|
|
|
|
|
|
#ifndef LUPPP_EVENT_HANDLER_DSP_H
|
|
|
|
#define LUPPP_EVENT_HANDLER_DSP_H
|
|
|
|
|
|
|
|
|
|
|
|
// Library
|
|
|
|
#include <cstring>
|
|
|
|
#include <iostream>
|
|
|
|
#include <jack/ringbuffer.h>
|
|
|
|
|
|
|
|
// Internal
|
|
|
|
#include "jack.hxx"
|
|
|
|
#include "event.hxx"
|
2013-10-01 17:04:59 +02:00
|
|
|
#include "controller/controller.hxx"
|
2013-11-19 22:51:20 +01:00
|
|
|
#include "controller/genericmidi.hxx"
|
2013-04-20 12:37:36 +02:00
|
|
|
#include "eventhandler.hxx"
|
|
|
|
|
2013-08-05 14:56:38 +02:00
|
|
|
#include "logic.hxx"
|
2013-10-12 14:19:37 +02:00
|
|
|
#include "state/state.hxx"
|
|
|
|
#include "timemanager.hxx"
|
|
|
|
#include "controllerupdater.hxx"
|
2013-08-05 14:56:38 +02:00
|
|
|
|
2013-04-20 12:37:36 +02:00
|
|
|
using namespace std;
|
|
|
|
|
|
|
|
extern Jack* jack;
|
|
|
|
|
2013-04-20 12:54:16 +02:00
|
|
|
void handleDspEvents()
|
2013-04-20 12:37:36 +02:00
|
|
|
{
|
|
|
|
uint availableRead = jack_ringbuffer_read_space( rbToDsp );
|
|
|
|
|
|
|
|
while ( availableRead >= sizeof(EventBase) )
|
|
|
|
{
|
|
|
|
jack_ringbuffer_peek( rbToDsp, (char*)processDspMem, sizeof(EventBase) );
|
|
|
|
|
|
|
|
EventBase* e = (EventBase*)processDspMem;
|
|
|
|
|
|
|
|
// recheck the size against the actual event size
|
|
|
|
if ( availableRead >= e->size() )
|
|
|
|
{
|
2013-10-18 02:06:34 +02:00
|
|
|
|
|
|
|
// MIDI binding creation: sample the Event.
|
|
|
|
if( jack->bindingEventRecordEnable )
|
|
|
|
{
|
2013-10-18 02:28:00 +02:00
|
|
|
//printf("event %i\n", e->type() );
|
2013-10-18 02:06:34 +02:00
|
|
|
jack->bindingEventType = e->type();
|
2013-10-18 15:33:00 +02:00
|
|
|
|
2013-10-18 15:50:28 +02:00
|
|
|
const char* target = e->name();
|
|
|
|
if ( target )
|
|
|
|
{
|
2013-10-18 17:52:04 +02:00
|
|
|
EventControllerBindingTarget event( target );
|
2013-10-18 15:50:28 +02:00
|
|
|
writeToGuiRingbuffer( &event );
|
|
|
|
}
|
2013-10-18 02:06:34 +02:00
|
|
|
}
|
|
|
|
|
2013-04-20 12:37:36 +02:00
|
|
|
switch ( e->type() )
|
|
|
|
{
|
2013-09-21 00:28:59 +02:00
|
|
|
case Event::QUIT: {
|
|
|
|
if ( availableRead >= sizeof(EventQuit) ) {
|
|
|
|
EventQuit ev;
|
|
|
|
jack_ringbuffer_read( rbToDsp, (char*)&ev, sizeof(EventQuit) );
|
|
|
|
jack->quit();
|
2013-09-21 01:52:29 +02:00
|
|
|
// we want to *quit* *fast*: remaining events don't matter!
|
|
|
|
return;
|
|
|
|
|
2013-09-21 00:28:59 +02:00
|
|
|
} break; }
|
|
|
|
|
|
|
|
// ========= SAVE =====
|
2013-09-06 01:28:11 +02:00
|
|
|
case Event::STATE_SAVE: {
|
|
|
|
if ( availableRead >= sizeof(EventStateSave) ) {
|
|
|
|
EventStateSave ev;
|
|
|
|
jack_ringbuffer_read( rbToDsp, (char*)&ev, sizeof(EventStateSave) );
|
|
|
|
jack->getState()->save();
|
2013-09-03 19:05:57 +02:00
|
|
|
} break; }
|
2013-09-06 01:28:11 +02:00
|
|
|
case Event::STATE_RESET: {
|
|
|
|
if ( availableRead >= sizeof(EventStateReset) ) {
|
|
|
|
EventStateReset ev;
|
|
|
|
jack_ringbuffer_read( rbToDsp, (char*)&ev, sizeof(EventStateReset) );
|
|
|
|
jack->getState()->reset();
|
2013-09-06 01:10:33 +02:00
|
|
|
} break; }
|
2013-09-03 19:05:57 +02:00
|
|
|
|
2013-09-20 11:29:05 +02:00
|
|
|
// ========= MASTER ===
|
2013-04-20 12:37:36 +02:00
|
|
|
case Event::MASTER_VOL: {
|
|
|
|
if ( availableRead >= sizeof(EventMasterVol) ) {
|
|
|
|
EventMasterVol ev(0);
|
|
|
|
jack_ringbuffer_read( rbToDsp, (char*)&ev, sizeof(EventMasterVol) );
|
2013-09-20 11:29:05 +02:00
|
|
|
jack->masterVolume( ev.vol );
|
|
|
|
} break; }
|
|
|
|
case Event::MASTER_RETURN: {
|
|
|
|
if ( availableRead >= sizeof(EventMasterReturn) ) {
|
|
|
|
EventMasterReturn ev;
|
|
|
|
jack_ringbuffer_read( rbToDsp, (char*)&ev, sizeof(EventMasterReturn) );
|
2013-10-07 16:21:24 +02:00
|
|
|
if ( ev.ret == RETURN_MAIN ) {
|
2013-11-21 15:11:06 +01:00
|
|
|
jack->returnVolume( ev.vol );
|
2013-10-07 16:21:24 +02:00
|
|
|
}
|
2013-04-20 12:37:36 +02:00
|
|
|
} break; }
|
2013-09-20 14:11:47 +02:00
|
|
|
case Event::MASTER_INPUT_VOL: {
|
|
|
|
if ( availableRead >= sizeof(EventMasterVol) ) {
|
|
|
|
EventMasterVol ev(0);
|
|
|
|
jack_ringbuffer_read( rbToDsp, (char*)&ev, sizeof(EventMasterVol) );
|
|
|
|
jack->getLogic()->masterInputVol( ev.vol );
|
|
|
|
} break; }
|
2013-09-20 13:40:50 +02:00
|
|
|
case Event::MASTER_INPUT_TO: {
|
|
|
|
if ( availableRead >= sizeof(EventMasterInputTo) ) {
|
|
|
|
EventMasterInputTo ev;
|
|
|
|
jack_ringbuffer_read( rbToDsp, (char*)&ev, sizeof(EventMasterInputTo) );
|
2013-11-09 23:11:45 +01:00
|
|
|
jack->bindingSend = ev.place;
|
2013-09-20 13:40:50 +02:00
|
|
|
jack->getLogic()->masterInputTo( ev.place, ev.value );
|
|
|
|
} break; }
|
2013-09-20 14:02:27 +02:00
|
|
|
case Event::MASTER_INPUT_TO_ACTIVE: {
|
|
|
|
if ( availableRead >= sizeof(EventMasterInputToActive) ) {
|
|
|
|
EventMasterInputToActive ev;
|
|
|
|
jack_ringbuffer_read( rbToDsp, (char*)&ev, sizeof(EventMasterInputToActive) );
|
2013-11-09 23:11:45 +01:00
|
|
|
jack->bindingSend = ev.place;
|
|
|
|
jack->bindingActive = ev.active;
|
2013-09-20 14:02:27 +02:00
|
|
|
jack->getLogic()->masterInputToActive( ev.place, ev.active );
|
|
|
|
} break; }
|
2013-08-06 23:42:04 +02:00
|
|
|
|
|
|
|
// ========= GRID =====
|
2013-11-02 15:10:26 +01:00
|
|
|
case Event::GRID_STATE: {
|
|
|
|
if ( availableRead >= sizeof(EventGridState) ) {
|
|
|
|
EventGridState ev;
|
|
|
|
jack_ringbuffer_read( rbToDsp, (char*)&ev, sizeof(EventGridState) );
|
|
|
|
// clear clips in Controllers
|
|
|
|
if ( ev.state == GridLogic::STATE_EMPTY )
|
|
|
|
{
|
|
|
|
jack->getLooper( ev.track )->getClip( ev.scene )->init();
|
|
|
|
jack->getControllerUpdater()->setTrackSceneProgress(ev.track, ev.scene, 0 );
|
|
|
|
jack->getControllerUpdater()->setSceneState( ev.track, ev.scene, GridLogic::STATE_EMPTY );
|
|
|
|
}
|
|
|
|
} break; }
|
|
|
|
|
2013-08-06 23:42:04 +02:00
|
|
|
case Event::GRID_EVENT: {
|
|
|
|
if ( availableRead >= sizeof(EventGridEvent) ) {
|
|
|
|
EventGridEvent ev;
|
|
|
|
jack_ringbuffer_read( rbToDsp, (char*)&ev, sizeof(EventGridEvent) );
|
2013-10-18 02:28:00 +02:00
|
|
|
jack->bindingTrack = ev.track;
|
|
|
|
jack->bindingScene = ev.scene;
|
2013-08-06 23:42:04 +02:00
|
|
|
if ( ev.pressed )
|
|
|
|
jack->getGridLogic()->pressed( ev.track, ev.scene );
|
|
|
|
else
|
|
|
|
jack->getGridLogic()->released( ev.track, ev.scene );
|
|
|
|
} break; }
|
|
|
|
|
2013-08-22 06:48:59 +02:00
|
|
|
case Event::GRID_LAUNCH_SCENE: {
|
|
|
|
EventGridLaunchScene ev;
|
|
|
|
jack_ringbuffer_read( rbToDsp, (char*)&ev, sizeof(EventGridLaunchScene) );
|
|
|
|
jack->getGridLogic()->launchScene( ev.scene );
|
2013-10-18 02:28:00 +02:00
|
|
|
jack->bindingScene = ev.scene;
|
2013-08-22 06:48:59 +02:00
|
|
|
break; }
|
|
|
|
|
2013-10-08 23:32:25 +02:00
|
|
|
case Event::GRID_SELECT_CLIP_ENABLE: {
|
|
|
|
EventGridSelectClipEnable ev;
|
|
|
|
jack_ringbuffer_read( rbToDsp, (char*)&ev, sizeof(EventGridSelectClipEnable) );
|
|
|
|
jack->getGridLogic()->setSelectTrackScene( ev.enable );
|
2013-10-08 22:53:41 +02:00
|
|
|
break; }
|
|
|
|
case Event::GRID_SELECT_CLIP_EVENT: {
|
|
|
|
EventGridSelectClipEvent ev;
|
|
|
|
jack_ringbuffer_read( rbToDsp, (char*)&ev, sizeof(EventGridSelectClipEvent) );
|
|
|
|
jack->getGridLogic()->selectedTrackSceneEvent( ev.pressed );
|
|
|
|
break; }
|
|
|
|
|
2013-12-04 14:50:08 +01:00
|
|
|
case Event::GRID_SELECT_NEW_CHOSEN: {
|
|
|
|
EventGridSelectNewChosen ev;
|
|
|
|
jack_ringbuffer_read( rbToDsp, (char*)&ev, sizeof(EventGridSelectNewChosen) );
|
|
|
|
jack->getGridLogic()->specialScene( ev.track, ev.scene );
|
|
|
|
break; }
|
|
|
|
|
|
|
|
|
2013-05-20 00:57:12 +02:00
|
|
|
case Event::LOOPER_LOAD: {
|
|
|
|
if ( availableRead >= sizeof(EventLooperLoad) ) {
|
|
|
|
EventLooperLoad ev;
|
2013-05-20 02:08:10 +02:00
|
|
|
jack_ringbuffer_read( rbToDsp, (char*)&ev, sizeof(EventLooperLoad) );
|
2013-08-22 01:05:00 +02:00
|
|
|
jack->getGridLogic()->load( ev.track, ev.clip, (AudioBuffer*)ev.audioBuffer );
|
2013-04-20 12:37:36 +02:00
|
|
|
} break; }
|
2013-05-16 00:27:31 +02:00
|
|
|
case Event::METRONOME_ACTIVE: {
|
|
|
|
if ( availableRead >= sizeof(EventMetronomeActive) ) {
|
|
|
|
EventMetronomeActive ev(false);
|
|
|
|
jack_ringbuffer_read( rbToDsp, (char*)&ev, sizeof(EventMetronomeActive) );
|
2013-09-18 11:09:26 +02:00
|
|
|
jack->getLogic()->metronomeEnable(ev.active);
|
2013-04-20 12:37:36 +02:00
|
|
|
} break; }
|
2013-05-13 23:04:12 +02:00
|
|
|
case Event::LOOPER_STATE: {
|
|
|
|
if ( availableRead >= sizeof(EventLooperState) ) {
|
|
|
|
EventLooperState ev;
|
|
|
|
jack_ringbuffer_read( rbToDsp, (char*)&ev, sizeof(EventLooperState) );
|
2013-07-27 19:24:04 +02:00
|
|
|
//jack->setLooperState( ev.track, ev.scene, ev.state );
|
2013-05-13 23:04:12 +02:00
|
|
|
} break; }
|
2013-05-16 02:38:11 +02:00
|
|
|
case Event::LOOPER_LOOP_LENGTH: {
|
|
|
|
if ( availableRead >= sizeof(EventLooperLoopLength) ) {
|
|
|
|
EventLooperLoopLength ev;
|
|
|
|
jack_ringbuffer_read( rbToDsp, (char*)&ev, sizeof(EventLooperLoopLength) );
|
2013-08-13 18:03:33 +02:00
|
|
|
jack->getLogic()->looperClipLenght( ev.track, ev.scene, ev.beats );
|
2013-05-16 02:38:11 +02:00
|
|
|
} break; }
|
2013-08-13 19:34:08 +02:00
|
|
|
|
|
|
|
|
|
|
|
case Event::LOOPER_LOOP_USE_AS_TEMPO: {
|
|
|
|
if ( availableRead >= sizeof(EventLooperUseAsTempo) ) {
|
|
|
|
EventLooperUseAsTempo ev;
|
|
|
|
jack_ringbuffer_read( rbToDsp, (char*)&ev, sizeof(EventLooperUseAsTempo) );
|
|
|
|
jack->getLogic()->looperUseAsTempo( ev.track, ev.scene );
|
|
|
|
} break; }
|
|
|
|
|
|
|
|
|
|
|
|
|
2013-05-16 18:16:18 +02:00
|
|
|
case Event::TIME_BPM: {
|
|
|
|
if ( availableRead >= sizeof(EventTimeBPM) ) {
|
|
|
|
EventTimeBPM ev;
|
|
|
|
jack_ringbuffer_read( rbToDsp, (char*)&ev, sizeof(EventTimeBPM) );
|
|
|
|
jack->getTimeManager()->setBpm(ev.bpm);
|
|
|
|
} break; }
|
2013-05-16 18:45:46 +02:00
|
|
|
case Event::TIME_TEMPO_TAP: {
|
|
|
|
if ( availableRead >= sizeof(EventTimeTempoTap) ) {
|
|
|
|
EventTimeTempoTap ev;
|
|
|
|
jack_ringbuffer_read( rbToDsp, (char*)&ev, sizeof(EventTimeTempoTap) );
|
|
|
|
jack->getTimeManager()->tap();
|
|
|
|
} break; }
|
2013-07-28 15:56:34 +02:00
|
|
|
|
2013-07-31 12:34:28 +02:00
|
|
|
// ======== FX ===========
|
2013-09-20 12:23:59 +02:00
|
|
|
|
|
|
|
case Event::FX_REVERB: break;
|
|
|
|
/*{
|
2013-07-31 12:34:28 +02:00
|
|
|
if ( availableRead >= sizeof(EventFxReverb) ) {
|
|
|
|
EventFxReverb ev;
|
|
|
|
jack_ringbuffer_read( rbToDsp, (char*)&ev, sizeof(EventFxReverb) );
|
2013-09-11 02:32:58 +02:00
|
|
|
// TODO implement reverb
|
2013-07-31 12:34:28 +02:00
|
|
|
break; }
|
|
|
|
}
|
2013-09-20 12:23:59 +02:00
|
|
|
*/
|
2013-07-28 17:00:17 +02:00
|
|
|
case Event::TRACK_VOLUME: {
|
|
|
|
if ( availableRead >= sizeof(EventTrackVol) ) {
|
|
|
|
EventTrackVol ev;
|
|
|
|
jack_ringbuffer_read( rbToDsp, (char*)&ev, sizeof(EventTrackVol) );
|
2013-08-05 14:56:38 +02:00
|
|
|
jack->getLogic()->trackVolume( ev.track, ev.vol );
|
2013-10-18 02:28:00 +02:00
|
|
|
jack->bindingTrack = ev.track;
|
2013-07-28 17:00:17 +02:00
|
|
|
break; }
|
|
|
|
}
|
2013-09-23 13:51:41 +02:00
|
|
|
|
|
|
|
case Event::TRACK_RECORD_ARM: {
|
|
|
|
if ( availableRead >= sizeof(EventTrackRecordArm) ) {
|
|
|
|
EventTrackRecordArm ev;
|
|
|
|
jack_ringbuffer_read( rbToDsp, (char*)&ev, sizeof(EventTrackRecordArm) );
|
|
|
|
jack->getLogic()->trackRecordArm( ev.track, ev.recordArm );
|
2013-10-18 02:28:00 +02:00
|
|
|
jack->bindingTrack = ev.track;
|
|
|
|
jack->bindingActive = ev.recordArm;
|
2013-09-23 13:51:41 +02:00
|
|
|
break; }
|
|
|
|
}
|
2013-09-20 13:40:50 +02:00
|
|
|
|
2013-09-23 16:23:48 +02:00
|
|
|
case Event::TRACK_SEND_ACTIVE: {
|
|
|
|
if ( availableRead >= sizeof(EventTrackSendActive) ) {
|
|
|
|
EventTrackSendActive ev;
|
|
|
|
jack_ringbuffer_read( rbToDsp, (char*)&ev, sizeof(EventTrackSendActive) );
|
|
|
|
jack->getLogic()->trackSendActive( ev.track, ev.send, ev.active );
|
2013-10-18 02:28:00 +02:00
|
|
|
jack->bindingTrack = ev.track;
|
2013-11-21 15:43:22 +01:00
|
|
|
jack->bindingSend = ev.send;
|
2013-10-18 02:28:00 +02:00
|
|
|
jack->bindingActive = ev.active;
|
2013-09-23 16:23:48 +02:00
|
|
|
} break; }
|
|
|
|
|
2013-07-28 15:56:34 +02:00
|
|
|
case Event::TRACK_SEND: {
|
|
|
|
if ( availableRead >= sizeof(EventTrackSend) ) {
|
|
|
|
EventTrackSend ev;
|
|
|
|
jack_ringbuffer_read( rbToDsp, (char*)&ev, sizeof(EventTrackSend) );
|
2013-08-05 14:56:38 +02:00
|
|
|
jack->getLogic()->trackSend( ev.track, ev.send, ev.value );
|
2013-10-18 02:28:00 +02:00
|
|
|
jack->bindingTrack = ev.track;
|
|
|
|
jack->bindingSend = ev.send;
|
2013-07-28 15:56:34 +02:00
|
|
|
} break; }
|
2013-09-20 11:29:05 +02:00
|
|
|
|
2013-08-06 23:20:37 +02:00
|
|
|
|
|
|
|
// ========= LUPPP INTERNAL =====
|
|
|
|
case Event::LOOPER_REQUEST_BUFFER: {
|
|
|
|
if ( availableRead >= sizeof(EventLooperClipRequestBuffer) ) {
|
|
|
|
EventLooperClipRequestBuffer ev;
|
|
|
|
jack_ringbuffer_read( rbToDsp, (char*)&ev, sizeof(EventLooperClipRequestBuffer) );
|
|
|
|
jack->getLooper( ev.track )->setRequestedBuffer( ev.scene, ev.ab );
|
|
|
|
} break; }
|
|
|
|
|
2013-09-03 20:35:02 +02:00
|
|
|
case Event::REQUEST_SAVE_BUFFER: {
|
|
|
|
if ( availableRead >= sizeof(EventRequestSaveBuffer) ) {
|
|
|
|
EventRequestSaveBuffer ev;
|
|
|
|
jack_ringbuffer_read( rbToDsp, (char*)&ev, sizeof(EventRequestSaveBuffer) );
|
|
|
|
jack->getLooper( ev.track )->getClip(ev.scene)->recieveSaveBuffer( ev.ab );
|
|
|
|
} break; }
|
|
|
|
|
2013-10-01 17:04:59 +02:00
|
|
|
case Event::CONTROLLER_INSTANCE: {
|
|
|
|
if ( availableRead >= sizeof(EventControllerInstance) ) {
|
|
|
|
EventControllerInstance ev;
|
|
|
|
jack_ringbuffer_read( rbToDsp, (char*)&ev, sizeof(EventControllerInstance) );
|
2013-10-02 03:40:44 +02:00
|
|
|
jack->getControllerUpdater()->registerController( static_cast<Controller*>(ev.controller) );
|
2013-10-01 17:04:59 +02:00
|
|
|
} break; }
|
|
|
|
|
2013-11-10 21:13:41 +01:00
|
|
|
case Event::CONTROLLER_INSTANCE_REMOVE: {
|
|
|
|
if ( availableRead >= sizeof(EventControllerInstanceRemove) ) {
|
|
|
|
EventControllerInstanceRemove ev;
|
|
|
|
jack_ringbuffer_read( rbToDsp, (char*)&ev, sizeof(EventControllerInstanceRemove) );
|
|
|
|
|
|
|
|
jack->getControllerUpdater()->removeController( ev.ID );
|
|
|
|
} break; }
|
|
|
|
|
2013-10-18 17:52:04 +02:00
|
|
|
case Event::CONTROLLER_BINDING_ENABLE: {
|
|
|
|
if ( availableRead >= sizeof(EventControllerBindingEnable) ) {
|
|
|
|
EventControllerBindingEnable ev;
|
|
|
|
jack_ringbuffer_read( rbToDsp, (char*)&ev, sizeof(EventControllerBindingEnable) );
|
2013-10-18 02:28:00 +02:00
|
|
|
jack->bindingEventRecordEnable = ev.enable;
|
|
|
|
} break; }
|
|
|
|
|
2013-11-19 22:51:20 +01:00
|
|
|
|
|
|
|
case Event::CONTROLLER_BINDING_REMOVE: {
|
|
|
|
if ( availableRead >= sizeof(EventControllerBindingRemove) ) {
|
|
|
|
EventControllerBindingRemove ev;
|
|
|
|
jack_ringbuffer_read( rbToDsp, (char*)&ev, sizeof(EventControllerBindingRemove) );
|
|
|
|
// get Controller* from controllerID
|
|
|
|
Controller* c =jack->getControllerUpdater()->getController(ev.controllerID);
|
|
|
|
// dynamic cast to check for GenericMIDI controller
|
|
|
|
GenericMIDI* g = dynamic_cast<GenericMIDI*>(c);
|
|
|
|
if ( g )
|
|
|
|
{
|
|
|
|
// kick out BindingID
|
|
|
|
g->removeBinding( ev.bindingID );
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
// GUI print notify of error removing binding
|
|
|
|
}
|
|
|
|
} break; }
|
|
|
|
|
2013-10-19 13:54:26 +02:00
|
|
|
case Event::CONTROLLER_INSTANCE_GET_TO_WRITE: {
|
|
|
|
if ( availableRead >= sizeof(EventControllerInstanceGetToWrite) ) {
|
|
|
|
EventControllerInstanceGetToWrite ev;
|
|
|
|
jack_ringbuffer_read( rbToDsp, (char*)&ev, sizeof(EventControllerInstanceGetToWrite) );
|
2013-11-10 23:26:08 +01:00
|
|
|
|
2013-10-19 13:54:26 +02:00
|
|
|
// get the corresponding Controller with ID, and return it
|
2013-11-10 21:13:41 +01:00
|
|
|
|
2013-10-19 13:54:26 +02:00
|
|
|
Controller* c = jack->getControllerUpdater()->getController( ev.ID );
|
2013-11-10 21:13:41 +01:00
|
|
|
|
|
|
|
cout << "controller instance get to write id " << ev.ID << endl;
|
|
|
|
|
2013-10-19 13:54:26 +02:00
|
|
|
EventControllerInstanceGetToWrite tmp( ev.ID, c );
|
|
|
|
writeToGuiRingbuffer( &tmp );
|
|
|
|
} break; }
|
|
|
|
|
2013-04-20 12:37:36 +02:00
|
|
|
default:
|
|
|
|
{
|
2013-07-28 17:00:17 +02:00
|
|
|
cout << "DSP: Unkown message!! Will clog ringbuffer" << endl;
|
2013-04-20 12:37:36 +02:00
|
|
|
// just do nothing
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
// next call will get the half-written event
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// update available read, and loop over events
|
|
|
|
availableRead = jack_ringbuffer_read_space( rbToDsp );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void writeToDspRingbuffer(EventBase* e)
|
|
|
|
{
|
|
|
|
if ( jack_ringbuffer_write_space(rbToDsp) >= e->size() )
|
|
|
|
{
|
|
|
|
jack_ringbuffer_write( rbToDsp, (const char*)e, e->size() );
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2013-11-02 00:31:18 +01:00
|
|
|
// non-RT context, printing is OK!
|
2013-04-20 12:37:36 +02:00
|
|
|
cout << "->DSP ringbuffer full!" << endl;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif // LUPPP_EVENT_HANDLER_DSP_H
|
|
|
|
|