diff options
Diffstat (limited to 'attic/muse_qt4_evolution/synti/simpledrums')
15 files changed, 4689 insertions, 0 deletions
diff --git a/attic/muse_qt4_evolution/synti/simpledrums/CMakeLists.txt b/attic/muse_qt4_evolution/synti/simpledrums/CMakeLists.txt new file mode 100644 index 00000000..b29bab02 --- /dev/null +++ b/attic/muse_qt4_evolution/synti/simpledrums/CMakeLists.txt @@ -0,0 +1,52 @@ +#============================================================================= +# MusE +# Linux Music Editor +# $Id:$ +# +# Copyright (C) 2002-2006 by Werner Schweer and others +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License version 2. +# +# 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, write to the Free Software +# Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. +#============================================================================= + +QT4_WRAP_CPP ( simpledrums_mocs simpledrumsgui.h ssplugingui.h ) +QT4_WRAP_UI ( simpledrums_uis simpledrumsguibase.ui sspluginchooserbase.ui ) + +add_library ( simpledrums SHARED + simpledrums.cpp + simpledrumsgui.cpp + simpledrums.h + ssplugin.cpp + ssplugingui.cpp + ssplugin.h + common.h + ${simpledrums_mocs} + ${simpledrums_uis} + ) + +# - tell cmake to name target simpledrums.so instead of +# libsimpledrums.so +# - use precompiled header files +# +set_target_properties ( simpledrums + PROPERTIES PREFIX "" + COMPILE_FLAGS "-O6 -include ${PROJECT_BINARY_DIR}/all-pic.h" + ) + +target_link_libraries(simpledrums + synti +# awl + ${QT_LIBRARIES} + ) + +install_targets ( /${CMAKE_INSTALL_LIBDIR}/${MusE_INSTALL_NAME}/synthi/ simpledrums ) + diff --git a/attic/muse_qt4_evolution/synti/simpledrums/COPYING b/attic/muse_qt4_evolution/synti/simpledrums/COPYING new file mode 100644 index 00000000..5c3cefc2 --- /dev/null +++ b/attic/muse_qt4_evolution/synti/simpledrums/COPYING @@ -0,0 +1,3 @@ +COPYING +--------------------------------------- +This software is licensed under GNU GPL. diff --git a/attic/muse_qt4_evolution/synti/simpledrums/README b/attic/muse_qt4_evolution/synti/simpledrums/README new file mode 100644 index 00000000..468640b1 --- /dev/null +++ b/attic/muse_qt4_evolution/synti/simpledrums/README @@ -0,0 +1,43 @@ +-------------------------------------- +Simpledrums v 0.2, by Mathias Lundgren +-------------------------------------- + +Simpledrums is a simple MESS-synth sampler (MusE Experimental Soft +Synth) aiming at becoming a simple, tightly integrated sampler for +MusE, specifically aimed at drumsamples. + +Features: +- 16 channels/samples (1 sample/channel) +- Simple controls for each individual channel: volume, balance, noteoff-ignore, channel on/off +- Main volume +- 4 LADSPA send-effects can be used, 4 effect taps for each individual channel +- All channel parameters are controllable via the GUI, or by MusE:s controller handling (controller pane in pianoroll/drumeditor) +- All effect parameters can be controlled via the GUI, or by Sysex messages (f.ex. turn effect on/off, modify effect parameters) +- Complete synth state (fx-parameters, samples etc) is saved together with MusE project, and restored later when loaded +- Samples automatically resampled when loaded (if needed) + +That's all folks! + +------------- +Known issues: +------------- +- Not the prettiest gui in the world +- All samples are read directly into memory (no caching) +- Some obscure LADSPA-effects make SimpleSynth segfault +- More... + +------------- +Future plans: +------------- +- Fix all the known issues! ;-) +- Sample loops +- Sample offset variation w respect to note velocity +- Treble/eq-controller for each individual channel +- Treble level variation w respect to note velocity +- More... + +Mathias Lundgren, (lunar_shuttle@users.sourceforge.net), 2004 +Plugin management code based on Werner Schweers plugin management handling for MusE + +(C) Copyright Mathias Lundgren, Werner Schweer 2000-2004 +Licensed under the GNU General Public License diff --git a/attic/muse_qt4_evolution/synti/simpledrums/ReleaseNotes.txt b/attic/muse_qt4_evolution/synti/simpledrums/ReleaseNotes.txt new file mode 100644 index 00000000..e0d633d8 --- /dev/null +++ b/attic/muse_qt4_evolution/synti/simpledrums/ReleaseNotes.txt @@ -0,0 +1,18 @@ +RELEASE NOTES: +-------------- +????-??-?? ver 0.2 +- Support for 4 LADSPA sendeffects added +- Resampling of samples when loading (libsamplerate) +- Synth state is saved to/restored from project file +- Channel settings: balance, volume, effect tap for each sendeffect +- Effect settings: all LADSPA parameters controllable and saved to MusE project, effect master volume, effect on/off +- Support for mono + stereo samples +- Support for stereo + mono LADSPA effects +- Bugfixes, GUI-improvements etc... + +2004-11-09 ver 0.1 +- Simpledrums initial release +- 16 channels (1 sample for each channel) with parameters: volume, balance, noteoff-ignore + +(C) Copyright Mathias Lundgren, Werner Schweer 2000-2004 +Licensed under the GNU General Public License diff --git a/attic/muse_qt4_evolution/synti/simpledrums/common.h b/attic/muse_qt4_evolution/synti/simpledrums/common.h new file mode 100644 index 00000000..e4763540 --- /dev/null +++ b/attic/muse_qt4_evolution/synti/simpledrums/common.h @@ -0,0 +1,110 @@ +// +// C++ Interface: common +// +// Description: +// +// +// Author: Mathias Lundgren <lunar_shuttle@users.sf.net>, (C) 2004 +// +// Copyright: See COPYING file that comes with this distribution +// +// +#ifndef __MUSE_TESTO_COMMON_H__ +#define __MUSE_TESTO_COMMON_H__ + +#include "muse/midictrl.h" + +#define SS_VERSIONSTRING "1.0" + +#define SS_DEBUG 0 +#define SS_DEBUG_INIT 0 +#define SS_TRACE_FUNC 0 +#define SS_DEBUG_MIDI 0 +#define SS_DEBUG_LADSPA 0 +#define SS_DEBUG_STATE 0 + +#define SS_DBG(string) if (SS_DEBUG) fprintf(stderr, "%s:%d:%s: %s\n", __FILE__ , __LINE__ , __PRETTY_FUNCTION__, string); +#define SS_DBG2(string1, string2) if (SS_DEBUG) fprintf(stderr, "%s:%d:%s: %s: %s\n", __FILE__ , __LINE__ , __PRETTY_FUNCTION__, string1, string2); +#define SS_DBG_I(string1, int) if (SS_DEBUG) fprintf(stderr, "%s:%d:%s: %s: %d\n", __FILE__ , __LINE__ , __PRETTY_FUNCTION__, string1, int); + +#define SS_TRACE_IN if (SS_TRACE_FUNC) fprintf (stderr, "->%s:%d\n", __PRETTY_FUNCTION__, __LINE__); +#define SS_TRACE_OUT if (SS_TRACE_FUNC) fprintf (stderr, "<-%s:%d\n", __PRETTY_FUNCTION__, __LINE__); +#define SS_ERROR(string) fprintf(stderr, "SimpleDrums error: %s\n", string) +#define SS_DBG_LADSPA(string1) if (SS_DEBUG_LADSPA) fprintf(stderr, "%s:%d:%s: %s\n", __FILE__ , __LINE__ , __PRETTY_FUNCTION__, string1); +#define SS_DBG_LADSPA2(string1, string2) if (SS_DEBUG_LADSPA) fprintf(stderr, "%s:%d:%s: %s: %s\n", __FILE__ , __LINE__ , __PRETTY_FUNCTION__, string1, string2); + +#define SS_SYSEX_INIT_DATA_VERSION 1 + +#define SS_NR_OF_CHANNELS 16 +#define SS_AUDIO_CHANNELS 2 +#define SS_NR_OF_SENDEFFECTS 4 + +// Controller-related: +#define SS_CHANNEL_CTRL_VOLUME 0 +#define SS_CHANNEL_CTRL_PAN 1 +#define SS_CHANNEL_CTRL_NOFF 2 +#define SS_CHANNEL_CTRL_ONOFF 3 +#define SS_CHANNEL_SENDFX1 4 +#define SS_CHANNEL_SENDFX2 5 +#define SS_CHANNEL_SENDFX3 6 +#define SS_CHANNEL_SENDFX4 7 + +#define SS_PLUGIN_RETURN 0 +#define SS_PLUGIN_ONOFF 1 + +#define SS_NR_OF_MASTER_CONTROLLERS 1 +#define SS_NR_OF_CHANNEL_CONTROLLERS 8 +#define SS_NR_OF_PLUGIN_CONTROLLERS 2 + +#define SS_NR_OF_CONTROLLERS (SS_NR_OF_MASTER_CONTROLLERS + (SS_NR_OF_CHANNELS * SS_NR_OF_CHANNEL_CONTROLLERS) + (SS_NR_OF_PLUGIN_CONTROLLERS*SS_NR_OF_SENDEFFECTS)) +#define SS_FIRST_MASTER_CONTROLLER CTRL_NRPN14_OFFSET +#define SS_FIRST_CHANNEL_CONTROLLER (SS_FIRST_MASTER_CONTROLLER + SS_NR_OF_MASTER_CONTROLLERS) +#define SS_LAST_MASTER_CONTROLLER (SS_FIRST_CHANNEL_CONTROLLER - 1) +#define SS_LAST_CHANNEL_CONTROLLER (SS_FIRST_CHANNEL_CONTROLLER -1 + (SS_NR_OF_CHANNEL_CONTROLLERS * SS_NR_OF_CHANNELS)) + +#define SS_FIRST_PLUGIN_CONTROLLER (SS_LAST_CHANNEL_CONTROLLER + 1) +#define SS_LAST_PLUGIN_CONTROLLER (SS_FIRST_PLUGIN_CONTROLLER -1 + SS_NR_OF_SENDEFFECTS*SS_NR_OF_PLUGIN_CONTROLLERS) + +#define SS_MASTER_CTRL_VOLUME SS_FIRST_MASTER_CONTROLLER + +#define SS_CHANNEL_VOLUME_CONTROLLER(int) (SS_FIRST_CHANNEL_CONTROLLER + (SS_NR_OF_CHANNEL_CONTROLLERS * int) + SS_CHANNEL_CTRL_VOLUME) +#define SS_CHANNEL_PAN_CONTROLLER(int) (SS_FIRST_CHANNEL_CONTROLLER + (SS_NR_OF_CHANNEL_CONTROLLERS * int) + SS_CHANNEL_CTRL_PAN) +#define SS_CHANNEL_NOFF_CONTROLLER(int) (SS_FIRST_CHANNEL_CONTROLLER + (SS_NR_OF_CHANNEL_CONTROLLERS * int) + SS_CHANNEL_CTRL_NOFF) +#define SS_CHANNEL_ONOFF_CONTROLLER(int) (SS_FIRST_CHANNEL_CONTROLLER + (SS_NR_OF_CHANNEL_CONTROLLERS * int) + SS_CHANNEL_CTRL_ONOFF) +#define SS_CHANNEL_SENDFX_CONTROLLER(int1,int2) (SS_FIRST_CHANNEL_CONTROLLER + (SS_NR_OF_CHANNEL_CONTROLLERS * int1) + SS_CHANNEL_SENDFX1 + int2) + +#define SS_PLUGIN_RETURNLEVEL_CONTROLLER(int) (SS_FIRST_PLUGIN_CONTROLLER + (int * SS_NR_OF_PLUGIN_CONTROLLERS)) +#define SS_PLUGIN_ONOFF_CONTROLLER(int) (SS_FIRST_PLUGIN_CONTROLLER + (int * SS_NR_OF_PLUGIN_CONTROLLERS) + 1) + +#define SS_LOWEST_NOTE 36 +#define SS_HIGHEST_NOTE (SS_LOWEST_NOTE + SS_NR_OF_CHANNELS) + +#define SS_PLUGIN_PARAM_MIN 0 +#define SS_PLUGIN_PARAM_MAX 127 + +typedef unsigned char byte; + +enum { + SS_SYSEX_LOAD_SAMPLE = 0, // gui -> synth: tell synth to load sample + SS_SYSEX_INIT_DATA, // synth reinitialization, the position of this (1) in the enum must not be changed since this value is written into proj file + SS_SYSEX_LOAD_SAMPLE_OK, // synth -> gui: tell gui sample loaded OK + SS_SYSEX_LOAD_SAMPLE_ERROR, // synth -> gui: tell gui sample ! loaded OK + SS_SYSEX_CLEAR_SAMPLE, // gui -> synth: tell synth to clear sample + SS_SYSEX_CLEAR_SAMPLE_OK, // synth->gui: confirm sample cleared OK + SS_SYSEX_LOAD_SENDEFFECT, // gui -> synth: tell synth to load laspa-effect + SS_SYSEX_LOAD_SENDEFFECT_OK,// synth->gui: plugin loaded ok + SS_SYSEX_LOAD_SENDEFFECT_ERROR, // synth->gui: plugin _not_ loaded ok + SS_SYSEX_CLEAR_SENDEFFECT, // gui->synth: clear plugin + SS_SYSEX_CLEAR_SENDEFFECT_OK,// synth->gui: plugin cleared + SS_SYSEX_SET_PLUGIN_PARAMETER, //gui->synth: set plugin parameter + SS_SYSEX_SET_PLUGIN_PARAMETER_OK, // synth->gui: set plugin parameter (update gui) + SS_SYSEX_ERRORMSG, // synth -> gui: general error message from synth + SS_SYSEX_GET_INIT_DATA, // gui->synth: request init data + SS_SYSEX_SEND_INIT_DATA // synth->gui: give gui init data + }; + +extern int SS_samplerate; +extern float SS_map_pluginparam2logdomain(int pluginparam_val); +extern int SS_map_logdomain2pluginparam(float pluginparam_log); +#endif + diff --git a/attic/muse_qt4_evolution/synti/simpledrums/simpledrums.cpp b/attic/muse_qt4_evolution/synti/simpledrums/simpledrums.cpp new file mode 100644 index 00000000..93be946d --- /dev/null +++ b/attic/muse_qt4_evolution/synti/simpledrums/simpledrums.cpp @@ -0,0 +1,1719 @@ +// +// C++ Implementation: simplesynth +// +// Description: +// +// +// Author: Mathias Lundgren <lunar_shuttle@users.sf.net>, (C) 2004 +// +// Copyright: See COPYING file that comes with this distribution +// +// + +#include "muse/midictrl.h" +#include "muse/midi.h" +#include "libsynti/midievent.h" +#include "simpledrums.h" +// #include <qstring.h> +#include <samplerate.h> + +const char* SimpleSynth::synth_state_descr[] = + { + "SS_INITIALIZING", + "SS_LOADING_SAMPLE", + "SS_CLEARING_SAMPLE", + "SS_RUNNING" + }; + +const char* SimpleSynth::channel_state_descr[] = + { + "SS_CHANNEL_INACTIVE", + "SS_SAMPLE_PLAYING" + }; + +#define SWITCH_SYNTH_STATE(state)\ +synth_state = state; \ +if (SS_DEBUG_STATE) \ + fprintf (stderr, "SS STATE: %s\n", SimpleSynth::synth_state_descr[state]); + +#define SWITCH_CHAN_STATE(ch, s)\ +channels[ch].state = s; \ +if (SS_DEBUG_STATE) \ + fprintf (stderr, "SS CHAN %d STATE: %s\n", ch, SimpleSynth::channel_state_descr[s]); + +#define SS_CHANNEL_VOLUME_QUOT 100.0 +#define SS_MASTER_VOLUME_QUOT 100.0 +int SS_samplerate; + +#define SS_LOG_MAX 0 +#define SS_LOG_MIN -10 +#define SS_LOG_OFFSET SS_LOG_MIN + + +// +// Map plugin parameter on domain [SS_PLUGIN_PARAM_MIN, SS_PLUGIN_PARAM_MAX] to domain [SS_LOG_MIN, SS_LOG_MAX] (log domain) +// +float SS_map_pluginparam2logdomain(int pluginparam_val) + { + float scale = (float) (SS_LOG_MAX - SS_LOG_MIN)/ (float) SS_PLUGIN_PARAM_MAX; + float scaled = (float) pluginparam_val * scale; + float mapped = scaled + SS_LOG_OFFSET; + return mapped; + } +// +// Map plugin parameter on domain to domain [SS_LOG_MIN, SS_LOG_MAX] to [SS_PLUGIN_PARAM_MIN, SS_PLUGIN_PARAM_MAX] (from log-> [0,127]) +// (inverse func to the above) +int SS_map_logdomain2pluginparam(float pluginparam_log) + { + float mapped = pluginparam_log - SS_LOG_OFFSET; + float scale = (float) SS_PLUGIN_PARAM_MAX / (float) (SS_LOG_MAX - SS_LOG_MIN); + int scaled = (int) round(mapped * scale); + return scaled; + } + +//--------------------------------------------------------- +// SimpleSynth +//--------------------------------------------------------- +SimpleSynth::SimpleSynth(int sr) + : Mess(SS_AUDIO_CHANNELS) + { + SS_TRACE_IN + SS_samplerate = sr; + SS_initPlugins(); + + simplesynth_ptr = this; + master_vol = 100.0 / SS_MASTER_VOLUME_QUOT; + master_vol_ctrlval = 100; + + //initialize + for (int i=0; i<SS_NR_OF_CHANNELS; i++) { + channels[i].sample = 0; + channels[i].playoffset = 0; + channels[i].noteoff_ignore = false; + channels[i].volume = (double) (100.0/SS_CHANNEL_VOLUME_QUOT ); + channels[i].volume_ctrlval = 100; + channels[i].pan = 64; + channels[i].balanceFactorL = 1.0; + channels[i].balanceFactorR = 1.0; + SWITCH_CHAN_STATE(i, SS_CHANNEL_INACTIVE); + channels[i].channel_on = false; + for (int j=0; j<SS_NR_OF_SENDEFFECTS; j++) { + channels[i].sendfxlevel[j] = 0.0; + } + } + + //Process buffer: + processBuffer[0] = new double[SS_PROCESS_BUFFER_SIZE]; //left + processBuffer[1] = new double[SS_PROCESS_BUFFER_SIZE]; //right + + //Send effects + for (int i=0; i<SS_NR_OF_SENDEFFECTS; i++) { + sendFxLineOut[i][0] = new float[SS_SENDFX_BUFFER_SIZE]; //left out + sendFxLineOut[i][1] = new float[SS_SENDFX_BUFFER_SIZE]; //right out + sendFxReturn[i][0] = new float[SS_SENDFX_BUFFER_SIZE]; //left in + sendFxReturn[i][1] = new float[SS_SENDFX_BUFFER_SIZE]; //right in + } + + for (int i=0; i<SS_NR_OF_SENDEFFECTS; i++) { + sendEffects[i].state = SS_SENDFX_OFF; + sendEffects[i].plugin = 0; + sendEffects[i].retgain = 1.0; + sendEffects[i].retgain_ctrlval = 100; + sendEffects[i].nrofparameters = 0; + } + + //Build controller list: + controllers[0].name = "Master volume"; + controllers[0].num = CTRL_NRPN14_OFFSET; + controllers[0].min = 0; + controllers[0].max = 127; + + int i=1; + for (int ch=0; ch<SS_NR_OF_CHANNELS; ch++) { + QString c1 = "Channel " + QString::number(ch + 1) + " volume"; + QString c2 = "Channel " + QString::number(ch + 1) + " pan"; + QString c3 = "Channel " + QString::number(ch + 1) + " noteoff ignore"; + QString c4 = "Channel " + QString::number(ch + 1) + " on/off"; + QString c5 = "Channel " + QString::number(ch + 1) + " fx send 1"; + QString c6 = "Channel " + QString::number(ch + 1) + " fx send 2"; + QString c7 = "Channel " + QString::number(ch + 1) + " fx send 3"; + QString c8 = "Channel " + QString::number(ch + 1) + " fx send 4"; + controllers[i].name = c1.toLatin1().data(); + controllers[i].num = CTRL_NRPN14_OFFSET+i; + controllers[i].min = 0; + controllers[i].max = 127; + + controllers[i+1].name = c2.toLatin1().data(); + controllers[i+1].num = CTRL_NRPN14_OFFSET+i+1; + controllers[i+1].min = 0; + controllers[i+1].max = 127; + + controllers[i+2].name = c3.toLatin1().data(); + controllers[i+2].num = CTRL_NRPN14_OFFSET+i+2; + controllers[i+2].min = 0; + controllers[i+2].max = 1; + + controllers[i+3].name = c4.toLatin1().data(); + controllers[i+3].num = CTRL_NRPN14_OFFSET+i+3; + controllers[i+3].min = 0; + controllers[i+3].max = 1; + + controllers[i+4].name = c5.toLatin1().data(); + controllers[i+4].num = CTRL_NRPN14_OFFSET+i+4; + + controllers[i+5].name = c6.toLatin1().data(); + controllers[i+5].num = CTRL_NRPN14_OFFSET+i+5; + + controllers[i+6].name = c7.toLatin1().data(); + controllers[i+6].num = CTRL_NRPN14_OFFSET+i+6; + + controllers[i+7].name = c8.toLatin1().data(); + controllers[i+7].num = CTRL_NRPN14_OFFSET+i+7; + + controllers[i+4].min = controllers[i+5].min = controllers[i+6].min = controllers[i+7].min = 0; + controllers[i+4].max = controllers[i+5].max = controllers[i+6].max = controllers[i+7].max = 127; + + i+=8; + } + + for (int sfx=0; sfx<SS_NR_OF_SENDEFFECTS; sfx++) { + QString c1 = "Sendfx " + QString::number(sfx) + " ret gain"; + QString c2 = "Sendfx " + QString::number(sfx) + " on/off"; + controllers[i].name = c1.toLatin1().data(); + controllers[i].num = CTRL_NRPN14_OFFSET+i; + controllers[i].min = 0; + controllers[i].max = 127; + + controllers[i+1].name = c2.toLatin1().data(); + controllers[i+1].num = CTRL_NRPN14_OFFSET+i+1; + controllers[i+1].min = 0; + controllers[i+1].max = 1; + i+=2; + } + + pthread_mutex_init(&SS_LoaderMutex, NULL); + SS_TRACE_OUT + } + +//--------------------------------------------------------- +// ~SimpleSynth +//--------------------------------------------------------- +SimpleSynth::~SimpleSynth() + { + SS_TRACE_IN + + // Cleanup channels and samples: + SS_DBG("Cleaning up sample data"); + for (int i=0; i<SS_NR_OF_CHANNELS; i++) { + if (channels[i].sample) { + delete[] channels[i].sample->data; + delete channels[i].sample; + } + } + simplesynth_ptr = NULL; + + SS_DBG("Deleting pluginlist"); + //Cleanup plugins: + for (iPlugin i = plugins.begin(); i != plugins.end(); ++i) { + delete (*i); + } + plugins.clear(); + + SS_DBG("Deleting sendfx buffers"); + //Delete sendfx buffers: + for (int i=0; i<SS_NR_OF_SENDEFFECTS; i++) { + delete[] sendFxLineOut[i][0]; + delete[] sendFxLineOut[i][1]; + delete[] sendFxReturn[i][0]; + delete[] sendFxReturn[i][1]; + } + + //processBuffer: + SS_DBG("Deleting process buffer"); + delete[] processBuffer[0]; + delete[] processBuffer[1]; + SS_TRACE_OUT + } + +//--------------------------------------------------------- +// guiVisible +/*! + \fn SimpleSynth::guiVisible + \brief Tells if the gui is hidden or shown + \return true/false if gui is shown/hidden + */ +//--------------------------------------------------------- +bool SimpleSynth::guiVisible() const + { + SS_TRACE_IN + bool v = gui->isVisible(); + SS_TRACE_OUT + return v; + } + +//--------------------------------------------------------- +// hasGui +/*! + \fn SimpleSynth::hasGui + \brief Tells if the synth has a gui or not + \return true if synth has gui, false it synth has no gui + */ +//--------------------------------------------------------- +bool SimpleSynth::hasGui() const + { + SS_TRACE_IN + SS_TRACE_OUT + return true; + } + +//--------------------------------------------------------- +// playNote +/*! + \fn SimpleSynth::playNote + \brief Triggers a note on (noteoffs are noteons with velo=0) + \param channel midi channel + \param pitch note pitch + \param velo note velocity + \return false for ok, true for not ok (not sure these are handled differently, but...) + */ +//--------------------------------------------------------- +bool SimpleSynth::playNote(int /*channel*/, int pitch, int velo) + { + SS_TRACE_IN + //Don't bother about channel, we're processing every playnote! + if ((pitch >= SS_LOWEST_NOTE) && (pitch <= SS_HIGHEST_NOTE)) { + bool noteOff = (velo == 0 ? 1 : 0); + int ch = pitch - SS_LOWEST_NOTE; + if(!noteOff) { + if (channels[ch].sample) { + //Turn on the white stuff: + channels[ch].playoffset = 0; + SWITCH_CHAN_STATE(ch , SS_SAMPLE_PLAYING); + channels[ch].cur_velo = (double) velo / 127.0; + channels[ch].gain_factor = channels[ch].cur_velo * channels[ch].volume; + if (SS_DEBUG_MIDI) { + printf("Playing note %d on channel %d\n", pitch, ch); + } + } + } + else { + //Note off: + if (channels[ch].noteoff_ignore) { + if (SS_DEBUG_MIDI) { + printf("Note off on channel %d\n", ch); + } + SWITCH_CHAN_STATE(ch , SS_CHANNEL_INACTIVE); + channels[ch].playoffset = 0; + channels[ch].cur_velo = 0; + } + } + } + SS_TRACE_OUT + return false; + } + +//--------------------------------------------------------- +// processEvent +/*! + \fn SimpleSynth::processEvent + \brief All events from sequencer first shows up here and are forwarded to their correct functions + \param event The event sent from sequencer + \return false for ok, true for not ok + */ +//--------------------------------------------------------- +bool SimpleSynth::processEvent(const MidiEvent& ev) + { + SS_TRACE_IN + switch(ev.type()) { + case ME_CONTROLLER: + if (SS_DEBUG_MIDI) { + printf("SimpleSynth::processEvent - Controller. Chan: %x dataA: %x dataB: %x\n", ev.channel(), ev.dataA(), ev.dataB()); + for (int i=0; i< ev.len(); i++) + printf("%x ", ev.data()[i]); + } + setController(ev.channel(), ev.dataA(), ev.dataB(), false); + return true; + case ME_NOTEON: + return playNote(ev.channel(), ev.dataA(), ev.dataB()); + case ME_NOTEOFF: + return playNote(ev.channel(), ev.dataA(), 0); + case ME_SYSEX: + //Debug print + if (SS_DEBUG_MIDI) { + printf("SimpleSynth::processEvent - Sysex received\n"); + for (int i=0; i< ev.len(); i++) + printf("%x ", ev.data()[i]); + printf("\n"); + } + return sysex(ev.len(), ev.data()); + } + return false; + SS_TRACE_OUT + } + +//--------------------------------------------------------- +// setController +/*! + \fn SimpleSynth::setController + \brief Called from sequencer indirectly via SimpleSynth::processEvent + \brief when the synth is supposed to set a controller value + \param channel channel nr + \param id controller id + \param val value of controller + \return false for ok, true for not ok + */ +//--------------------------------------------------------- +bool SimpleSynth::setController(int channel, int id, int val) + { + SS_TRACE_IN + if (SS_DEBUG_MIDI) { + printf("SimpleSynth::setController - received controller on channel %d, id %d value %d\n", channel, id, val); + } + + // Channel controllers: + if (id >= SS_FIRST_CHANNEL_CONTROLLER && id <= SS_LAST_CHANNEL_CONTROLLER ) { + // Find out which channel we're dealing with: + id-= SS_FIRST_CHANNEL_CONTROLLER; + int ch = (id / SS_NR_OF_CHANNEL_CONTROLLERS); + id = (id % SS_NR_OF_CHANNEL_CONTROLLERS); + + switch (id) { + case SS_CHANNEL_CTRL_VOLUME: + if (SS_DEBUG_MIDI) + printf("Received channel ctrl volume %d for channel %d\n", val, ch); + channels[ch].volume_ctrlval = val; + updateVolume(ch, val); + break; + case SS_CHANNEL_CTRL_NOFF: + if (SS_DEBUG_MIDI) + printf("Received ctrl noff %d for channel %d\n", val, ch); + channels[ch].noteoff_ignore = val; + break; + case SS_CHANNEL_CTRL_PAN: + { + if (SS_DEBUG_MIDI) + printf("Received ctrl pan %d for channel %d\n", val, ch); + channels[ch].pan = val; + updateBalance(ch, val); + break; + } + case SS_CHANNEL_CTRL_ONOFF: + { + if (SS_DEBUG_MIDI) + printf("Received ctrl onoff %d for channel %d\n", val, ch); + + if (val == false && channels[ch].channel_on == true) { + SWITCH_CHAN_STATE(ch, SS_CHANNEL_INACTIVE); + channels[ch].channel_on = val; + } + else if (val == true && channels[ch].channel_on == false) { // if it actually _was_ off: + SWITCH_CHAN_STATE(ch, SS_CHANNEL_INACTIVE); + channels[ch].playoffset = 0; + channels[ch].channel_on = val; + } + break; + } + case SS_CHANNEL_SENDFX1: + case SS_CHANNEL_SENDFX2: + case SS_CHANNEL_SENDFX3: + case SS_CHANNEL_SENDFX4: + { + int fxid = id - SS_CHANNEL_SENDFX1; + channels[ch].sendfxlevel[fxid] = (double)val/127.0; + break; + } + + default: + if (SS_DEBUG_MIDI) + printf("Unknown controller received for channel %d. id=%d\n", ch, id); + break; + } + } + // Master controllers: + else if (id >= SS_FIRST_MASTER_CONTROLLER && id <= SS_LAST_MASTER_CONTROLLER) { + if (SS_DEBUG_MIDI) + printf("Mastervol controller received: %d\n", id); + master_vol_ctrlval = val; + master_vol = (double) master_vol_ctrlval / SS_MASTER_VOLUME_QUOT; + } + // Emmm, this one should've been there in the beginning + else if (id == CTRL_VOLUME) { + if (SS_DEBUG_MIDI) { + printf("Ctrl volume received: vol: %d\n", val); + } + master_vol_ctrlval = val; + master_vol = (double) master_vol_ctrlval / SS_MASTER_VOLUME_QUOT; + //This one can't be from the gui, update gui: + guiUpdateMasterVol(val); + } + // Plugin controllers: + else if (id >= SS_FIRST_PLUGIN_CONTROLLER && id <= SS_LAST_PLUGIN_CONTROLLER) { + + int fxid = (id - SS_FIRST_PLUGIN_CONTROLLER) / SS_NR_OF_PLUGIN_CONTROLLERS; + int cmd = (id - SS_FIRST_PLUGIN_CONTROLLER) % SS_NR_OF_PLUGIN_CONTROLLERS; + + // Plugin return-gain: + if (cmd == SS_PLUGIN_RETURN) { + if (SS_DEBUG_MIDI) + printf("Ctrl fx retgain received: fxid: %d val: %d\n", fxid, val); + sendEffects[fxid].retgain_ctrlval = val; + sendEffects[fxid].retgain = (double) val / 75.0; + } + // Plugin on/off: + else if (cmd == SS_PLUGIN_ONOFF) { + if (SS_DEBUG_MIDI) + printf("Ctrl fx onoff received: fxid: %d val: %d\n", fxid, val); + sendEffects[fxid].state = (SS_SendFXState) val; + } + } + else { + if (SS_DEBUG_MIDI) + printf("Unknown controller received: %d\n", id); + } + SS_TRACE_OUT + return false; + } + +//--------------------------------------------------------- +/*! + \fn SimpleSynth::setController + */ +//--------------------------------------------------------- +bool SimpleSynth::setController(int channel, int id, int val, bool /*fromGui*/) + { + SS_TRACE_IN + bool ret = setController(channel, id, val); //Perhaps TODO... Separate events from the gui + SS_TRACE_OUT + return ret; + } +//--------------------------------------------------------- +// sysex +/*! + \fn SimpleSynth::sysex + \brief Called from sequencer indirectly via SimpleSynth::processEvent + \param len length of the sysex data + \param data the sysex data + \return false for ok, true for not ok +*/ +//--------------------------------------------------------- +bool SimpleSynth::sysex(int /*len*/, const unsigned char* data) + { + SS_TRACE_IN + int cmd = data[0]; + switch (cmd) { + case SS_SYSEX_LOAD_SAMPLE: + { + int channel = data[1]; + //int l = data[2]; + const char* filename = (const char*)(data+3); + if (SS_DEBUG_MIDI) { + printf("Sysex cmd: load sample, filename %s, on channel: %d\n", filename, channel); + } + loadSample(channel, filename); + break; + } + case SS_SYSEX_CLEAR_SAMPLE: + { + int ch = data[1]; + clearSample(ch); + break; + } + + case SS_SYSEX_INIT_DATA: + { + parseInitData(data); + break; + } + + case SS_SYSEX_LOAD_SENDEFFECT: + { + int fxid = data[1]; + QString lib = (const char*) (data + 2); + QString label = (const char*) (data + lib.length() + 3); + if (SS_DEBUG_MIDI) { + printf("Sysex cmd load effect: %d %s %s\n", fxid, lib.toLatin1().data(), label.toLatin1().data()); + } + initSendEffect(fxid, lib, label); + break; + } + + case SS_SYSEX_CLEAR_SENDEFFECT: + { + int fxid = data[1]; + if (SS_DEBUG_MIDI) { + printf("Sysex cmd clear effect: %d\n", fxid); + } + sendEffects[fxid].state = SS_SENDFX_OFF; + cleanupPlugin(fxid); + sendEffects[fxid].plugin = 0; + break; + } + + case SS_SYSEX_SET_PLUGIN_PARAMETER: + { + int fxid = data[1]; + int parameter = data[2]; + int val = data[3]; + // Write it to the plugin: + float floatval = sendEffects[fxid].plugin->convertGuiControlValue(parameter, val); + setFxParameter(fxid, parameter, floatval); + break; + } + + case SS_SYSEX_GET_INIT_DATA: + { + int initdata_len = 0; + const byte* tmp_initdata = NULL; + byte* event_data = NULL; + + getInitData(&initdata_len, &tmp_initdata); + int totlen = initdata_len + 1; + + event_data = new byte[initdata_len + 1]; + event_data[0] = SS_SYSEX_SEND_INIT_DATA; + memcpy(event_data + 1, tmp_initdata, initdata_len); + delete[] tmp_initdata; + tmp_initdata = NULL; + + MidiEvent ev(0, ME_SYSEX, event_data, totlen); + gui->writeEvent(ev); + delete[] event_data; + + break; + } + + default: + if (SS_DEBUG_MIDI) + printf("Unknown sysex cmd received: %d\n", cmd); + break; + } + SS_TRACE_OUT + return false; + } + +//--------------------------------------------------------- +// getPatchName +/*! + \fn SimpleSynth::getPatchName + \brief Called from host to get names of patches + \param index - which patchnr we're about to deliver + \return const char* with patchname + */ +//--------------------------------------------------------- +const char* SimpleSynth::getPatchName(int /*index*/, int, int) const + { + SS_TRACE_IN + SS_TRACE_OUT + return 0; + } + +//--------------------------------------------------------- +// getPatchInfo +/*! + \fn SimpleSynth::getPatchInfo + \brief Called from host to get info about patches + \param index - which patchnr we're about to deliver + \param patch - if this one is 0, this is the first call, otherwise keep deliver the host patches... or something + \return MidiPatch with patch info for host + */ +//--------------------------------------------------------- +const MidiPatch* SimpleSynth::getPatchInfo(int index, const MidiPatch* patch) const + { + SS_TRACE_IN + index = 0; patch = 0; + SS_TRACE_OUT + return 0; + } + +//--------------------------------------------------------- +// getControllerInfo +/*! + \fn SimpleSynth::getControllerInfo + \brief Called from host to collect info about which controllers the synth supports + \param index current controller number + \param name pointer where name is stored + \param controller int pointer where muse controller number is stored + \param min int pointer where controller min value is stored + \param max int pointer where controller max value is stored + \return 0 when done, otherwise return next desired controller index + */ +//--------------------------------------------------------- +int SimpleSynth::getControllerInfo(int index, const char** name, int* controller, int* min, int* max) + { + SS_TRACE_IN + if (index >= SS_NR_OF_CONTROLLERS) { + SS_TRACE_OUT + return 0; + } + + *name = controllers[index].name.c_str(); + *controller = controllers[index].num; + *min = controllers[index].min; + *max = controllers[index].max; + + if (SS_DEBUG_MIDI) { + printf("setting controller info: index %d name %s controller %d min %d max %d\n", index, *name, *controller, *min, *max); + } + SS_TRACE_OUT + return (index +1); + } + +//--------------------------------------------------------- +// process +/*! + \fn SimpleSynth::process + \brief Realtime function where the processing actually occurs + \param channels - audio data + \param offset - sample offset + \param len - nr of samples to process + */ +//--------------------------------------------------------- +void SimpleSynth::process(float** out, int offset, int len) + { + //Process messages from the gui + while (gui->fifoSize()) { + MidiEvent ev = gui->readEvent(); + if (ev.type() == ME_SYSEX) { + sysex(ev.len(), ev.data()); + sendEvent(ev); + } + else if (ev.type() == ME_CONTROLLER) { + setController(ev.channel(), ev.dataA(), ev.dataB(), true); + sendEvent(ev); + } + else { + if (SS_DEBUG) + printf("SimpleSynth::process(): unknown event, type: %d\n", ev.type()); + } + } + + if (synth_state == SS_RUNNING) { + + //Temporary mix-doubles + double out1, out2; + //double ltemp, rtemp; + float* data; + // Velocity factor: + double gain_factor; + + + // Clear send-channels. Skips if fx not turned on + for (int i=0; i<SS_NR_OF_SENDEFFECTS; i++) { + if (sendEffects[i].state == SS_SENDFX_ON) { + memset(sendFxLineOut[i][0], 0, SS_SENDFX_BUFFER_SIZE * sizeof(float)); + memset(sendFxLineOut[i][1], 0, SS_SENDFX_BUFFER_SIZE * sizeof(float)); + } + } + + + memset(out[0] + offset, 0, len * sizeof(float)); + memset(out[1] + offset, 0, len * sizeof(float)); + + //Process 1 channel at a time + for (int ch=0; ch < SS_NR_OF_CHANNELS; ch++) { + // If channels is turned off, skip: + if (channels[ch].channel_on == false) + continue; + + //If sample isn't playing, skip: + if (channels[ch].state == SS_SAMPLE_PLAYING) { + memset(processBuffer[0], 0, SS_PROCESS_BUFFER_SIZE * sizeof(double)); + memset(processBuffer[1], 0, SS_PROCESS_BUFFER_SIZE * sizeof(double)); + + for (int i=0; i<len; i++) { + // Current channel sample data: + data = channels[ch].sample->data; + gain_factor = channels[ch].gain_factor; + // Current velocity factor: + + if (channels[ch].sample->channels == 2) { + // + // Stereo sample: + // + // Add from sample: + out1 = (double) (data[channels[ch].playoffset] * gain_factor * channels[ch].balanceFactorL); + out2 = (double) (data[channels[ch].playoffset + 1] * gain_factor * channels[ch].balanceFactorR); + channels[ch].playoffset += 2; + } + else { + // + // Mono sample: + // + out1 = (double) (data[channels[ch].playoffset] * gain_factor * channels[ch].balanceFactorL); + out2 = (double) (data[channels[ch].playoffset] * gain_factor * channels[ch].balanceFactorR); + channels[ch].playoffset++; + } + + processBuffer[0][i] = out1; + processBuffer[1][i] = out2; + + // If send-effects tap is on, tap signal to respective lineout channel + for (int j=0; j<SS_NR_OF_SENDEFFECTS; j++) { + if (channels[ch].sendfxlevel[j] != 0.0) { + //If the effect has 2 inputs (stereo in): + if (sendEffects[j].inputs == 2) { + sendFxLineOut[j][0][i]+= (out1 * channels[ch].sendfxlevel[j]); + sendFxLineOut[j][1][i]+= (out2 * channels[ch].sendfxlevel[j]); + } + //If the effect is mono (1 input), only use first fxLineOut + else if (sendEffects[j].inputs == 1) { + sendFxLineOut[j][0][i]+= ((out1 + out2) * channels[ch].sendfxlevel[j] / 2.0); + } + //Effects with 0 or >2 inputs are ignored + } + } + + // + // If we've reached the last sample, set state to inactive + // + if (channels[ch].playoffset >= channels[ch].sample->samples) { + SWITCH_CHAN_STATE(ch, SS_CHANNEL_INACTIVE); + channels[ch].playoffset = 0; + break; + } + } + // Add contribution for this channel, for this frame, to final result: + for (int i=0; i<len; i++) { + out[0][i+offset]+=processBuffer[0][i]; + out[1][i+offset]+=processBuffer[1][i]; + } + } + } + // Do something funny with the sendies: + for (int j=0; j<SS_NR_OF_SENDEFFECTS; j++) { + if (sendEffects[j].state == SS_SENDFX_ON) { + sendEffects[j].plugin->process(len); + for (int i=0; i<len; i++) { + //Effect has mono output: + if (sendEffects[j].outputs == 1) { + //Add the result to both channels: + out[0][i+offset]+=((sendEffects[j].retgain * sendFxReturn[j][0][i]) / 2.0); + out[1][i+offset]+=((sendEffects[j].retgain * sendFxReturn[j][0][i]) / 2.0); + } + else if (sendEffects[j].outputs == 2) { + // Effect has stereo output + out[0][i+offset]+=(sendEffects[j].retgain * sendFxReturn[j][0][i]); + out[1][i+offset]+=(sendEffects[j].retgain * sendFxReturn[j][1][i]); + } + } + } + } + // Finally master gain: + for (int i=0; i<len; i++) { + out[0][i+offset] = (out[0][i+offset] * master_vol); + out[1][i+offset] = (out[1][i+offset] * master_vol); + } + } + } + +//--------------------------------------------------------- +// showGui +/*! + \fn SimpleSynth::showGui + \brief Displays or hides the gui window + \param val true or false = gui shown or hidden + */ +//--------------------------------------------------------- +void SimpleSynth::showGui(bool val) + { + SS_TRACE_IN + gui->setShown(val); + SS_TRACE_OUT + } + +//--------------------------------------------------------- +/*! + \fn SimpleSynth::init + \brief Initializes the SimpleSynth + \param name string set to caption in the gui dialog + \return true if successful, false if unsuccessful + */ +//--------------------------------------------------------- +bool SimpleSynth::init(const char* name) + { + SS_TRACE_IN + SWITCH_SYNTH_STATE(SS_INITIALIZING); + gui = new SimpleSynthGui(); + gui->show(); + gui->setWindowTitle(name); + SWITCH_SYNTH_STATE(SS_RUNNING); + SS_TRACE_OUT + return true; + } + +//--------------------------------------------------------- +/*! + \fn SimpleSynth::getInitData + \brief Data for reinitialization of SimpleSynth when loading project + \param n - number of chars used in the data + \param data - data that is sent as a sysex to the synth on reload of project + */ +//--------------------------------------------------------- +void SimpleSynth::getInitData(int* n, const unsigned char** data) + { + SS_TRACE_IN + // Calculate length of data + // For each channel, we need to store volume, pan, noff, onoff + int len = SS_NR_OF_CHANNEL_CONTROLLERS * SS_NR_OF_CHANNELS; + // Sampledata: filenames len + for (int i=0; i<SS_NR_OF_CHANNELS; i++) { + if (channels[i].sample) { + int filenamelen = strlen(channels[i].sample->filename.c_str()) + 2; + len+=filenamelen; + } + else + len++; //Add place for SS_NO_SAMPLE + } + len+=3; // 1 place for SS_SYSEX_INIT_DATA, 1 byte for master vol, 1 byte for version data + + // Effect data length + len++; //Add place for SS_SYSEX_INIT_DATA_VERSION, as control + + for (int i=0; i<SS_NR_OF_SENDEFFECTS; i++) { + Plugin* plugin = sendEffects[i].plugin; + if (plugin) { + int namelen = plugin->lib().size() + 2; + int labelnamelen = plugin->label().size() + 2; + len+=(namelen + labelnamelen); + + len+=3; //1 byte for nr of parameters, 1 byte for return gain, 1 byte for effect on/off + len+=sendEffects[i].nrofparameters; // 1 byte for each parameter value + } + else { + len++; //place for SS_NO_PLUGIN + } + } + + // First, SS_SYSEX_INIT_DATA + byte* buffer = new byte[len]; + memset(buffer, 0, len); + buffer[0] = SS_SYSEX_INIT_DATA; + buffer[1] = SS_SYSEX_INIT_DATA_VERSION; + if (SS_DEBUG_INIT) { + printf("Length of init data: %d\n", len); + printf("buffer[0] - SS_SYSEX_INIT_DATA: %d\n", SS_SYSEX_INIT_DATA); + printf("buffer[1] - SS_SYSEX_INIT_DATA_VERSION: %d\n", SS_SYSEX_INIT_DATA_VERSION); + } + int i = 2; + // All channels: + // 0 - volume ctrlval (0-127) + // 1 - pan (0-127) + // 2 - noff ignore (0-1) + // 3 - channel on/off (0-1) + // 4 - 7 - sendfx 1-4 (0-127) + // 8 - len of filename, n + // 9 - 9+n - filename + for (int ch=0; ch<SS_NR_OF_CHANNELS; ch++) { + buffer[i] = (byte) channels[ch].volume_ctrlval; + buffer[i+1] = (byte) channels[ch].pan; + buffer[i+2] = (byte) channels[ch].noteoff_ignore; + buffer[i+3] = (byte) channels[ch].channel_on; + buffer[i+4] = (byte) round(channels[ch].sendfxlevel[0] * 127.0); + buffer[i+5] = (byte) round(channels[ch].sendfxlevel[1] * 127.0); + buffer[i+6] = (byte) round(channels[ch].sendfxlevel[2] * 127.0); + buffer[i+7] = (byte) round(channels[ch].sendfxlevel[3] * 127.0); + + if (SS_DEBUG_INIT) { + printf("Channel %d:\n", ch); + printf("buffer[%d] - channels[ch].volume_ctrlval = \t%d\n", i, channels[ch].volume_ctrlval); + printf("buffer[%d] - channels[ch].pan = \t\t%d\n", i+1, channels[ch].pan); + printf("buffer[%d] - channels[ch].noteoff_ignore = \t%d\n", i+2, channels[ch].noteoff_ignore ); + printf("buffer[%d] - channels[ch].channel_on = \t%d\n", i+3, channels[ch].channel_on); + for (int j= i+4; j < i+8; j++) { + printf("buffer[%d] - channels[ch].sendfxlevel[%d]= \t%d\n", j, j-i-4, (int)round(channels[ch].sendfxlevel[j-i-4] * 127.0)); + } + } + if (channels[ch].sample) { + int filenamelen = strlen(channels[ch].sample->filename.c_str()) + 1; + buffer[i+8] = (byte) filenamelen; + memcpy((buffer+(i+9)), channels[ch].sample->filename.c_str(), filenamelen); + if (SS_DEBUG_INIT) { + printf("buffer[%d] - filenamelen: %d\n", i+8, filenamelen); + printf("buffer[%d] - buffer[%d] - filename: ", (i+9), (i+9) + filenamelen - 1); + for (int j = i+9; j< i+9+filenamelen; j++) { + printf("%c",buffer[j]); + } + printf("\n"); + } + i+= (SS_NR_OF_CHANNEL_CONTROLLERS + 1 + filenamelen); + } + else { + buffer[i+8] = SS_NO_SAMPLE; + if (SS_DEBUG_INIT) { + printf("buffer[%d]: SS_NO_SAMPLE: - %d\n", i+8, SS_NO_SAMPLE); + } + i+= (SS_NR_OF_CHANNEL_CONTROLLERS + 1); + } + } + if (SS_DEBUG_INIT) { + printf("buffer[%d]: Master vol: - %d\n", i, master_vol_ctrlval); + } + buffer[i] = master_vol_ctrlval; + *(data) = buffer; *n = len; + i++; + + //Send effects: + buffer[i] = SS_SYSEX_INIT_DATA_VERSION; //Just for check + if (SS_DEBUG_INIT) { + printf("buffer[%d]: Control value, SS_SYSEX_INIT_DATA_VERSION\n", i); + } + + i++; + for (int j=0; j<SS_NR_OF_SENDEFFECTS; j++) { + if (sendEffects[j].plugin) { + int labelnamelen = sendEffects[j].plugin->label().size() + 1; + buffer[i] = labelnamelen; + memcpy((buffer+i+1), sendEffects[j].plugin->label().toLatin1().data(), labelnamelen); + if (SS_DEBUG_INIT) { + printf("buffer[%d] - labelnamelen: %d\n", i, labelnamelen); + printf("buffer[%d] - buffer[%d] - filename: ", (i+1), (i+1) + labelnamelen - 1); + for (int k = i+1; k < i+1+labelnamelen; k++) { + printf("%c",buffer[k]); + } + printf("\n"); + } + + i+=(labelnamelen + 1); + + int namelen = sendEffects[j].plugin->lib().size() + 1; + buffer[i] = namelen; + memcpy((buffer+i+1), sendEffects[j].plugin->lib().toLatin1().data(), namelen); + if (SS_DEBUG_INIT) { + printf("buffer[%d] - libnamelen : %d\n", i, namelen); + printf("buffer[%d] - buffer[%d] - filename: ", (i+1), (i+1) + namelen - 1); + for (int k = i+1; k < i+1+namelen; k++) { + printf("%c",buffer[k]); + } + printf("\n"); + } + + i+=(namelen + 1); + + buffer[i]=sendEffects[j].nrofparameters; + if (SS_DEBUG_INIT) { + printf("buffer[%d]: sendEffects[%d].nrofparameters=%d\n", i, j, buffer[i]); + } + i++; + + buffer[i]=sendEffects[j].retgain_ctrlval; + if (SS_DEBUG_INIT) { + printf("buffer[%d]: sendEffects[%d].retgain_ctrlval=%d\n", i, j, buffer[i]); + } + i++; + + for (int k=0; k<sendEffects[j].nrofparameters; k++) { + //TODO: Convert to 127-scale + buffer[i] = sendEffects[j].plugin->getGuiControlValue(k); + if (SS_DEBUG_INIT) { + printf("buffer[%d]: sendEffects[%d].parameterval[%d]=%d\n", i, j, k, buffer[i]); + } + i++; + } + } + // No plugin loaded: + else { + buffer[i] = SS_NO_PLUGIN; + if (SS_DEBUG_INIT) { + printf("buffer[%d]: SS_NO_PLUGIN\n", i); + } + i++; + } + } + + SS_TRACE_OUT + } + + +/*! + \fn SimpleSynth::parseInitData() + */ +void SimpleSynth::parseInitData(const unsigned char* data) + { + SS_TRACE_IN + //int len = strlen((const char*)data); + if (SS_DEBUG_INIT) { + printf("buffer[1], SS_SYSEX_INIT_DATA_VERSION=%d\n", *(data+1)); + } + const byte* ptr = data+2; + for (int ch=0; ch<SS_NR_OF_CHANNELS; ch++) { + channels[ch].volume_ctrlval = (byte) *(ptr); + + if (SS_DEBUG_INIT) { + printf("Channel %d:\n", ch); + printf("buffer[%ld] - channels[ch].volume_ctrlval = \t%d\n", ptr-data, *ptr); + printf("buffer[%ld] - channels[ch].pan = \t\t%d\n", ptr-data+1, *(ptr+1)); + printf("buffer[%ld] - channels[ch].noteoff_ignore = \t%d\n", ptr-data+2, *(ptr+2)); + printf("buffer[%ld] - channels[ch].channel_on = \t%d\n", ptr-data+3, *(ptr+3)); + } + updateVolume(ch, *(ptr)); + guiUpdateVolume(ch, *(ptr)); + + channels[ch].pan = *(ptr+1); + updateBalance(ch, *(ptr+1)); + guiUpdateBalance(ch, *(ptr+1)); + + channels[ch].noteoff_ignore = *(ptr+2); + guiUpdateNoff(ch, *(ptr+2)); + + channels[ch].channel_on = *(ptr+3); + guiUpdateChoff(ch, *(ptr+3)); + + ptr+=4; + + for (int i=0; i<4; i++) { + channels[ch].sendfxlevel[i] = (float) (*(ptr)/127.0); + guiUpdateSendFxLevel(ch, i, *(ptr)); + ptr++; + } + + bool hasSample = *(ptr); + ptr++; + + channels[ch].sample = 0; + channels[ch].playoffset = 0; + SWITCH_CHAN_STATE(ch, SS_CHANNEL_INACTIVE); + if (SS_DEBUG_INIT) { + printf("parseInitData: channel %d, volume: %f pan: %d bfL %f bfR %f chON %d s1: %f s2: %f s3: %f s4: %f\n", + ch, + channels[ch].volume, + channels[ch].pan, + channels[ch].balanceFactorL, + channels[ch].balanceFactorR, + channels[ch].channel_on, + channels[ch].sendfxlevel[0], + channels[ch].sendfxlevel[1], + channels[ch].sendfxlevel[2], + channels[ch].sendfxlevel[3] + ); + } + if (hasSample) { + std::string filenametmp = (const char*) ptr; + ptr+= strlen(filenametmp.c_str()) + 1; + //printf("We should load %s\n", filenametmp.c_str()); + loadSample(ch, filenametmp.c_str()); + } + else { + //Clear sample + clearSample(ch); + guiNotifySampleCleared(ch); + } + } + //Master vol: + master_vol_ctrlval = *(ptr); + master_vol = (double) master_vol_ctrlval / SS_MASTER_VOLUME_QUOT; + guiUpdateMasterVol(master_vol_ctrlval); + if (SS_DEBUG_INIT) { + printf("Master vol: %d\n", master_vol_ctrlval); + } + ptr++; + + // Effects: + if (*(ptr) != SS_SYSEX_INIT_DATA_VERSION) { + fprintf(stderr, "Error loading init data - control byte not found. Skipping...\n"); + SS_TRACE_OUT + return; + } + ptr++; + + for (int i=0; i<SS_NR_OF_SENDEFFECTS; i++) { + if (SS_DEBUG_INIT) + printf("buffer[%ld] - sendeffect[%d], labelnamelen=%d\n", ptr-data, i, *ptr); + int labelnamelen = *(ptr); + + if (labelnamelen != SS_NO_PLUGIN) { + ptr++; + std::string labelnametmp = (const char*) ptr; + ptr+= labelnamelen; + + //int libnamelen = *(ptr); + ptr++; + std::string libnametmp = (const char*) ptr; + ptr+= strlen(libnametmp.c_str()) + 1; + + + initSendEffect(i, libnametmp.c_str(), labelnametmp.c_str()); + //initSendEffect(0, "cmt", "freeverb3"); + + byte params = *(ptr); + byte retgain = *(ptr+1); + ptr+=2; + + sendEffects[i].nrofparameters = params; + + sendEffects[i].retgain_ctrlval = retgain; + sendEffects[i].retgain = retgain; + sendEffects[i].retgain = (double) retgain/ 75.0; + MidiEvent ev(0, 0, ME_CONTROLLER, SS_PLUGIN_RETURNLEVEL_CONTROLLER(i), retgain); + gui->writeEvent(ev); + + for (int j=0; j<params; j++) { + if (SS_DEBUG_INIT) + printf("buffer[%ld] - sendeffect[%d], parameter[%d]=%d\n", ptr-data, i, j, *ptr); + setFxParameter(i, j, sendEffects[i].plugin->convertGuiControlValue(j, *(ptr))); + ptr++; + } + } + else { + if (sendEffects[i].plugin) + cleanupPlugin(i); + ptr++; + } + } + + SS_TRACE_OUT + } + +/*! + \fn SimpleSynth::loadSample(int chno, const char* filename) + */ +bool SimpleSynth::loadSample(int chno, const char* filename) + { + SS_TRACE_IN + SS_Channel* ch = &channels[chno]; + + // Thread stuff: + SS_SampleLoader* loader = new SS_SampleLoader; + loader->channel = ch; + loader->filename = std::string(filename); + loader->ch_no = chno; + if (SS_DEBUG) { + printf("Loader filename is: %s\n", filename); + } + pthread_t sampleThread; + pthread_attr_t* attributes = (pthread_attr_t*) malloc(sizeof(pthread_attr_t)); + pthread_attr_init(attributes); + pthread_attr_setdetachstate(attributes, PTHREAD_CREATE_DETACHED); + if (pthread_create(&sampleThread, attributes, ::loadSampleThread, (void*) loader)) { + perror("creating thread failed:"); + pthread_attr_destroy(attributes); + delete loader; + return false; + } + + pthread_attr_destroy(attributes); + SS_TRACE_OUT + return true; + } + +/*! + \fn loadSampleThread(void* p) + \brief Since process needs to respond withing a certain time, loading of samples need to be done in a separate thread + */ +static void* loadSampleThread(void* p) + { + SS_TRACE_IN + pthread_mutex_lock(&SS_LoaderMutex); + + // Crit section: + SS_State prevState = synth_state; + SWITCH_SYNTH_STATE(SS_LOADING_SAMPLE); + SS_SampleLoader* loader = (SS_SampleLoader*) p; + SS_Channel* ch = loader->channel; + int ch_no = loader->ch_no; + + if (ch->sample) { + delete[] ch->sample->data; + delete ch->sample; + } + ch->sample = new SS_Sample; + SS_Sample* smp = ch->sample; + + SNDFILE* sf; + const char* filename = loader->filename.c_str(); + SF_INFO sfi; + + if (SS_DEBUG) + printf("loadSampleThread: filename = %s\n", filename); + + sf = sf_open(filename, SFM_READ, &sfi); + if (sf == 0) { + fprintf(stderr,"Error opening file: %s\n", filename); + SWITCH_SYNTH_STATE(prevState); + simplesynth_ptr->guiSendSampleLoaded(false, loader->ch_no, filename); + delete ch->sample; ch->sample = 0; + delete loader; + pthread_mutex_unlock(&SS_LoaderMutex); + SS_TRACE_OUT + pthread_exit(0); + } + + //Print some info: + if (SS_DEBUG) { + printf("Sample info:\n"); + printf("Frames: \t%ld\n", (long) sfi.frames); + printf("Channels: \t%d\n", sfi.channels); + printf("Samplerate: \t%d\n", sfi.samplerate); + } + + // + // Allocate and read the thingie + // + + // If current samplerate is the same as MusE's: + if (SS_samplerate == sfi.samplerate) { + smp->data = new float[sfi.channels * sfi.frames]; + sf_count_t n = sf_readf_float(sf, smp->data, sfi.frames); + smp->frames = sfi.frames; + smp->samples = (n * sfi.channels); + smp->channels = sfi.channels; + if (SS_DEBUG) { + printf("%ld frames read\n", (long) n); + } + } + else // otherwise, resample: + { + smp->channels = sfi.channels; + // Get new nr of frames: + double srcratio = (double) SS_samplerate/ (double) sfi.samplerate; + smp->frames = (long) floor(((double) sfi.frames * srcratio)); + smp->frames = (sfi.channels == 1 ? smp->frames * 2 : smp->frames ); // Double nr of new frames if mono->stereo + smp->samples = smp->frames * smp->channels; + + if (SS_DEBUG) { + printf("Resampling from %ld frames to %ld frames - srcration: %lf\n", sfi.frames, smp->frames, srcratio); + printf("Nr of new samples: %ld\n", smp->samples); + } + + // Read to temporary: + float temp[sfi.frames * sfi.channels]; + int frames_read = sf_readf_float(sf, temp, sfi.frames); + if (frames_read != sfi.frames) { + fprintf(stderr,"Error reading sample %s\n", filename); + simplesynth_ptr->guiSendSampleLoaded(false, loader->ch_no, filename); + sf_close(sf); + SWITCH_SYNTH_STATE(prevState); + delete ch->sample; ch->sample = 0; + delete loader; + pthread_mutex_unlock(&SS_LoaderMutex); + pthread_exit(0); + SS_TRACE_OUT + } + + // Allocate mem for the new one + smp->data = new float[smp->frames * smp->channels]; + memset(smp->data, 0, sizeof(float)* smp->frames * smp->channels); + + // libsamplerate & co (secret rabbits in the code!) + SRC_DATA srcdata; + srcdata.data_in = temp; + srcdata.data_out = smp->data; + srcdata.input_frames = sfi.frames; + srcdata.output_frames = smp->frames; + srcdata.src_ratio = (double) SS_samplerate / (double) sfi.samplerate; + + if (SS_DEBUG) { + printf("Converting sample....\n"); + } + + if (src_simple(&srcdata, SRC_SINC_BEST_QUALITY, sfi.channels)) { + SS_ERROR("Error when resampling, ignoring current sample"); + //TODO: deallocate and stuff + } + else if (SS_DEBUG) { + printf("Sample converted. %ld input frames used, %ld output frames generated\n", + srcdata.input_frames_used, + srcdata.output_frames_gen); + } + } + //Just close the dam thing + sf_close(sf); + SWITCH_SYNTH_STATE(prevState); + ch->sample->filename = loader->filename; + simplesynth_ptr->guiSendSampleLoaded(true, ch_no, filename); + delete loader; + pthread_mutex_unlock(&SS_LoaderMutex); + SS_TRACE_OUT + pthread_exit(0); + } + + +static Mess* instantiate(int sr, const char* name) + { + printf("SimpleSynth sampleRate %d\n", sr); + SimpleSynth* synth = new SimpleSynth(sr); + if (!synth->init(name)) { + delete synth; + synth = 0; + } + return synth; + } + + +/*! + \fn SimpleSynth::updateBalance(int pan) + */ +void SimpleSynth::updateBalance(int ch, int val) + { + SS_TRACE_IN + channels[ch].pan = val; + + // Balance: + channels[ch].balanceFactorL = 1.0; + channels[ch].balanceFactorR = 1.0; + double offset = 0; + int dev = val - 64; + offset = (double) dev / 64.0; + if (offset < 0) { + channels[ch].balanceFactorR = 1.0 + offset; + } + else { + channels[ch].balanceFactorL = 1.0 - offset; + } + + if (SS_DEBUG_MIDI) + printf("balanceFactorL %f balanceFactorR %f\n", channels[ch].balanceFactorL, channels[ch].balanceFactorR); + SS_TRACE_OUT + } + + +/*! + \fn SimpleSynth::updateVolume(int invol_ctrlval) + */ +void SimpleSynth::updateVolume(int ch, int invol_ctrlval) + { + SS_TRACE_IN + channels[ch].volume = (double)invol_ctrlval/ (double) SS_CHANNEL_VOLUME_QUOT; + channels[ch].volume_ctrlval = invol_ctrlval; + SS_TRACE_OUT + } + + +/*! + \fn SimpleSynth::guiUpdateBalance(int ch, int bal) + */ +void SimpleSynth::guiUpdateBalance(int ch, int bal) + { + SS_TRACE_IN + MidiEvent ev(0, ch, ME_CONTROLLER, SS_CHANNEL_PAN_CONTROLLER(ch), bal); + gui->writeEvent(ev); + SS_TRACE_OUT + } + + +/*! + \fn SimpleSynth::guiUpdateVolume(int ch, int val) + */ +void SimpleSynth::guiUpdateVolume(int ch, int val) + { + SS_TRACE_IN + MidiEvent ev(0, 0, ME_CONTROLLER, SS_CHANNEL_VOLUME_CONTROLLER(ch), val); + gui->writeEvent(ev); + SS_TRACE_OUT + } + + +/*! + \fn SimpleSynth::guiUpdateNoff(bool b) + */ +void SimpleSynth::guiUpdateNoff(int ch, bool b) + { + SS_TRACE_IN + MidiEvent ev(0, 0, ME_CONTROLLER, SS_CHANNEL_NOFF_CONTROLLER(ch), b); + gui->writeEvent(ev); + SS_TRACE_OUT + } + + +/*! + \fn SimpleSynth::guiUpdateChoff(int ch, bool b) + */ +void SimpleSynth::guiUpdateChoff(int ch, bool b) + { + SS_TRACE_IN + MidiEvent ev(0, 0, ME_CONTROLLER, SS_CHANNEL_ONOFF_CONTROLLER(ch), b); + gui->writeEvent(ev); + SS_TRACE_OUT + } + + +/*! + \fn SimpleSynth::guiUpdateMasterVol(int val) + */ +void SimpleSynth::guiUpdateMasterVol(int val) + { + SS_TRACE_IN + MidiEvent ev(0, 0, ME_CONTROLLER, SS_MASTER_CTRL_VOLUME, val); + gui->writeEvent(ev); + SS_TRACE_OUT + } + +/*! + \fn SimpleSynth::guiUpdateSendFxLevel(int fxid, int level) + */ +void SimpleSynth::guiUpdateSendFxLevel(int channel, int fxid, int level) + { + SS_TRACE_IN + MidiEvent ev(0, 0, ME_CONTROLLER, SS_CHANNEL_SENDFX_CONTROLLER(channel, fxid), level); + gui->writeEvent(ev); + SS_TRACE_OUT + } + + +/*! + \fn SimpleSynth::guiSendSampleLoaded(int ch, const char* filename) + */ +void SimpleSynth::guiSendSampleLoaded(bool success, int ch, const char* filename) + { + SS_TRACE_IN + int len = strlen(filename) + 3; //2 + filenamelen + 1; + byte out[len]; + + if (success) { + out[0] = SS_SYSEX_LOAD_SAMPLE_OK; + } + else { + out[0] = SS_SYSEX_LOAD_SAMPLE_ERROR; + } + out[1] = ch; + memcpy(out+2, filename, strlen(filename)+1); + MidiEvent ev(0, ME_SYSEX, out, len); + gui->writeEvent(ev); + SS_TRACE_OUT + } + + +/*! + \fn SimpleSynth::guiSendError(const char* errorstring) + */ +void SimpleSynth::guiSendError(const char* errorstring) + { + SS_TRACE_IN + byte out[strlen(errorstring)+2]; + out[0] = SS_SYSEX_ERRORMSG; + memcpy(out+1, errorstring, strlen(errorstring) +1); + SS_TRACE_OUT + } + +extern "C" + { + static MESS descriptor = { + "SimpleSynth", + "Mathias Lundgren (lunar_shuttle@users.sf.net)", + "0.1", //Version string + MESS_MAJOR_VERSION, MESS_MINOR_VERSION, + instantiate, + }; + const MESS* mess_descriptor() { return &descriptor; } + } + + +/*! + \fn SimpleSynth::initSendEffect(int sendeffectid, QString lib, QString name) + */ +bool SimpleSynth::initSendEffect(int id, QString lib, QString name) + { + SS_TRACE_IN + bool success = false; + if (sendEffects[id].plugin) { + //Cleanup if one was already there: + cleanupPlugin(id); + } + sendEffects[id].plugin = (LadspaPlugin*) plugins.find(lib, name); + LadspaPlugin* plugin = sendEffects[id].plugin; + if (plugin) { //We found one + + sendEffects[id].inputs = plugin->inports(); + sendEffects[id].outputs = plugin->outports(); + + if (plugin->instantiate()) { + SS_DBG2("Plugin instantiated", name.toLatin1().data()); + SS_DBG_I("Parameters", plugin->parameter()); + SS_DBG_I("No of inputs", plugin->inports()); + SS_DBG_I("No of outputs",plugin->outports()); + SS_DBG_I("Inplace-capable", plugin->inPlaceCapable()); + + // Connect inputs/outputs: + // If single output/input, only use first channel in sendFxLineOut/sendFxReturn + SS_DBG("Connecting ports..."); + plugin->connectInport(0, sendFxLineOut[id][0]); + if (plugin->inports() == 2) + plugin->connectInport(1, sendFxLineOut[id][1]); + else if (plugin->inports() > 2) { + fprintf(stderr, "Plugin has more than 2 inputs, not supported\n"); + } + + plugin->connectOutport(0, sendFxReturn[id][0]); + if (plugin->outports() == 2) + plugin->connectOutport(1, sendFxReturn[id][1]); + else if (plugin->outports() > 2) { + fprintf(stderr, "Plugin has more than 2 outputs, not supported\n"); + } + SS_DBG("Ports connected"); + if (plugin->start()) { + sendEffects[id].state = SS_SENDFX_ON; + success = true; + + int n = plugin->parameter(); + sendEffects[id].nrofparameters = n; + + // This is not nice, but freeverb doesn't want to play until some values are set: + if (name == "freeverb3") { + setFxParameter(id, 2, 0.5); + setFxParameter(id, 3, 0.5); + setFxParameter(id, 4, 0.5); + guiUpdateFxParameter(id, 2, 0.5); + guiUpdateFxParameter(id, 3, 0.5); + guiUpdateFxParameter(id, 4, 0.5); + } + } + //TODO: cleanup if failed + } + } + //Notify gui + int len = 3; + byte out[len]; + out[0] = SS_SYSEX_LOAD_SENDEFFECT_OK; + out[1] = id; + int j=0; + for (iPlugin i = plugins.begin(); i!=plugins.end(); i++, j++) { + if ((*i)->lib() == plugin->lib() && (*i)->label() == plugin->label()) { + out[2] = j; + MidiEvent ev(0, ME_SYSEX, out, len); + gui->writeEvent(ev); + } + } + + if (!success) { + QString errorString = "Error loading plugin \"" + plugin->label() + "\""; + guiSendError(errorString.toLatin1().data()); + } + return success; + SS_TRACE_OUT + } + + +/*! + \fn SimpleSynth::setSendFxLevel(int channel, int effectid, double val) + */ +void SimpleSynth::setSendFxLevel(int channel, int effectid, double val) + { + SS_TRACE_IN + channels[channel].sendfxlevel[effectid] = val; + SS_TRACE_OUT + } + + +/*! + \fn SimpleSynth::cleanupPlugin(int id) + */ +void SimpleSynth::cleanupPlugin(int id) + { + SS_TRACE_IN + LadspaPlugin* plugin = sendEffects[id].plugin; + plugin->stop(); + SS_DBG2("Stopped fx", plugin->label().toLatin1().data()); + sendEffects[id].nrofparameters = 0; + sendEffects[id].state = SS_SENDFX_OFF; + sendEffects[id].plugin = 0; + + byte d[2]; + d[0] = SS_SYSEX_CLEAR_SENDEFFECT_OK; + d[1] = id; + MidiEvent ev(0, ME_SYSEX, d, 2); + gui->writeEvent(ev); + SS_TRACE_OUT + } + + +/*! + \fn SimpleSynth::setFxParameter(int fxid, int param, float val) + \brief Set fx-parameter on plugin and notify gui + */ +void SimpleSynth::setFxParameter(int fxid, int param, float val) + { + SS_TRACE_IN + LadspaPlugin* plugin = sendEffects[fxid].plugin; + if (SS_DEBUG_LADSPA) { + printf("Setting fx parameter: %f\n", val); + } + plugin->setParam(param, val); + //sendEffects[fxid].parameter[param] = val; + //guiUpdateFxParameter(fxid, param, val); + SS_TRACE_OUT + } + + + +/*! + \fn SimpleSynth::guiUpdateFxParameter(int fxid, int param, float val) + \brief Notify gui of changed fx-parameter + */ +void SimpleSynth::guiUpdateFxParameter(int fxid, int param, float val) + { + SS_TRACE_IN + LadspaPlugin* plugin = sendEffects[fxid].plugin; + float min, max; + plugin->range(param, &min, &max); + //offset: + val-= min; + + int intval = plugin->getGuiControlValue(param); + /*if (plugin->isLog(param)) { + intval = SS_map_logdomain2pluginparam(logf(val/(max - min) + min)); + } + else if (plugin->isBool(param)) { + intval = (int) val; + } + else { + float scale = SS_PLUGIN_PARAM_MAX / (max - min); + intval = (int) ((val - min) * scale); + }*/ + if (SS_DEBUG_MIDI) { + printf("Updating gui, fx parameter. fxid=%d, param=%d val=%d\n", fxid, param, intval); + } + + byte d[4]; + d[0] = SS_SYSEX_SET_PLUGIN_PARAMETER_OK; + d[1] = fxid; + d[2] = param; + d[3] = intval; + MidiEvent ev(0, ME_SYSEX, d, 4); + gui->writeEvent(ev); + SS_TRACE_OUT + } + + +/*! + \fn SimpleSynth::clearSample(int ch) + \brief Clears a sample (actually clears a channel) + */ +void SimpleSynth::clearSample(int ch) + { + SS_TRACE_IN + if (channels[ch].sample) { + if (SS_DEBUG) + printf("Clearing sample on channel %d\n", ch); + SS_State prevstate = synth_state; + SWITCH_CHAN_STATE(ch, SS_CHANNEL_INACTIVE); + SWITCH_SYNTH_STATE(SS_CLEARING_SAMPLE); + if (channels[ch].sample->data) { + delete[] channels[ch].sample->data; + channels[ch].sample->data = 0; + } + if (channels[ch].sample) { + delete channels[ch].sample; + channels[ch].sample = 0; + } + SWITCH_SYNTH_STATE(prevstate); + guiNotifySampleCleared(ch); + if (SS_DEBUG) { + printf("Clear sample - sample cleared on channel %d\n", ch); + } + } + SS_TRACE_OUT + } + + +/*! + \fn SimpleSynth::guiNotifySampleCleared(int ch) + */ +void SimpleSynth::guiNotifySampleCleared(int ch) + { + SS_TRACE_IN + byte d[2]; + d[0] = SS_SYSEX_CLEAR_SAMPLE_OK; + d[1] = (byte) ch; + MidiEvent ev(0, ME_SYSEX, d, 2); + gui->writeEvent(ev); + SS_TRACE_OUT + } diff --git a/attic/muse_qt4_evolution/synti/simpledrums/simpledrums.h b/attic/muse_qt4_evolution/synti/simpledrums/simpledrums.h new file mode 100644 index 00000000..d52f90af --- /dev/null +++ b/attic/muse_qt4_evolution/synti/simpledrums/simpledrums.h @@ -0,0 +1,173 @@ +// +// C++ Interface: simplesynth +// +// Description: +// +// +// Author: Mathias Lundgren <lunar_shuttle@users.sf.net>, (C) 2004 +// +// Copyright: See COPYING file that comes with this distribution +// +// +#ifndef SIMPLESYNTH_H +#define SIMPLESYNTH_H + +#include <sndfile.h> +#include "libsynti/mess.h" +#include "common.h" +#include "libsynti/midievent.h" +#include "simpledrumsgui.h" +#include "ssplugin.h" + +#define SS_NO_SAMPLE 0 +#define SS_NO_PLUGIN 0 + +#define SS_PROCESS_BUFFER_SIZE 4096 //TODO: Add initialization method for nr of frames in each process from MusE - if nr of frames > than this, this will fail +#define SS_SENDFX_BUFFER_SIZE SS_PROCESS_BUFFER_SIZE + +enum SS_ChannelState + { + SS_CHANNEL_INACTIVE=0, + SS_SAMPLE_PLAYING, + }; + +enum SS_State + { + SS_INITIALIZING=0, + SS_LOADING_SAMPLE, + SS_CLEARING_SAMPLE, + SS_RUNNING, + }; + +enum SS_SendFXState + { + SS_SENDFX_OFF=0, + SS_SENDFX_ON + }; + +struct SS_SendFx + { + SS_SendFXState state; + LadspaPlugin* plugin; + int inputs; + int outputs; + int retgain_ctrlval; + double retgain; + int nrofparameters; + }; + +struct SS_Sample + { + float* data; + int samplerate; + int bits; + std::string filename; + long samples; + long frames; + int channels; + SF_INFO sfinfo; + }; + +struct SS_Channel + { + SS_ChannelState state; + const char* name; + SS_Sample* sample; + int playoffset; + bool noteoff_ignore; + + double volume; + int volume_ctrlval; + + double cur_velo; + double gain_factor; + + int pan; + double balanceFactorL; + double balanceFactorR; + + bool channel_on; + + //Send fx: + double sendfxlevel[SS_NR_OF_SENDEFFECTS]; + }; + +struct SS_Controller + { + std::string name; + int num; + int min, max; + }; + +struct SS_SampleLoader + { + SS_Channel* channel; + std::string filename; + int ch_no; + }; + +class SimpleSynth : public Mess + { + public: + SimpleSynth(int); + + virtual ~SimpleSynth(); + + virtual bool guiVisible() const; + virtual bool hasGui() const; + virtual bool playNote(int arg1, int arg2, int arg3); + virtual bool processEvent(const MidiEvent& arg1); + virtual bool setController(int arg1, int arg2, int arg3); + virtual bool sysex(int arg1, const unsigned char* arg2); + virtual const char* getPatchName(int arg1, int arg2, int arg3) const; + virtual const MidiPatch* getPatchInfo(int arg1, const MidiPatch* arg2) const; + virtual int getControllerInfo(int arg1, const char** arg2, int* arg3, int* arg4, int* arg5); + virtual void process(float** data, int offset, int len); + virtual void showGui(bool arg1); + virtual void getInitData(int*, const unsigned char**); + bool init(const char* name); + void guiSendSampleLoaded(bool success, int ch, const char* filename); + void guiSendError(const char* errorstring); + + static const char* synth_state_descr[]; + static const char* channel_state_descr[]; + +private: + SimpleSynthGui* gui; + + SS_Channel channels[SS_NR_OF_CHANNELS]; + SS_Controller controllers[SS_NR_OF_CONTROLLERS]; + bool setController(int channel, int id, int val, bool fromGui); + bool loadSample(int ch_no, const char* filename); + void parseInitData(const unsigned char* data); + void updateVolume(int ch, int in_volume_ctrlval); + void updateBalance(int ch, int pan); + void guiNotifySampleCleared(int ch); + void guiUpdateBalance(int ch, int bal); + void guiUpdateVolume(int ch, int val); + void guiUpdateNoff(int ch, bool b); + void guiUpdateChoff(int ch, bool b); + void guiUpdateMasterVol(int val); + void guiUpdateFxParameter(int fxid, int param, float val); + void guiUpdateSendFxLevel(int channel, int fxid, int level); + bool initSendEffect(int sendeffectid, QString lib, QString name); + void setSendFxLevel(int channel, int effectid, double val); + void cleanupPlugin(int id); + void setFxParameter(int fxid, int param, float val); + void clearSample(int ch); + double master_vol; + int master_vol_ctrlval; + + //Send effects: + SS_SendFx sendEffects[SS_NR_OF_SENDEFFECTS]; + float* sendFxLineOut[SS_NR_OF_SENDEFFECTS][2]; //stereo output (fed into LADSPA inputs),sent from the individual channels -> LADSPA fx + float* sendFxReturn[SS_NR_OF_SENDEFFECTS][2]; //stereo inputs, from LADSPA plugins, sent from LADSPA -> SS and added to the mix + double* processBuffer[2]; + }; + +static void* loadSampleThread(void*); +static pthread_mutex_t SS_LoaderMutex; +static SS_State synth_state; +static SimpleSynth* simplesynth_ptr; + +#endif diff --git a/attic/muse_qt4_evolution/synti/simpledrums/simpledrumsgui.cpp b/attic/muse_qt4_evolution/synti/simpledrums/simpledrumsgui.cpp new file mode 100644 index 00000000..bc3e3e92 --- /dev/null +++ b/attic/muse_qt4_evolution/synti/simpledrums/simpledrumsgui.cpp @@ -0,0 +1,881 @@ +// +// C++ Implementation: testogui +// +// Description: +// +// +// Author: Mathias Lundgren <lunar_shuttle@users.sf.net>, (C) 2004 +// +// Copyright: See COPYING file that comes with this distribution +// +// + +#include "simpledrumsgui.h" +#include "libsynti/midievent.h" +#include "muse/midi.h" +#include "ssplugingui.h" + +#define SS_VOLUME_MIN_VALUE 0 +#define SS_VOLUME_MAX_VALUE 127 +#define SS_VOLUME_DEFAULT_VALUE 100 +#define SS_MASTERVOL_MAX_VALUE 127 +#define SS_MASTERVOL_DEFAULT_VALUE 100.0/127.0 +#define SS_SENDFX_MIN_VALUE 0 +#define SS_SENDFX_MAX_VALUE 127 + +//Gui constants: +#define SS_BTNGRP_WIDTH 50 +#define SS_BTNGRP_HEIGHT 80 +#define SS_ONOFF_WIDTH 16 +#define SS_ONOFF_HEIGHT 21 +#define SS_VOLSLDR_WIDTH (SS_BTNGRP_WIDTH - 8) +#define SS_VOLSLDR_LENGTH 120 +#define SS_PANSLDR_WIDTH (SS_BTNGRP_WIDTH - 8) +#define SS_PANSLDR_LENGTH 20 +#define SS_PANSLDR_DEFAULT_VALUE 63 +#define SS_NONOFF_LABEL_WIDTH 30 +#define SS_NONOFF_LABEL_HEIGHT 16 +#define SS_NONOFF_WIDTH SS_ONOFF_WIDTH +#define SS_NONOFF_HEIGHT SS_ONOFF_HEIGHT +#define SS_SENDFX_WIDTH ((SS_BTNGRP_WIDTH/2) - 4) +//#define SS_SENDFX_WIDTH 28 +#define SS_SENDFX_HEIGHT SS_SENDFX_WIDTH +#define SS_MASTERSLDR_WIDTH (SS_BTNGRP_WIDTH - 8) +#define SS_MASTERSLDR_HEIGHT (SS_BTNGRP_HEIGHT - 4) + + +// Sample groupbox + +#define SS_SAMPLENAME_LABEL_WIDTH 30 +#define SS_SAMPLENAME_LABEL_HEIGHT 21 +#define SS_SAMPLENAME_LABEL_XOFF 4 + +#define SS_SAMPLE_LOAD_WIDTH 15 +#define SS_SAMPLE_LOAD_HEIGHT 19 + +#define SS_SAMPLE_CLEAR_WIDTH SS_SAMPLE_LOAD_WIDTH +#define SS_SAMPLE_CLEAR_HEIGHT SS_SAMPLE_LOAD_HEIGHT + +#define SS_SAMPLENAME_LINEEDIT_WIDTH 90 +#define SS_SAMPLENAME_LINEEDIT_HEIGHT 21 + +#define SS_SAMPLE_INFO_LINE_HEIGHT 22 +#define SS_SAMPLE_INFO_LINE_WIDTH (SS_SAMPLENAME_LINEEDIT_XOFF + SS_SAMPLENAME_LINEEDIT_WIDTH) + +#define SS_GUI_WINDOW_WIDTH ((SS_NR_OF_CHANNELS +1) * SS_BTNGRP_XOFF) +#define SS_MAIN_GROUPBOX_HEIGHT 200 +#define SS_GUI_WINDOW_HEIGHT (SS_BTNGRP_HEIGHT + SS_MAIN_GROUPBOX_HEIGHT) +#define SS_MAIN_GROUPBOX_WIDTH SS_GUI_WINDOW_WIDTH + +SimpleSynthGui* simplesynthgui_ptr; + + +/*! + \fn QChannelSlider::QChannelSlider(Qt::Orientation orientation, int ch, QWidget* parent, const char* name) + */ +QChannelSlider::QChannelSlider(Qt::Orientation orientation, int ch, QWidget* parent) + : QSlider(orientation, parent) + { + channel = ch; + } + + +/*! + \fn QChannelSlider::getChannel() + */ +int QChannelSlider::getChannel() + { + return channel; + } + + +/*! + \fn QChannelSlider::setChannel(int ch) + */ +void QChannelSlider::setChannel(int ch) + { + channel = ch; + } + +/*! + \fn QChannelSlider::setValue(int val) + */ +void QChannelSlider::setValue(int val) + { + val = (val > 127 ? 127 : val); + val = (val < 0 ? 0 : val); + QSlider::setValue(val); + emit valueChanged(channel, val); + } + +/*! + \fn QInvertedChannelSlider::setValue(int val) + */ +void QInvertedChannelSlider::setValue(int val) + { + int inverted = this->maximum() - val; + inverted = (inverted > 127 ? 127 : inverted); + inverted = (inverted < 0 ? 0 : inverted); + QSlider::setValue(val); + emit valueChanged(channel, inverted); + } + +/*! + \fn QInvertedSlider::setValue(int val) + */ +void QInvertedSlider::setValue(int val) + { + int inverted = this->maximum() - val; + inverted = (inverted > 127 ? 127 : inverted); + inverted = (inverted < 0 ? 0 : inverted); + emit invertedValueChanged(inverted); + QSlider::setValue(val); + } + + +/*! + \fn QChannelCheckbox::QChannelCheckbox(QWidget* parent, int ch) + */ +QChannelCheckbox::QChannelCheckbox(QWidget* parent, int ch) + : QCheckBox(parent) + { + channel = ch; + connect(this, SIGNAL(clicked()), SLOT(isClicked())); + } + + +/*! + \fn QChannelCheckbox::isClicked() + */ +void QChannelCheckbox::isClicked() + { + emit channelState(channel, this->isChecked()); + } + +/*! + \fn QChannelButton::QChannelButton(QWidget* parent, const char* text, int ch, const char* name) + */ +QChannelButton::QChannelButton(QWidget* parent, const char* text, int ch) + : QPushButton(parent), channel (ch) + { + connect(this, SIGNAL(clicked()), SLOT(isClicked())); + setText(text); + } + +/*! + \fn QChannelButton::isClicked() + */ +void QChannelButton::isClicked() + { + emit channelState(channel, this->isChecked()); + } + +/*! + \fn QChannelDial() + */ +QChannelDial::QChannelDial(QWidget* parent, int ch, int fxid) + : QDial(parent) + { + setTracking(true); + channel = ch; + sendfxid = fxid; + } + +/*! + \fn QChannelSlider::setValue(int val) + */ +void QChannelDial::setValue(int val) + { + QDial::setValue(val); + emit valueChanged(channel, sendfxid, val); + } + +/*! + \fn SimpleSynthGui::SimpleSynthGui() + */ +SimpleSynthGui::SimpleSynthGui() + { + SS_TRACE_IN + setupUi(this); + simplesynthgui_ptr = this; + pluginGui = new SS_PluginGui(this); + pluginGui->hide(); + + QVBoxLayout* mainLayout = new QVBoxLayout(this); //, 3); + QHBoxLayout* channelLayout = new QHBoxLayout; + mainLayout->addLayout(channelLayout); + + //this->setFixedWidth(SS_GUI_WINDOW_WIDTH); + //this->setFixedHeight(SS_GUI_WINDOW_HEIGHT); + for (int i=0; i<SS_NR_OF_CHANNELS; i++) { + channelButtonGroups[i] = new QGroupBox(this); +// channelButtonGroups[i]->setMinimumSize(SS_BTNGRP_WIDTH, SS_BTNGRP_HEIGHT); + channelButtonGroups[i]->setTitle(QString::number(i + 1)); + + QString name = QString("volumeSlider"); + name.append(i + 1); + + channelLayout->addWidget(channelButtonGroups[i]); + + QVBoxLayout* inchnlLayout = new QVBoxLayout(channelButtonGroups[i]); //, 2, 0, "channelinternallayout"); + inchnlLayout->setAlignment(Qt::AlignHCenter); + + onOff[i] = new QChannelCheckbox(channelButtonGroups[i], i); +// onOff[i]->setMinimumSize(SS_ONOFF_WIDTH, SS_ONOFF_HEIGHT); + onOff[i]->setToolTip("Channel " + QString::number(i + 1) + " on/off"); + inchnlLayout->addWidget(onOff[i]); + connect(onOff[i], SIGNAL(channelState(int, bool)), SLOT(channelOnOff(int, bool))); + + volumeSliders[i] = new QInvertedChannelSlider(Qt::Vertical, i, channelButtonGroups[i]); + volumeSliders[i]->setMinimum(SS_VOLUME_MIN_VALUE); + volumeSliders[i]->setMaximum(SS_VOLUME_MAX_VALUE); + volumeSliders[i]->setValue(SS_VOLUME_MAX_VALUE - SS_VOLUME_DEFAULT_VALUE); +// volumeSliders[i]->setMinimumSize(SS_VOLSLDR_WIDTH, SS_VOLSLDR_LENGTH); + volumeSliders[i]->setToolTip("Volume, channel " + QString::number(i + 1)); +// setMinimumSize(SS_VOLSLDR_WIDTH, SS_VOLSLDR_LENGTH); + inchnlLayout->addWidget(volumeSliders[i]); + connect(volumeSliders[i], SIGNAL(valueChanged(int, int)), SLOT(volumeChanged(int, int))); + + nOffLabel[i] = new QLabel(channelButtonGroups[i]); +// nOffLabel[i]->setMinimumSize(SS_NONOFF_LABEL_WIDTH, SS_NONOFF_LABEL_HEIGHT); + nOffLabel[i]->setText("nOff"); + inchnlLayout->addWidget(nOffLabel[i]); + + nOffIgnore[i] = new QChannelCheckbox(channelButtonGroups[i], i); +// nOffIgnore[i]->setMinimumSize(SS_NONOFF_WIDTH, SS_NONOFF_HEIGHT); + nOffIgnore[i]->setToolTip("Note off ignore, channel " + QString::number(i + 1)); + inchnlLayout->addWidget(nOffIgnore[i]); + connect(nOffIgnore[i], SIGNAL(channelState(int, bool)),SLOT(channelNoteOffIgnore(int, bool))); + + panSliders[i] = new QChannelSlider(Qt::Horizontal, i, channelButtonGroups[i]); + panSliders[i]->setRange(0, 127); + panSliders[i]->setValue(SS_PANSLDR_DEFAULT_VALUE); +// panSliders[i]->setMinimumSize(SS_PANSLDR_WIDTH, SS_PANSLDR_LENGTH); + panSliders[i]->setToolTip("Pan, channel " + QString::number(i + 1)); + inchnlLayout->addWidget(panSliders[i]); + connect(panSliders[i], SIGNAL(valueChanged(int, int)), SLOT(panChanged(int, int))); + + QGridLayout* dialGrid = new QGridLayout; + inchnlLayout->addLayout(dialGrid); + sendFxDial[i][0] = new QChannelDial(channelButtonGroups[i], i, 0); + sendFxDial[i][0]->setRange(0, 127); + sendFxDial[i][0]->setMaximumSize(SS_SENDFX_WIDTH, SS_SENDFX_HEIGHT); + sendFxDial[i][0]->setToolTip("Fx 1 send amount"); + //inchnlLayout->addWidget(sendFxDial[i][0]); + dialGrid->addWidget(sendFxDial[i][0], 0, 0, Qt::AlignCenter | Qt::AlignTop); + + connect(sendFxDial[i][0], SIGNAL(valueChanged(int, int, int)), SLOT(sendFxChanged(int, int, int))); + + sendFxDial[i][1] = new QChannelDial(channelButtonGroups[i], i, 1); + sendFxDial[i][1]->setRange(0, 127); + //inchnlLayout->add(sendFxDial[i][1]); + dialGrid->addWidget(sendFxDial[i][1], 0, 1, Qt::AlignCenter | Qt::AlignTop); + sendFxDial[i][1]->setMaximumSize(SS_SENDFX_WIDTH, SS_SENDFX_HEIGHT); + sendFxDial[i][1]->setToolTip("Fx 2 send amount"); + + connect(sendFxDial[i][1], SIGNAL(valueChanged(int, int, int)), SLOT(sendFxChanged(int, int, int))); + + sendFxDial[i][2] = new QChannelDial(channelButtonGroups[i], i, 2); + sendFxDial[i][2]->setRange(0, 127); + sendFxDial[i][2]->setMaximumSize(SS_SENDFX_WIDTH, SS_SENDFX_HEIGHT); + //inchnlLayout->add(sendFxDial[i][2]); + dialGrid->addWidget(sendFxDial[i][2], 1, 0, Qt::AlignCenter | Qt::AlignTop); + sendFxDial[i][2]->setToolTip("Fx 3 send amount"); + connect(sendFxDial[i][2], SIGNAL(valueChanged(int, int, int)), SLOT(sendFxChanged(int, int, int))); + + sendFxDial[i][3] = new QChannelDial(channelButtonGroups[i], i, 3); + sendFxDial[i][3]->setRange(0, 127); + sendFxDial[i][3]->setMaximumSize(SS_SENDFX_WIDTH, SS_SENDFX_HEIGHT); + sendFxDial[i][3]->setToolTip("Fx 4 send amount"); + + dialGrid->addWidget(sendFxDial[i][3], 1, 1, Qt::AlignCenter | Qt::AlignTop); + connect(sendFxDial[i][3], SIGNAL(valueChanged(int, int, int)), SLOT(sendFxChanged(int, int, int))); + inchnlLayout->activate(); + //channelLayout->activate(); + } + + //Master buttongroup: + masterButtonGroup = new QGroupBox(this); + channelLayout->addWidget(masterButtonGroup); + QVBoxLayout* mbgLayout = new QVBoxLayout(masterButtonGroup); + mbgLayout->setAlignment(Qt::AlignCenter); +// masterButtonGroup->setMinimumSize(SS_BTNGRP_WIDTH, SS_BTNGRP_HEIGHT); + masterSlider = new QInvertedSlider(Qt::Vertical, masterButtonGroup); + masterSlider->setToolTip("Master volume"); + mbgLayout->addWidget(masterSlider); + masterSlider->setRange(0, 127); + masterSlider->setValue(SS_VOLUME_MAX_VALUE - (int)(SS_MASTERVOL_DEFAULT_VALUE*SS_VOLUME_MAX_VALUE)); +// masterSlider->setMinimumSize(SS_MASTERSLDR_WIDTH, SS_MASTERSLDR_HEIGHT); + connect(masterSlider, SIGNAL(invertedValueChanged(int)), SLOT(masterVolChanged(int))); + + //Main groupbox + mainGroupBox = new QGroupBox(this); + mainLayout->addWidget(mainGroupBox); + + QGridLayout* mgbLayout = new QGridLayout(mainGroupBox); // , 8, 3, 1); + + int i=0; + + for (int c=0; c<2; c++) { + for (int r=0; r<SS_NR_OF_CHANNELS/2; r++) { + QHBoxLayout* strip = new QHBoxLayout;//(mgbLayout, 5); + mgbLayout->addLayout(strip, r, c); + + QLabel* channelLabel = new QLabel(QString("Ch ") + QString::number(i + 1), mainGroupBox); + strip->addWidget(channelLabel); + + sampleNameLineEdit[i] = new QLineEdit(mainGroupBox); + sampleNameLineEdit[i]->setReadOnly(true); + strip->addWidget(sampleNameLineEdit[i]); + + loadSampleButton[i] = new QChannelButton(mainGroupBox, "L", i); +// loadSampleButton[i]->setMinimumSize(SS_SAMPLE_LOAD_WIDTH, SS_SAMPLE_LOAD_HEIGHT); + loadSampleButton[i]->setToolTip("Load sample on channel " + QString::number(i + 1)); + strip->addWidget(loadSampleButton[i]); + connect(loadSampleButton[i], SIGNAL(channelState(int, bool)), SLOT(loadSampleDialogue(int))); + + clearSampleButton[i] = new QChannelButton(mainGroupBox, "C", i); +// clearSampleButton[i]->setMinimumSize(SS_SAMPLE_CLEAR_WIDTH, SS_SAMPLE_CLEAR_HEIGHT); + clearSampleButton[i]->setToolTip("Clear sample on channel " + QString::number(i + 1)); + strip->addWidget(clearSampleButton[i]); + connect(clearSampleButton[i], SIGNAL(channelState(int, bool)), SLOT(clearSample(int))); + + i++; + } + } + + // Right bottom panel: + QGroupBox* rbPanel= new QGroupBox(mainGroupBox); + mgbLayout->addWidget(rbPanel, 1, 3, 7, 1, Qt::AlignCenter); + QGridLayout* rbLayout = new QGridLayout(rbPanel); // 6, 1, 8, 5); + + openPluginsButton = new QPushButton("&Send Effects"); + openPluginsButton->setToolTip("Configure LADSPA send effects"); + connect(openPluginsButton, SIGNAL(clicked()), SLOT(openPluginButtonClicked())); + rbLayout->addWidget(openPluginsButton, 2, 1, Qt::AlignCenter | Qt::AlignVCenter); + aboutButton = new QPushButton("About SimpleDrums"); + connect(aboutButton, SIGNAL(clicked()), SLOT(aboutButtonClicked())); +//TD rbLayout->addRowSpacing(3, 20); + rbLayout->addWidget(aboutButton, 4, 1, Qt::AlignLeft | Qt::AlignVCenter); + + + loadButton = new QPushButton(tr("&Load setup"), rbPanel); + connect(loadButton, SIGNAL(clicked()), SLOT(loadSetup())); + saveButton = new QPushButton(tr("&Save setup"), rbPanel); + connect(saveButton, SIGNAL(clicked()), SLOT(saveSetup())); + //rbLayout->addWidget(openPluginsButton, 1, 1, Qt::AlignCenter | Qt::AlignVCenter); +// rbLayout->addRowSpacing(2, 20); + rbLayout->addWidget(loadButton, 3, 1, Qt::AlignCenter | Qt::AlignVCenter); + rbLayout->addWidget(saveButton, 4, 1, Qt::AlignCenter | Qt::AlignVCenter); +// rbLayout->addRowSpacing(5, 20); + rbLayout->addWidget(aboutButton, 6, 1, Qt::AlignCenter | Qt::AlignVCenter); + + lastDir = ""; + //Connect socketnotifier to fifo + QSocketNotifier* s = new QSocketNotifier(readFd, QSocketNotifier::Read); + connect(s, SIGNAL(activated(int)), SLOT(readMessage(int))); + SS_TRACE_OUT + } + +/*! + \fn SimpleSynthGui::~SimpleSynthGui() + */ +SimpleSynthGui::~SimpleSynthGui() + { + SS_TRACE_IN + simplesynthgui_ptr = 0; + delete pluginGui; + SS_TRACE_OUT + } + +/*! + \fn SimpleSynthGui::readMessage(int) + */ +void SimpleSynthGui::readMessage(int) + { + MessGui::readMessage(); + } + +/*! + \fn SimpleSynthGui::processEvent(const MidiEvent& ev) + */ +void SimpleSynthGui::processEvent(const MidiEvent& ev) + { + SS_TRACE_IN + if (SS_DEBUG_MIDI) { + printf("GUI received midi event\n"); + } + if (ev.type() == ME_CONTROLLER) { + int id = ev.dataA(); + int val = ev.dataB(); + + // Channel controllers: + if (id >= SS_FIRST_CHANNEL_CONTROLLER && id <= SS_LAST_CHANNEL_CONTROLLER ) { + // Find out which channel we're dealing with: + id-= SS_FIRST_CHANNEL_CONTROLLER; + int ch = (id / SS_NR_OF_CHANNEL_CONTROLLERS); + id = (id % SS_NR_OF_CHANNEL_CONTROLLERS); + + int fxid = -1; + + if (SS_DEBUG_MIDI) { + printf("GUI received midi controller - id: %d val %d channel %d\n", id, val, ch); + } + + switch(id) { + case SS_CHANNEL_CTRL_VOLUME: + volumeSliders[ch]->blockSignals(true); + volumeSliders[ch]->setValue(SS_VOLUME_MAX_VALUE - val); + volumeSliders[ch]->blockSignals(false); + break; + + case SS_CHANNEL_CTRL_PAN: + panSliders[ch]->blockSignals(true); + panSliders[ch]->setValue(val); + panSliders[ch]->blockSignals(false); + break; + + case SS_CHANNEL_CTRL_NOFF: + nOffIgnore[ch]->blockSignals(true); + nOffIgnore[ch]->setChecked(val); + nOffIgnore[ch]->blockSignals(false); + break; + + case SS_CHANNEL_CTRL_ONOFF: + onOff[ch]->blockSignals(true); + onOff[ch]->setChecked(val); + onOff[ch]->blockSignals(false); + break; + + case SS_CHANNEL_SENDFX1: + case SS_CHANNEL_SENDFX2: + case SS_CHANNEL_SENDFX3: + case SS_CHANNEL_SENDFX4: + fxid = id - SS_CHANNEL_SENDFX1; + if (SS_DEBUG_MIDI) { + printf("SimpleSynthGui::processEvent - Channel sendfx, fxid: %d, val: %d\n", fxid, val); + } + sendFxDial[ch][fxid]->blockSignals(true); + sendFxDial[ch][fxid]->setValue(val); + sendFxDial[ch][fxid]->blockSignals(false); + break; + + default: + if (SS_DEBUG_MIDI) + printf("SimpleSynthGui::processEvent - unknown controller received: %d\n", id); + } + } + // Master controllers: + else if (id >= SS_FIRST_MASTER_CONTROLLER && id <= SS_LAST_MASTER_CONTROLLER) { + if (id == SS_MASTER_CTRL_VOLUME) { + masterSlider->blockSignals(true); + masterSlider->setValue(SS_MASTERVOL_MAX_VALUE - val); + masterSlider->blockSignals(false); + } + } + else if (id>= SS_FIRST_PLUGIN_CONTROLLER && id <= SS_LAST_PLUGIN_CONTROLLER) { + int fxid = (id - SS_FIRST_PLUGIN_CONTROLLER) / SS_NR_OF_PLUGIN_CONTROLLERS; + int cmd = (id - SS_FIRST_PLUGIN_CONTROLLER) % SS_NR_OF_PLUGIN_CONTROLLERS; + + // Plugin return-gain: + if (cmd == SS_PLUGIN_RETURN) { + if (SS_DEBUG_MIDI) + printf("SimpleSynthGui::processEvent - fx retgain received: fxid: %d val: %d\n", fxid, val); + + SS_PluginFront* pf = pluginGui->getPluginFront((unsigned)fxid); + pf->setRetGain(val); + } + } + } + // + // Sysexes: + // + else if (ev.type() == ME_SYSEX) { + byte* data = ev.data(); + int cmd = *data; + switch (cmd) { + case SS_SYSEX_LOAD_SAMPLE_OK: { + int ch = *(data+1); + QString filename = (const char*) (data+2); + sampleNameLineEdit[ch]->setText(filename.section('/',-1,-1)); + if (SS_DEBUG_MIDI) { + printf("SimpleSynthGui - sample %s loaded OK on channel: %d\n", filename.toLatin1().data(), ch); + } + if (!onOff[ch]->isChecked()) { + onOff[ch]->blockSignals(true); + onOff[ch]->setChecked(true); + onOff[ch]->blockSignals(false); + channelOnOff(ch, true); + } + break; + } + + case SS_SYSEX_LOAD_SAMPLE_ERROR: { + //int ch = *(data+1); + const char* filename = (const char*) (data+2); + /*QMessageBox* yn = new QMessageBox("Sample not found", "Failed to load sample: " + QString(filename) + "\n" + + "Do you want to open file browser and try to locate it elsewhere?", + QMessageBox::Warning, + QMessageBox::Yes, + QMessageBox::No, + QMessageBox::NoButton, + this);*/ + /*int res = QMessageBox::warning(this, + "SimpleDrums","Failed to load sample: " + QString(filename) + "\n" + + "Do you want to open file browser and try to locate it elsewhere?", + "&Yes", "&No"); + */ + //int res = yn->exec(); + printf("Error: Sample %s not found! TODO: Fix this\n", filename); + //if (res == 0) { + // loadSampleDialogue(ch); + // } + break; + } + + case SS_SYSEX_LOAD_SENDEFFECT_OK: { + if (SS_DEBUG_MIDI) { + printf("SimpleSynthGui - sysex load sendeffect OK on fxid: %d\n", *(data+1)); + } + int fxid = *(data+1); + SS_PluginFront* pf = pluginGui->getPluginFront((unsigned)fxid); + pf->updatePluginValue(*(data+2)); + break; + } + + case SS_SYSEX_CLEAR_SENDEFFECT_OK: { + if (SS_DEBUG_MIDI) { + printf("SimpleSynthGui - sysex clear sendeffect OK on fxid: %d\n", *(data+1)); + } + SS_PluginFront* pf = pluginGui->getPluginFront((unsigned)*(data+1)); + pf->clearPluginDisplay(); + break; + } + + case SS_SYSEX_CLEAR_SAMPLE_OK: { + if (SS_DEBUG_MIDI) { + printf("SimpleSynthGui - sysex clear samle OK on channel: %d\n", *(data+1)); + } + byte ch = *(data+1); + sampleNameLineEdit[ch]->setText(""); + break; + } + + case SS_SYSEX_SET_PLUGIN_PARAMETER_OK: { + if (SS_DEBUG_MIDI) { + printf("SimpleSynthGui - plugin parameter OK on fxid: %d\n", *(data+1)); + } + SS_PluginFront* pf = pluginGui->getPluginFront((unsigned)*(data+1)); + int param = *(data+2); + int val = *(data+3); + pf->blockSignals(true); + pf->setParameterValue(param, val); + pf->blockSignals(false); + break; + } + + case SS_SYSEX_SEND_INIT_DATA: { +// FN: TODO +#if 1 + const unsigned initdata_len = ev.len() - 1; + byte* init_data = (data + 1); + QFileInfo fileInfo = QFileInfo(lastSavedProject); + + lastProjectDir = fileInfo.path(); + if (fileInfo.suffix() != "sds" && fileInfo.suffix() != "SDS") { + lastSavedProject += ".sds"; + fileInfo = QFileInfo(lastSavedProject); + } + QFile theFile(fileInfo.filePath()); + + // Write data + if (theFile.open(QIODevice::WriteOnly)) { + theFile.write((const char*)&initdata_len, sizeof(initdata_len)); // First write length + if (theFile.write((const char*)init_data, initdata_len) == -1) { + // Fatal error writing + QMessageBox* msgBox = new QMessageBox(QMessageBox::Warning, "SimpleDrums error Dialog", "Fatal error when writing to file. Setup not saved.", + QMessageBox::Ok, this); + msgBox->exec(); + delete msgBox; + } + theFile.close(); + } + else { + // An error occured when opening + QMessageBox* msgBox = new QMessageBox(QMessageBox::Warning, "SimpleDrums error Dialog", "Error opening file. Setup was not saved.", + QMessageBox::Ok, this); + msgBox->exec(); + delete msgBox; + } +#endif + + break; + } + + + default: + if (SS_DEBUG_MIDI) { + printf("SimpleSynthGui::processEvent - unknown sysex cmd received: %d\n", cmd); + } + break; + } + } + SS_TRACE_OUT + } + + +/*! + \fn SimpleSynthGui::volumeChanged(int val) + */ +void SimpleSynthGui::volumeChanged(int channel, int val) + { + setChannelVolume(channel, val); + } + +/*! + \fn SimpleSynthGui::panChanged(int channel, int value) + */ +void SimpleSynthGui::panChanged(int channel, int value) + { + sendController(0, SS_CHANNEL_PAN_CONTROLLER(channel), value); + } + +/*! + \fn SimpleSynthGui::channelOnOff(int channel, bool state) + */ +void SimpleSynthGui::channelOnOff(int channel, bool state) + { + sendController(0, SS_CHANNEL_ONOFF_CONTROLLER(channel), state); + } + +/*! + \fn SimpleSynthGui::channelNoteOffIgnore(bool state) + */ +void SimpleSynthGui::channelNoteOffIgnore(int channel, bool state) + { + sendController(0, SS_CHANNEL_NOFF_CONTROLLER(channel), (int) state); + } + +/*! + \fn SimpleSynthGui::sendFxChanged(int ch, int fxid, int val) + */ +void SimpleSynthGui::sendFxChanged(int ch, int fxid, int val) + { + sendController(0, SS_CHANNEL_SENDFX_CONTROLLER(ch, fxid), (int) val); + } + +/*! + \fn SimpleSynthGui::masterVolChanged(int val) + */ +void SimpleSynthGui::masterVolChanged(int val) + { + sendController(0, SS_MASTER_CTRL_VOLUME, val); + } + +/*! + \fn SimpleSynthGui::setChannelVolume(int channel, byte volume) + */ +void SimpleSynthGui::setChannelVolume(int channel, int volume) + { + //volumeSliders[channel]->setValue(SS_VOLUME_MAX_VALUE - volume); + sendController(0, SS_CHANNEL_VOLUME_CONTROLLER(channel), (int)volume); + } + + +/*! + \fn SimpleSynthGui::loadSampleDialogue(int channel) + */ +void SimpleSynthGui::loadSampleDialogue(int channel) + { + QString filename = + QFileDialog::getOpenFileName( + this, + tr("Load sample dialog"), + lastDir, + QString("*.wav *.WAV")); + + if (filename != QString::null) { + QFileInfo fi(filename); + lastDir = fi.path(); + + if (SS_DEBUG) + printf("lastDir = %s\n", lastDir.toLatin1().data()); + + int l = filename.length() + 4; + byte d[l]; + + d[0] = SS_SYSEX_LOAD_SAMPLE; + d[1] = (byte) channel; + d[2] = (byte) filename.length(); + memcpy(d+3, filename.toLatin1().data(), filename.length()+1); + sendSysex(d, l); + } + } + + + +/*! + \fn SimpleSynthGui::clearSample(int ch) + */ +void SimpleSynthGui::clearSample(int ch) + { + if (sampleNameLineEdit[ch]->text().length() > 0) { //OK, we've got a live one here + byte d[2]; + d[0] = SS_SYSEX_CLEAR_SAMPLE; + d[1] = (byte) ch; + sendSysex(d, 2); + sampleNameLineEdit[ch]->setText(""); + } + } + +/*! + \fn SimpleSynthGui::displayPluginGui() + */ +void SimpleSynthGui::displayPluginGui() + { + pluginGui->show(); + } + +/*! + \fn SimpleSynthGui::loadEffectInvoked(int fxid, QString lib, QString label) + */ +void SimpleSynthGui::loadEffectInvoked(int fxid, QString lib, QString label) + { + int l = 4 + lib.length() + label.length(); + byte d[l]; + d[0] = SS_SYSEX_LOAD_SENDEFFECT; + d[1] = (byte) fxid; + memcpy (d+2, lib.toLatin1().data(), lib.length()+1); + memcpy (d+3+lib.length(), label.toLatin1().data(), label.length()+1); + sendSysex(d, l); + } + + +/*! + \fn SimpleSynthGui::returnLevelChanged(int fxid, int val) + */ +void SimpleSynthGui::returnLevelChanged(int fxid, int val) + { + sendController(0, SS_PLUGIN_RETURNLEVEL_CONTROLLER(fxid), val); + } + + +/*! + \fn SimpleSynthGui::toggleEffectOnOff(int fxid, int state) + */ +void SimpleSynthGui::toggleEffectOnOff(int fxid, int state) + { + sendController(0, SS_PLUGIN_ONOFF_CONTROLLER(fxid), state); + } + + +/*! + \fn SimpleSynthGui::clearPlugin(int fxid) + */ +void SimpleSynthGui::clearPlugin(int fxid) + { + byte d[2]; + d[0] = SS_SYSEX_CLEAR_SENDEFFECT; + d[1] = fxid; + sendSysex(d, 2); + } + + +/*! + \fn SimpleSynthGui::effectParameterChanged(int fxid, int parameter, int val) + */ +void SimpleSynthGui::effectParameterChanged(int fxid, int parameter, int val) + { + //printf("Gui: effectParameterChanged: %d %d %d\n", fxid, parameter, val); + int len = 4; + byte d[len]; + d[0] = SS_SYSEX_SET_PLUGIN_PARAMETER; + d[1] = (byte) fxid; + d[2] = (byte) parameter; + d[3] = (byte) val; + sendSysex(d, len); + } + + +/*! + \fn SimpleSynthGui::openPluginButtonClicked() + */ +void SimpleSynthGui::openPluginButtonClicked() + { + if (pluginGui->isVisible()) + pluginGui->raise(); + else + displayPluginGui(); + } + + +/*! + \fn SimpleSynthGui::aboutButtonClicked() + */ +void SimpleSynthGui::aboutButtonClicked() + { + QString caption = "SimpleDrums ver"; + caption+= SS_VERSIONSTRING; + QString text = caption + "\n\n(C) Copyright 2000-2004 Mathias Lundgren (lunar_shuttle@users.sf.net), Werner Schweer\nPublished under the GNU Public License"; + QMessageBox* msgBox = new QMessageBox(caption, text, QMessageBox::NoIcon, + QMessageBox::Ok, Qt::NoButton, Qt::NoButton, this); + msgBox->exec(); + } + + +/*! + \fn SimpleSynthGui::loadSetup() + \brief Load setup from file + */ +void SimpleSynthGui::loadSetup() + { + bool success = true; + QString filename = + QFileDialog::getOpenFileName(this, "Load setup dialog", lastProjectDir, + QString("*.sds *.SDS")); + + if (filename != QString::null) { + QFile theFile(filename); + if (theFile.open(QIODevice::ReadOnly)) { + unsigned initdata_len = 0; + if (theFile.read((char*)&initdata_len, sizeof(initdata_len)) == -1) + success = false; + + byte* init_data = new byte[initdata_len]; + if (theFile.read((char*)(init_data), initdata_len) == -1) + success = false; + + if (!success) { + QMessageBox* msgBox = new QMessageBox(QMessageBox::Warning, "SimpleDrums Error Dialog", "Error opening/reading from file. Setup not loaded.", + QMessageBox::Ok, this); + msgBox->exec(); + delete msgBox; + } + else { + sendSysex(init_data, initdata_len); + } + + delete[] init_data; + } + } + } + + +/*! + \fn SimpleSynthGui::saveSetup() + \brief Save setup to file + */ +void SimpleSynthGui::saveSetup() + { + QString filename = + QFileDialog::getSaveFileName(this, "Save setup dialog", lastProjectDir, + QString("*.sds *.SDS")); + + if (filename != QString::null) { + lastSavedProject = filename; + byte d[1]; + d[0] = SS_SYSEX_GET_INIT_DATA; + sendSysex(d, 1); // Makes synth send gui initdata, where rest of the saving takes place + } + } + diff --git a/attic/muse_qt4_evolution/synti/simpledrums/simpledrumsgui.h b/attic/muse_qt4_evolution/synti/simpledrums/simpledrumsgui.h new file mode 100644 index 00000000..b3436f5d --- /dev/null +++ b/attic/muse_qt4_evolution/synti/simpledrums/simpledrumsgui.h @@ -0,0 +1,206 @@ +// +// C++ Interface: testogui +// +// Description: +// +// +// Author: Mathias Lundgren <lunar_shuttle@users.sf.net>, (C) 2004 +// +// Copyright: See COPYING file that comes with this distribution +// +// +#ifndef __MUSE_TESTOGUI_H__ +#define __MUSE_TESTOGUI_H__ + +#include "libsynti/gui.h" +#include "ui_simpledrumsguibase.h" +#include "common.h" + +class QButtonGroup; +class QLabel; +class SS_PluginGui; + +//-------------------------------------- +// QChannelSlider +//-------------------------------------- +class QChannelSlider: public QSlider + { + Q_OBJECT + + public: + QChannelSlider(Qt::Orientation, int ch, QWidget* paren = 0); + int getChannel(); + void setChannel(int ch); + + public slots: + virtual void setValue(int val); + + signals: + void valueChanged(int channel, int value); + + protected: + int channel; + }; + +//-------------------------------------- +// QInvertedSlider +//-------------------------------------- +class QInvertedSlider : public QSlider + { + Q_OBJECT + public: + QInvertedSlider(Qt::Orientation o, QWidget* parent = 0) + : QSlider(o, parent) {} + + public slots: + virtual void setValue(int val); + + signals: + void invertedValueChanged(int value); + }; + +//-------------------------------------- +// QInvertedChannelSlider +//-------------------------------------- +class QInvertedChannelSlider : public QChannelSlider + { + Q_OBJECT + public: + QInvertedChannelSlider(Qt::Orientation o, int channel, QWidget* parent = 0) + : QChannelSlider(o, channel, parent) {}; + + public slots: + virtual void setValue(int val); + }; + + +//-------------------------------------- +// QChannelOnOff +//-------------------------------------- + +class QChannelCheckbox : public QCheckBox + { + Q_OBJECT + public: + QChannelCheckbox(QWidget* parent, int channel); + + private: + int channel; + + private slots: + void isClicked(); + + signals: + void channelState(int channel, bool state); + }; + +//-------------------------------------- +// QChannelButton +//-------------------------------------- +class QChannelButton : public QPushButton + { + Q_OBJECT + + private: + int channel; + + public: + QChannelButton(QWidget* parent, const char* text, int ch); + + private slots: + void isClicked(); + + signals: + void channelState(int channel, bool state); + + }; + +//-------------------------------------- +// QChannelDial +//-------------------------------------- + +class QChannelDial : public QDial + { + Q_OBJECT + + public: + QChannelDial(QWidget* parent, int ch, int fxid); + + signals: + void valueChanged(int channel, int fxid, int val); + + public slots: + virtual void setValue(int val); + + protected: + int channel; + int sendfxid; + }; + +//-------------------------------------- +// SimpleSynthGui - the Gui +//-------------------------------------- +class SimpleSynthGui : public QDialog, public Ui::SimpleDrumsGuiBase, public MessGui + { + Q_OBJECT + private: + // MESS interface: + virtual void processEvent(const MidiEvent& ev); + void setChannelVolume(int channel, int volume); + void displayPluginGui(); + QGroupBox* channelButtonGroups[SS_NR_OF_CHANNELS]; + QGroupBox* masterButtonGroup; + QGroupBox* mainGroupBox; + QInvertedChannelSlider* volumeSliders[SS_NR_OF_CHANNELS]; + QChannelSlider* panSliders[SS_NR_OF_CHANNELS]; + QChannelCheckbox* onOff[SS_NR_OF_CHANNELS]; + QChannelCheckbox* nOffIgnore[SS_NR_OF_CHANNELS]; + QChannelButton* loadSampleButton[SS_NR_OF_CHANNELS]; + QChannelButton* clearSampleButton[SS_NR_OF_CHANNELS]; + QLabel* nOffLabel[SS_NR_OF_CHANNELS]; + QLineEdit* sampleNameLineEdit[SS_NR_OF_CHANNELS]; + QInvertedSlider* masterSlider; + QChannelDial* sendFxDial[SS_NR_OF_CHANNELS][SS_NR_OF_SENDEFFECTS]; + + QPushButton* openPluginsButton; + QPushButton* aboutButton; + QPushButton* loadButton; + QPushButton* saveButton; + + + QString lastDir; + QString lastSavedProject; + QString lastProjectDir; + SS_PluginGui* pluginGui; + + public: + SimpleSynthGui(); + virtual ~SimpleSynthGui(); + + public slots: + void loadEffectInvoked(int fxid, QString lib, QString label); + void returnLevelChanged(int fxid, int val); + void toggleEffectOnOff(int fxid, int state); + void clearPlugin(int fxid); + void effectParameterChanged(int fxid, int parameter, int val); + + private slots: + void volumeChanged(int channel, int val); + void panChanged(int channel, int value); + void channelOnOff(int channel, bool state); + void channelNoteOffIgnore(int channel, bool state); + void masterVolChanged(int val); + void loadSampleDialogue(int channel); + void readMessage(int); + void clearSample(int ch); + void sendFxChanged(int ch, int fxid, int val); + void openPluginButtonClicked(); + void aboutButtonClicked(); + void loadSetup(); + void saveSetup(); + + }; + +extern SimpleSynthGui* simplesynthgui_ptr; + +#endif diff --git a/attic/muse_qt4_evolution/synti/simpledrums/simpledrumsguibase.ui b/attic/muse_qt4_evolution/synti/simpledrums/simpledrumsguibase.ui new file mode 100644 index 00000000..412bfdf6 --- /dev/null +++ b/attic/muse_qt4_evolution/synti/simpledrums/simpledrumsguibase.ui @@ -0,0 +1,23 @@ +<ui version="4.0" > + <author></author> + <comment></comment> + <exportmacro></exportmacro> + <class>SimpleDrumsGuiBase</class> + <widget class="QDialog" name="SimpleDrumsGuiBase" > + <property name="geometry" > + <rect> + <x>0</x> + <y>0</y> + <width>602</width> + <height>509</height> + </rect> + </property> + <property name="windowTitle" > + <string>DrumSynth 0.1</string> + </property> + </widget> + <layoutdefault spacing="6" margin="11" /> + <pixmapfunction>qPixmapFromMimeSource</pixmapfunction> + <resources/> + <connections/> +</ui> diff --git a/attic/muse_qt4_evolution/synti/simpledrums/ssplugin.cpp b/attic/muse_qt4_evolution/synti/simpledrums/ssplugin.cpp new file mode 100644 index 00000000..8d5c3d8f --- /dev/null +++ b/attic/muse_qt4_evolution/synti/simpledrums/ssplugin.cpp @@ -0,0 +1,456 @@ +// +// C++ Implementation: plugin +// +// Description: +// +// +// (C) Copyright 2000 Werner Schweer (ws@seh.de) +// Additions/modifications: Mathias Lundgren <lunar_shuttle@users.sf.net>, (C) 2004 +// Copyright: See COPYING file that comes with this distribution +// +// + +#include <dlfcn.h> +#include "ssplugin.h" +#include "common.h" + +PluginList plugins; + + +Plugin::Plugin(const QFileInfo* f) + : fi(*f) + { + } + +//--------------------------------------------------------- +// loadPluginLib +//--------------------------------------------------------- + +static void loadPluginLib(QFileInfo* fi) + { + SS_TRACE_IN + if (SS_DEBUG_LADSPA) { + printf("loadPluginLib: %s\n", fi->fileName().toLatin1().data()); + } + void* handle = dlopen(fi->filePath().toAscii().data(), RTLD_NOW); + if (handle == 0) { + fprintf(stderr, "dlopen(%s) failed: %s\n", + fi->filePath().toAscii().data(), dlerror()); + return; + } + LADSPA_Descriptor_Function ladspa = (LADSPA_Descriptor_Function)dlsym(handle, "ladspa_descriptor"); + + if (!ladspa) { + const char *txt = dlerror(); + if (txt) { + fprintf(stderr, + "Unable to find ladspa_descriptor() function in plugin " + "library file \"%s\": %s.\n" + "Are you sure this is a LADSPA plugin file?\n", + fi->filePath().toAscii().data(), + txt); + return;//exit(1); + } + } + const LADSPA_Descriptor* descr; + for (int i = 0;; ++i) { + descr = ladspa(i); + if (descr == NULL) + break; + plugins.push_back(new LadspaPlugin(fi, ladspa, descr)); + } + SS_TRACE_OUT + } + +//--------------------------------------------------------- +// loadPluginDir +//--------------------------------------------------------- + +static void loadPluginDir(const QString& s) + { + SS_TRACE_IN + QDir pluginDir(s, QString("*.so"), 0, QDir::Files); + if (pluginDir.exists()) { + QFileInfoList list = pluginDir.entryInfoList(); + int n = list.size(); + for (int i = 0; i < n; ++i) { + QFileInfo fi = list.at(i); + loadPluginLib(&fi); + } + } + SS_TRACE_OUT + } + +//--------------------------------------------------------- +// initPlugins +// search for LADSPA plugins +//--------------------------------------------------------- + +void SS_initPlugins() + { + SS_TRACE_IN + //loadPluginDir(museGlobalLib + QString("/plugins")); + + char* ladspaPath = getenv("LADSPA_PATH"); + if (ladspaPath == 0) + ladspaPath = "/usr/lib/ladspa:/usr/local/lib/ladspa"; + + char* p = ladspaPath; + while (*p != '\0') { + char* pe = p; + while (*pe != ':' && *pe != '\0') + pe++; + + int n = pe - p; + if (n) { + char* buffer = new char[n + 1]; + strncpy(buffer, p, n); + buffer[n] = '\0'; + loadPluginDir(QString(buffer)); + delete[] buffer; + } + p = pe; + if (*p == ':') + p++; + } + SS_TRACE_OUT + } + + +//--------------------------------------------------------- +// LadspaPlugin +//--------------------------------------------------------- + +LadspaPlugin::LadspaPlugin(const QFileInfo* f, + const LADSPA_Descriptor_Function ldf, + const LADSPA_Descriptor* d) + : Plugin(f), ladspa(ldf), plugin(d) + { + SS_TRACE_IN + _inports = 0; + _outports = 0; + _parameter = 0; + handle = 0; + active = false; + controls = 0; + inputs = 0; + outputs = 0; + + for (unsigned k = 0; k < plugin->PortCount; ++k) { + LADSPA_PortDescriptor pd = d->PortDescriptors[k]; + static const int CI = LADSPA_PORT_CONTROL | LADSPA_PORT_INPUT; + if ((pd & CI) == CI) { + ++_parameter; + pIdx.push_back(k); + } + else if (pd & LADSPA_PORT_INPUT) { + ++_inports; + iIdx.push_back(k); + } + else if (pd & LADSPA_PORT_OUTPUT) { + ++_outports; + oIdx.push_back(k); + } + } + + /*if (SS_DEBUG_LADSPA) { + printf("Label: %s\tLib: %s\tPortCount: %d\n", this->label().toLatin1().data(), this->lib().toLatin1().data(), plugin->PortCount); + printf("LADSPA_PORT_CONTROL|LADSPA_PORT_INPUT: %d\t", pIdx.size()); + printf("Input ports: %d\t", iIdx.size()); + printf("Output ports: %d\n\n", oIdx.size()); + }*/ + + LADSPA_Properties properties = plugin->Properties; + _inPlaceCapable = !LADSPA_IS_INPLACE_BROKEN(properties); + if (_inports != _outports) + _inPlaceCapable = false; + SS_TRACE_OUT + } + +//--------------------------------------------------------- +// ~LadspaPlugin +//--------------------------------------------------------- +LadspaPlugin::~LadspaPlugin() + { + SS_TRACE_IN + if (active) { + stop(); + } + if (handle) { + SS_DBG_LADSPA2("Cleaning up ", this->label().toLatin1().data()); + plugin->cleanup(handle); + } + + //Free ports: + if (controls) + delete controls; + if (inputs) + delete inputs; + if (outputs) + delete outputs; + SS_TRACE_OUT + } + +//--------------------------------------------------------- +// instantiate +//--------------------------------------------------------- + +bool LadspaPlugin::instantiate() + { + bool success = false; + handle = plugin->instantiate(plugin, SS_samplerate); + success = (handle != NULL); + if (success) + SS_DBG_LADSPA2("Plugin instantiated", label().toLatin1().data()); + return success; + } + +//--------------------------------------------------------- +// start +// activate and connect control ports +//--------------------------------------------------------- + +bool LadspaPlugin::start() + { + SS_TRACE_IN + if (handle) { + if (plugin->activate) { + plugin->activate(handle); + SS_DBG_LADSPA("Plugin activated"); + } + active = true; + } + else { + SS_DBG_LADSPA("Error trying to activate plugin - plugin not instantiated!"); + SS_TRACE_OUT + return false; + } + + //Connect ports: + controls = new Port[_parameter]; + + for (int k = 0; k < _parameter; ++k) { + double val = defaultValue(k); + controls[k].val = val; + plugin->connect_port(handle, pIdx[k], &controls[k].val); + } + + outputs = new Port[_outports]; + inputs = new Port[_inports]; + + SS_TRACE_OUT + return true; + } + +//--------------------------------------------------------- +// stop +// deactivate +//--------------------------------------------------------- +void LadspaPlugin::stop() + { + SS_TRACE_IN + if (handle) { + SS_DBG_LADSPA2("Trying to stop plugin", label().toLatin1().data()); + if (plugin->deactivate) { + SS_DBG_LADSPA2("Deactivating ", label().toLatin1().data()); + plugin->deactivate(handle); + active = false; + } + } + else + SS_DBG_LADSPA("Warning - tried to stop plugin, but plugin was never started...\n"); + SS_TRACE_OUT + } + +//--------------------------------------------------------- +// range +//--------------------------------------------------------- + +void LadspaPlugin::range(int i, float* min, float* max) const + { + SS_TRACE_IN + i = pIdx[i]; + LADSPA_PortRangeHint range = plugin->PortRangeHints[i]; + LADSPA_PortRangeHintDescriptor desc = range.HintDescriptor; + if (desc & LADSPA_HINT_TOGGLED) { + *min = 0.0; + *max = 1.0; + return; + } + float m = 1.0; + if (desc & LADSPA_HINT_SAMPLE_RATE) + m = (float) SS_samplerate; + + if (desc & LADSPA_HINT_BOUNDED_BELOW) + *min = range.LowerBound * m; + else + *min = 0.0; + if (desc & LADSPA_HINT_BOUNDED_ABOVE) + *max = range.UpperBound * m; + else + *max = 1.0; + SS_TRACE_OUT + } + +//--------------------------------------------------------- +// defaultValue +//--------------------------------------------------------- + +float LadspaPlugin::defaultValue(int k) const + { + SS_TRACE_IN + k = pIdx[k]; + LADSPA_PortRangeHint range = plugin->PortRangeHints[k]; + LADSPA_PortRangeHintDescriptor rh = range.HintDescriptor; + double val = 1.0; + if (LADSPA_IS_HINT_DEFAULT_MINIMUM(rh)) + val = range.LowerBound; + else if (LADSPA_IS_HINT_DEFAULT_LOW(rh)) + if (LADSPA_IS_HINT_LOGARITHMIC(range.HintDescriptor)) + val = exp(fast_log10(range.LowerBound) * .75 + + log(range.UpperBound) * .25); + else + val = range.LowerBound*.75 + range.UpperBound*.25; + else if (LADSPA_IS_HINT_DEFAULT_MIDDLE(rh)) + if (LADSPA_IS_HINT_LOGARITHMIC(range.HintDescriptor)) + val = exp(log(range.LowerBound) * .5 + + log(range.UpperBound) * .5); + else + val = range.LowerBound*.5 + range.UpperBound*.5; + else if (LADSPA_IS_HINT_DEFAULT_HIGH(rh)) + if (LADSPA_IS_HINT_LOGARITHMIC(range.HintDescriptor)) + val = exp(log(range.LowerBound) * .25 + + log(range.UpperBound) * .75); + else + val = range.LowerBound*.25 + range.UpperBound*.75; + else if (LADSPA_IS_HINT_DEFAULT_MAXIMUM(rh)) + val = range.UpperBound; + else if (LADSPA_IS_HINT_DEFAULT_0(rh)) + val = 0.0; + else if (LADSPA_IS_HINT_DEFAULT_1(rh)) + val = 1.0; + else if (LADSPA_IS_HINT_DEFAULT_100(rh)) + val = 100.0; + else if (LADSPA_IS_HINT_DEFAULT_440(rh)) + val = 440.0; + SS_TRACE_OUT + return val; + } + +//--------------------------------------------------------- +// find +//--------------------------------------------------------- + +Plugin* PluginList::find(const QString& file, const QString& name) + { + SS_TRACE_IN + for (iPlugin i = begin(); i != end(); ++i) { + if ((file == (*i)->lib()) && (name == (*i)->label())) { + SS_TRACE_OUT + return *i; + } + } + printf("Plugin <%s> not found\n", name.toLatin1().data()); + SS_TRACE_OUT + return 0; + } + +//--------------------------------------------------------- +// connectInport +//--------------------------------------------------------- +void LadspaPlugin::connectInport(int k, LADSPA_Data* datalocation) + { + SS_TRACE_IN + plugin->connect_port(handle, iIdx[k], datalocation); + SS_TRACE_OUT + } + +//--------------------------------------------------------- +// connectOutport +//--------------------------------------------------------- +void LadspaPlugin::connectOutport(int k, LADSPA_Data* datalocation) + { + SS_TRACE_IN + plugin->connect_port(handle, oIdx[k], datalocation); + SS_TRACE_OUT + } + +//--------------------------------------------------------- +// process +//--------------------------------------------------------- +void LadspaPlugin::process(unsigned long frames) + { + plugin->run(handle, frames); + } + +//--------------------------------------------------------- +// setParam +//--------------------------------------------------------- + +void LadspaPlugin::setParam(int k, float val) + { + SS_TRACE_IN + controls[k].val = val; + SS_TRACE_OUT + } + +//--------------------------------------------------------- +// getGuiControlValue +// scale control value to gui-slider/checkbox representation +//--------------------------------------------------------- + +int LadspaPlugin::getGuiControlValue(int param) const + { + SS_TRACE_IN + float val = getControlValue(param); + float min, max; + range(param, &min, &max); + int intval; + if (isLog(param)) { + intval = SS_map_logdomain2pluginparam(logf(val/(max - min) + min)); + } + else if (isBool(param)) { + intval = (int) val; + } + else { + float scale = SS_PLUGIN_PARAM_MAX / (max - min); + intval = (int) ((val - min) * scale); + } + SS_TRACE_OUT + return intval; + } + +//--------------------------------------------------------- +// convertGuiControlValue +// scale control value to gui-slider/checkbox representation +//--------------------------------------------------------- + +float LadspaPlugin::convertGuiControlValue(int parameter, int val) const + { + SS_TRACE_IN + float floatval = 0; + float min, max; + range(parameter, &min, &max); + + if (isLog(parameter)) { + if (val > 0) { + float logged = SS_map_pluginparam2logdomain(val); + float e = expf(logged) * (max - min); + e+=min; + floatval = e; + } + } + else if (isBool(parameter)) { + floatval = (float) val; + } + else if (isInt(parameter)) { + float scale = (max - min) / SS_PLUGIN_PARAM_MAX; + floatval = (float) round((((float) val) * scale) + min); + } + else { + float scale = (max - min) / SS_PLUGIN_PARAM_MAX; + floatval = (((float) val) * scale) + min; + } + SS_TRACE_OUT + return floatval; + } diff --git a/attic/muse_qt4_evolution/synti/simpledrums/ssplugin.h b/attic/muse_qt4_evolution/synti/simpledrums/ssplugin.h new file mode 100644 index 00000000..b9a7fb49 --- /dev/null +++ b/attic/muse_qt4_evolution/synti/simpledrums/ssplugin.h @@ -0,0 +1,171 @@ +// +// C++ Interface: plugin +// +// Description: +// +// +// (C) Copyright 2000 Werner Schweer (ws@seh.de) +// Additions/modifications: Mathias Lundgren <lunar_shuttle@users.sf.net>, (C) 2004 +// Copyright: See COPYING file that comes with this distribution +// +// + +#ifndef __PLUGIN_H__ +#define __PLUGIN_H__ + +#include <ladspa.h> +#include <math.h> + +//--------------------------------------------------------- +// Port +//--------------------------------------------------------- + +struct Port { + float val; + }; + +//--------------------------------------------------------- +// Plugin +//--------------------------------------------------------- + +class Plugin + { + protected: + QFileInfo fi; + + public: + Plugin(const QFileInfo* f); + virtual ~Plugin() {} + virtual QString label() const { return QString(); } + virtual QString name() const { return QString(); } + virtual unsigned long id() const { return 0; } + virtual QString maker() const { return QString(); } + virtual QString copyright() const { return QString(); } + virtual int parameter() const { return 0; } + virtual int inports() const { return 0; } + virtual int outports() const { return 0; } + virtual bool inPlaceCapable() const { return false; } + + virtual bool isLog(int) const { return false; } + virtual bool isBool(int) const { return false; } + virtual bool isInt(int) const { return false; } + virtual float defaultValue(int) const { return 0.0f; } + virtual void range(int, float* min, float* max) const { + *min = 0.0f; + *max = 1.0f; + } + virtual const char* getParameterName(int /*param*/) const { return ""; } + QString lib() const { return fi.baseName(); } + QString path() const { return fi.absolutePath(); } + }; + +//--------------------------------------------------------- +// LadspaPlugin +//--------------------------------------------------------- + +class LadspaPlugin : public Plugin + { + LADSPA_Descriptor_Function ladspa; + const LADSPA_Descriptor* plugin; + LADSPA_Handle handle; + bool active; + + Port* controls; + Port* inputs; + Port* outputs; + + protected: + int _parameter; + std::vector<int> pIdx; //control port numbers + + int _inports; + std::vector<int> iIdx; //input port numbers + + int _outports; + std::vector<int> oIdx; //output port numbers + + bool _inPlaceCapable; + + public: + LadspaPlugin(const QFileInfo* f, const LADSPA_Descriptor_Function, const LADSPA_Descriptor* d); + virtual ~LadspaPlugin(); + virtual QString label() const { return QString(plugin->Label); } + virtual QString name() const { return QString(plugin->Name); } + virtual unsigned long id() const { return plugin->UniqueID; } + virtual QString maker() const { return QString(plugin->Maker); } + virtual QString copyright() const { return QString(plugin->Copyright); } + virtual int parameter() const { return _parameter; } + virtual int inports() const { return _inports; } + virtual int outports() const { return _outports; } + virtual bool inPlaceCapable() const { return _inPlaceCapable; } + const LADSPA_Descriptor* ladspaDescriptor() const { return plugin; } + virtual bool isLog(int k) const { + LADSPA_PortRangeHint r = plugin->PortRangeHints[pIdx[k]]; + return LADSPA_IS_HINT_LOGARITHMIC(r.HintDescriptor); + } + virtual bool isBool(int k) const { + return LADSPA_IS_HINT_TOGGLED(plugin->PortRangeHints[pIdx[k]].HintDescriptor); + } + virtual bool isInt(int k) const { + LADSPA_PortRangeHint r = plugin->PortRangeHints[pIdx[k]]; + return LADSPA_IS_HINT_INTEGER(r.HintDescriptor); + } + virtual void range(int i, float*, float*) const; + virtual const char* getParameterName(int i) const { + return plugin->PortNames[pIdx[i]]; + } + virtual float defaultValue(int) const; + virtual float getControlValue(int k) const { + return controls[k].val; + } + + int getGuiControlValue(int parameter) const; + float convertGuiControlValue(int parameter, int val) const; + + bool instantiate(); + bool start(); + void stop(); + void connectInport(int k, LADSPA_Data* datalocation); + void connectOutport(int k, LADSPA_Data* datalocation); + void process(unsigned long); + void setParam(int i, float val); + + }; + + +static inline float fast_log2 (float val) + { + /* don't use reinterpret_cast<> because that prevents this + from being used by pure C code (for example, GnomeCanvasItems) + */ + int* const exp_ptr = (int *)(&val); + int x = *exp_ptr; + const int log_2 = ((x >> 23) & 255) - 128; + x &= ~(255 << 23); + x += 127 << 23; + *exp_ptr = x; + val = ((-1.0f/3) * val + 2) * val - 2.0f/3; // (1) + return (val + log_2); + } + +static inline float fast_log10 (const float val) + { + return fast_log2(val) / 3.312500f; + } + +//--------------------------------------------------------- +// PluginList +//--------------------------------------------------------- + +typedef std::list<Plugin*>::iterator iPlugin; + +class PluginList : public std::list<Plugin*> { + public: + Plugin* find(const QString& file, const QString& name); + PluginList() {} + }; + +extern void SS_initPlugins(); +extern PluginList plugins; + +#endif diff --git a/attic/muse_qt4_evolution/synti/simpledrums/sspluginchooserbase.ui b/attic/muse_qt4_evolution/synti/simpledrums/sspluginchooserbase.ui new file mode 100644 index 00000000..63d254df --- /dev/null +++ b/attic/muse_qt4_evolution/synti/simpledrums/sspluginchooserbase.ui @@ -0,0 +1,106 @@ +<ui version="4.0" > + <author></author> + <comment></comment> + <exportmacro></exportmacro> + <class>SS_PluginChooserBase</class> + <widget class="QDialog" name="SS_PluginChooserBase" > + <property name="geometry" > + <rect> + <x>0</x> + <y>0</y> + <width>777</width> + <height>681</height> + </rect> + </property> + <property name="windowTitle" > + <string>SimpleDrums - Ladspa Plugin Chooser</string> + </property> + <layout class="QVBoxLayout" > + <property name="margin" > + <number>10</number> + </property> + <property name="spacing" > + <number>6</number> + </property> + <item> + <widget class="QTreeWidget" name="effectsListView" > + <column> + <property name="text" > + <string>Name</string> + </property> + </column> + <column> + <property name="text" > + <string>Label</string> + </property> + </column> + <column> + <property name="text" > + <string>Inports</string> + </property> + </column> + <column> + <property name="text" > + <string>Outports</string> + </property> + </column> + <column> + <property name="text" > + <string>Creator</string> + </property> + </column> + </widget> + </item> + <item> + <layout class="QHBoxLayout" > + <property name="margin" > + <number>0</number> + </property> + <property name="spacing" > + <number>6</number> + </property> + <item> + <spacer> + <property name="orientation" > + <enum>Qt::Horizontal</enum> + </property> + <property name="sizeType" > + <enum>QSizePolicy::Expanding</enum> + </property> + <property name="sizeHint" > + <size> + <width>301</width> + <height>31</height> + </size> + </property> + </spacer> + </item> + <item> + <widget class="QPushButton" name="cancelButton" > + <property name="text" > + <string>&Cancel</string> + </property> + <property name="shortcut" > + <string>Alt+C</string> + </property> + </widget> + </item> + <item> + <widget class="QPushButton" name="okButton" > + <property name="text" > + <string>&OK</string> + </property> + <property name="shortcut" > + <string>Alt+O</string> + </property> + </widget> + </item> + </layout> + </item> + </layout> + </widget> + <layoutdefault spacing="6" margin="11" /> + <pixmapfunction>qPixmapFromMimeSource</pixmapfunction> + <resources/> + <connections/> +</ui> diff --git a/attic/muse_qt4_evolution/synti/simpledrums/ssplugingui.cpp b/attic/muse_qt4_evolution/synti/simpledrums/ssplugingui.cpp new file mode 100644 index 00000000..0428988b --- /dev/null +++ b/attic/muse_qt4_evolution/synti/simpledrums/ssplugingui.cpp @@ -0,0 +1,530 @@ +// +// C++ Implementation: ssplugingui +// +// Description: +// +// +// Author: Mathias Lundgren <lunar_shuttle@users.sf.net>, (C) 2004 +// +// Copyright: See COPYING file that comes with this distribution +// +// +#include "ssplugingui.h" +#include "ssplugin.h" +#include "simpledrumsgui.h" + +#define SS_PLUGINGUI_XOFF 300 +#define SS_PLUGINGUI_YOFF 300 +#define SS_PLUGINGUI_WIDTH 450 +#define SS_PLUGINGUI_MAX_WIDTH 700 + +#define SS_PLUGINFRONT_MINWIDTH SS_PLUGINGUI_WIDTH +#define SS_PLUGINFRONT_MINHEIGHT 70 +#define SS_PLUGINFRONT_MARGIN 9 +#define SS_PLUGINFRONT_INC_PARAM 30 +#define SS_PLUGINFRONT_INC_PARAM_MIN 60 +#define SS_PLUGINGUI_HEIGHT (SS_NR_OF_SENDEFFECTS * SS_PLUGINFRONT_MINHEIGHT) + +#define SS_PLUGINCHOOSER_NAMECOL 0 +#define SS_PLUGINCHOOSER_LABELCOL 1 +#define SS_PLUGINCHOOSER_INPORTSCOL 2 +#define SS_PLUGINCHOOSER_OUTPORTSCOL 3 +#define SS_PLUGINCHOOSER_CREATORCOL 4 + + +/*! + \fn SS_PluginChooser::SS_PluginChooser(QWidget* parent, const char* name = 0) + */ +SS_PluginChooser::SS_PluginChooser(QWidget* parent) + :QDialog(parent) + { + SS_TRACE_IN + setupUi(this); + selectedPlugin = 0; + + for (iPlugin i=plugins.begin(); i !=plugins.end(); i++) { + //Support for only 2 or 1 inport/outports + if ( ((*i)->outports() == 2 || (*i)->outports() == 1) && ((*i)->inports() == 2 || (*i)->inports() == 1) ) { + QTreeWidgetItem* tmpItem = new QTreeWidgetItem(effectsListView); + tmpItem->setText(SS_PLUGINCHOOSER_NAMECOL, (*i)->name()); + tmpItem->setText(SS_PLUGINCHOOSER_LABELCOL, (*i)->label()); + tmpItem->setText(SS_PLUGINCHOOSER_INPORTSCOL, QString::number((*i)->inports())); + tmpItem->setText(SS_PLUGINCHOOSER_OUTPORTSCOL, QString::number((*i)->outports())); + tmpItem->setText(SS_PLUGINCHOOSER_CREATORCOL, (*i)->maker()); + effectsListView->addTopLevelItem(tmpItem); + } + } + connect(okButton, SIGNAL(pressed()), SLOT(okPressed())); + connect(cancelButton, SIGNAL(pressed()), SLOT(cancelPressed())); + connect(effectsListView, SIGNAL(selectionChanged(QTreeWidgetItem*)), SLOT(selectionChanged(QTreeWidgetItem*))); + connect(effectsListView, SIGNAL(doubleClicked(QTreeWidgetItem*)), SLOT(doubleClicked(QTreeWidgetItem*))); + SS_TRACE_OUT + } + +/*! + \fn SS_PluginChooser::selectionChanged(QListViewItem* item) + */ +void SS_PluginChooser::selectionChanged(QTreeWidgetItem* item) + { + SS_TRACE_IN + selectedItem = item; + SS_TRACE_OUT + } + +/*! + \fn SS_PluginChooser::okPressed() + */ +void SS_PluginChooser::okPressed() + { + SS_TRACE_IN + selectedPlugin = findSelectedPlugin(); + done(QDialog::Accepted); + SS_TRACE_OUT + } + +/*! + \fn SS_PluginChooser::cancelPressed() + */ +void SS_PluginChooser::cancelPressed() + { + SS_TRACE_IN + SS_TRACE_OUT + done(QDialog::Rejected); + } + +/*! + \fn SS_PluginChooser::doubleClicked(QListViewItem* item) + */ +void SS_PluginChooser::doubleClicked(QTreeWidgetItem* /*item*/) + { + SS_TRACE_IN + selectedPlugin = findSelectedPlugin(); + SS_TRACE_OUT + done(QDialog::Accepted); + } + +/*! + \fn SS_PluginChooser::getSelectedPlugin() + */ +LadspaPlugin* SS_PluginChooser::findSelectedPlugin() + { + SS_TRACE_IN + LadspaPlugin* selected = 0; + for (iPlugin i=plugins.begin(); i != plugins.end(); i++) { + if ((*i)->name() == selectedItem->text(SS_PLUGINCHOOSER_NAMECOL)) + selected = (LadspaPlugin*) (*i); + } + SS_TRACE_OUT + return selected; + } + +/*! + \fn SS_PluginFront::SS_PluginFront(QWidget* parent, const char* name = 0) + */ +SS_PluginFront::SS_PluginFront(QWidget* parent, int in_fxid) + : QGroupBox(parent), fxid (in_fxid) + { + SS_TRACE_IN + expanded = false; + pluginChooser = 0; + plugin = 0; + expGroup = 0; + +//TD setLineWidth(3); + setFlat(false); +//TD setFrameStyle( Q3Frame::Box | Q3Frame::Raised ); +//TD setFrameShape(QFrame::StyledPanel); +// setFrameShadow(Qt::Sunken); + setFocusPolicy(Qt::NoFocus); + setMinimumSize(SS_PLUGINFRONT_MINWIDTH, SS_PLUGINFRONT_MINHEIGHT); + setMaximumSize(SS_PLUGINGUI_MAX_WIDTH, SS_PLUGINFRONT_MINHEIGHT); + + QVBoxLayout* bigLayout = new QVBoxLayout(this); + bigLayout->setMargin(SS_PLUGINFRONT_MARGIN); + bigLayout->setAlignment(Qt::AlignTop); +//TODO bigLayout->setResizeMode(QLayout::SetNoConstraint); + + layout = new QHBoxLayout; + bigLayout->addLayout(layout); + layout->setAlignment(Qt::AlignVCenter); +//TODO layout->setResizeMode(QLayout::SetNoConstraint); + + + QVBoxLayout* onOffLayout = new QVBoxLayout; + layout->addLayout(onOffLayout); + onOffLayout->setMargin(SS_PLUGINFRONT_MARGIN); + onOff = new QCheckBox(this); + onOffLayout->addWidget(new QLabel("On/Off", this)); + onOffLayout->addWidget(onOff); + connect(onOff, SIGNAL(toggled(bool)), SLOT(onOffToggled(bool))); + + pluginName = new QLineEdit(this); + pluginName->setReadOnly(true); + layout->addWidget(pluginName); + + loadFxButton = new QPushButton("L", this); + QRect r = loadFxButton->geometry(); + loadFxButton->setGeometry(r.x(), r.y(), 20, pluginName->geometry().height()); + loadFxButton->setSizePolicy(QSizePolicy(QSizePolicy::Minimum, QSizePolicy::Minimum)); + loadFxButton->setMinimumSize(20,pluginName->geometry().height()); + loadFxButton->setMaximumSize(30,pluginName->geometry().height()); + connect(loadFxButton, SIGNAL(clicked()), SLOT(loadButton())); + layout->addWidget(loadFxButton); + + clearFxButton = new QPushButton("C", this); + r = clearFxButton->geometry(); + clearFxButton->setGeometry(r.x(), r.y(), 20, pluginName->geometry().height()); + clearFxButton->setSizePolicy(QSizePolicy(QSizePolicy::Minimum, QSizePolicy::Minimum)); + clearFxButton->setMinimumSize(20,pluginName->geometry().height()); + clearFxButton->setMaximumSize(30,pluginName->geometry().height()); + connect(clearFxButton, SIGNAL(clicked()), SLOT(clearButtonPressed())); + layout->addWidget(clearFxButton); + + layout->addSpacing(5); + + expandButton = new QPushButton("->", this); + r = loadFxButton->geometry(); + expandButton->setGeometry(r.x(), r.y(), 20, pluginName->geometry().height()); + expandButton->setSizePolicy(QSizePolicy(QSizePolicy::Minimum, QSizePolicy::Minimum)); + expandButton->setMinimumSize(20,pluginName->geometry().height()); + expandButton->setMaximumSize(30,pluginName->geometry().height()); + connect(expandButton, SIGNAL(clicked()), SLOT(expandButtonPressed())); + layout->addWidget(expandButton); + + layout->addSpacing(5); + + QVBoxLayout* gainSliderLayout = new QVBoxLayout; + layout->addLayout(gainSliderLayout); + gainSliderLayout->addWidget(new QLabel("Return level", this)); + gainSliderLayout->setMargin(SS_PLUGINFRONT_MARGIN); + outGainSlider = new QSlider(Qt::Horizontal, this); + outGainSlider->setMinimumSize(100, pluginName->geometry().height()); + outGainSlider->setMaximumSize(500, pluginName->geometry().height()); + loadFxButton->setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Minimum)); + outGainSlider->setRange(0, 127); + outGainSlider->setValue(75); + connect(outGainSlider, SIGNAL(valueChanged(int)), SLOT(returnSliderMoved(int))); + gainSliderLayout->addWidget(outGainSlider); + clearPluginDisplay(); + + expLayout = new QVBoxLayout; // (bigLayout, 2); + bigLayout->addLayout(expLayout); + + clearFxButton->setToolTip(tr("Clear and unload effect")); + loadFxButton->setToolTip(tr("Load effect")); + expandButton->setToolTip(tr("Toggle display of effect parameters")); + onOff->setToolTip(tr("Turn effect on/off")); + SS_TRACE_OUT + } + +SS_PluginFront::~SS_PluginFront() + { + if (pluginChooser) + delete pluginChooser; + } + +/*! + \fn SS_PluginFront::clearPluginDisplay() + */ +void SS_PluginFront::clearPluginDisplay() + { + SS_TRACE_IN + if (expanded) + expandButtonPressed(); + + pluginName->setText("No plugin loaded"); + pluginName->setEnabled(false); + onOff->setEnabled(false); + onOff->blockSignals(true); + onOff->setChecked(false); + onOff->blockSignals(false); + + clearFxButton->setEnabled(false); + expandButton->setEnabled(false); + outGainSlider->setEnabled(false); + SS_TRACE_OUT + } + +/*! + \fn SS_PluginFront::setPluginName(QString name) + */ +void SS_PluginFront::setPluginName(QString name) + { + pluginName->setText(name); + } + + +/*! + \fn SS_PluginFront::loadButton() + */ +void SS_PluginFront::loadButton() + { + SS_TRACE_IN + if (!pluginChooser) + pluginChooser = new SS_PluginChooser(this); + + pluginChooser->exec(); + if ((pluginChooser->result() == QDialog::Accepted) && pluginChooser->getSelectedPlugin()) { + Plugin* p = pluginChooser->getSelectedPlugin(); + //printf("Selected plugin: %s\n", pluginChooser->getSelectedPlugin()->name().toLatin1().data()); + emit loadPlugin(fxid, p->lib(), p->label()); + } + SS_TRACE_OUT + } + +/*! + \fn SS_PluginFront::returnSliderMoved(int val) + */ +void SS_PluginFront::returnSliderMoved(int val) + { + emit returnLevelChanged(fxid, val); + } + + +/*! + \fn SS_PluginFront::updatePluginValue(unsigned i) + */ +void SS_PluginFront::updatePluginValue(unsigned k) + { + SS_TRACE_IN + // If parameters are shown - close them + if (expanded) { + expandButtonPressed(); + } + + unsigned j=0; + if (k > plugins.size()) { + fprintf(stderr, "Internal error, tried to update plugin w range outside of list\n"); + return; + } + + iPlugin i; + for (i = plugins.begin(); j != k; i++, j++); + plugin = (LadspaPlugin*) *(i); + setPluginName(plugin->label()); + outGainSlider->setEnabled(true); + clearFxButton->setEnabled(true); + expandButton->setEnabled(true); + pluginName->setEnabled(true); + onOff->setEnabled(true); + onOff->setChecked(true); + SS_TRACE_OUT + } + +/*! + \fn SS_PluginFront::onOffToggled(bool state) + */ +void SS_PluginFront::onOffToggled(bool state) + { + emit fxToggled(fxid, state); + } + +/*! + \fn SS_PluginFront::sizeHint() const + */ +QSize SS_PluginFront::sizeHint() const + { + return QSize(SS_PLUGINFRONT_MINWIDTH, 50); + } + +/*! + \fn SS_PluginFront::sizePolicy() const + */ +QSizePolicy SS_PluginFront::sizePolicy() const + { + return QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed); + } + + +/*! + \fn SS_PluginFront::clearButtonPressed() + */ +void SS_PluginFront::clearButtonPressed() + { + // If parameters are shown - close them + if (expanded) { + expandButtonPressed(); + } + emit clearPlugin(fxid); + } + +/*! + \fn SS_PluginFront::setRetGain(int val) + */ +void SS_PluginFront::setRetGain(int val) + { + outGainSlider->blockSignals(true); + outGainSlider->setValue(val); + outGainSlider->blockSignals(false); + } + +/*! + \fn SS_PluginFront::expandButtonPressed() + */ +void SS_PluginFront::expandButtonPressed() + { + SS_TRACE_IN + int sizeIncrease = 0; + QRect pf = geometry(); + + if (!expanded) { + plugin->parameter() == 1 ? sizeIncrease = SS_PLUGINFRONT_INC_PARAM_MIN : sizeIncrease = plugin->parameter() * SS_PLUGINFRONT_INC_PARAM; + pf.setHeight(pf.height() + sizeIncrease); + setMinimumSize(QSize(pf.width(), pf.height())); + setMaximumSize(QSize(SS_PLUGINGUI_MAX_WIDTH, pf.height())); + setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed)); + setGeometry(pf); + emit sizeChanged(fxid, sizeIncrease); + + expanded = true; + expandButton->setText("<-"); + createPluginParameters(); + } + else { +//TODO expLayout->remove(expGroup); + expGroup->hide(); + expGroup->deleteLater(); + paramWidgets.clear(); + expGroup = 0; + plugin->parameter() == 1 ? sizeIncrease = (0-SS_PLUGINFRONT_INC_PARAM_MIN) : sizeIncrease = 0 - (plugin->parameter() * SS_PLUGINFRONT_INC_PARAM); + expandButton->setText("->"); + expanded = false; + pf.setHeight(pf.height() + sizeIncrease); + pf.setTop(pf.top() + sizeIncrease); + pf.setBottom(pf.bottom() + sizeIncrease); + setGeometry(pf); + adjustSize(); + layout->activate(); + setMinimumSize(QSize(pf.width(), pf.height())); + setMaximumSize(QSize(SS_PLUGINGUI_MAX_WIDTH, pf.height())); + setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed)); + emit sizeChanged(fxid, sizeIncrease); + } + SS_TRACE_OUT + } + +/*! + \fn SS_PluginFront::createPluginParameters() + */ +void SS_PluginFront::createPluginParameters() + { + SS_TRACE_IN + expGroup = new QGroupBox(this); + + expGroup->setMinimumSize(QSize(50, 50)); + expGroup->setMaximumSize(QSize(SS_PLUGINGUI_MAX_WIDTH, (plugin->parameter() * SS_PLUGINFRONT_INC_PARAM - SS_PLUGINFRONT_MARGIN))); + expGroup->setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding)); + expLayout->addWidget(expGroup); + expGroup->show(); + QVBoxLayout* expGroupLayout = new QVBoxLayout(expGroup); // , 1); + expGroupLayout->setAlignment(Qt::AlignLeft | Qt::AlignVCenter); +//TD expGroupLayout->setResizeMode(QLayout::FreeResize); + expGroupLayout->setMargin(SS_PLUGINFRONT_MARGIN); + + for (int i=0; i < plugin->parameter(); i++) { + QHBoxLayout* paramStrip = new QHBoxLayout; // (expGroupLayout, 3); + expGroupLayout->addLayout(paramStrip); + paramStrip->setAlignment(Qt::AlignLeft); + QLabel* paramName = new QLabel(plugin->getParameterName(i), expGroup); + paramName->show(); + paramName->setMinimumSize(QSize(150, 10)); + paramName->setMaximumSize(QSize(300, SS_PLUGINFRONT_INC_PARAM)); + paramName->setSizePolicy(QSizePolicy(QSizePolicy::Minimum, QSizePolicy::Expanding)); + + paramStrip->addWidget(paramName); + + if (plugin->isBool(i)) { + SS_ParameterCheckBox* paramCheckBox = new SS_ParameterCheckBox(expGroup, plugin, fxid, i); + paramCheckBox->setEnabled(true); + paramCheckBox->setParamValue((int) plugin->getControlValue(i)); + paramCheckBox->show(); + paramStrip->addWidget(paramCheckBox); + connect(paramCheckBox, SIGNAL(valueChanged(int, int, int)), SLOT(parameterValueChanged(int, int, int))); + } + else { + SS_ParameterSlider* paramSlider = new SS_ParameterSlider(expGroup, plugin, fxid, i); + paramSlider->setEnabled(true); + paramSlider->show(); + paramSlider->setRange(SS_PLUGIN_PARAM_MIN, SS_PLUGIN_PARAM_MAX); + + float max, min; + plugin->range(i, &min, &max); + //int intval = 0; + paramSlider->setParamValue(plugin->getGuiControlValue(i)); + connect(paramSlider, SIGNAL(valueChanged(int, int, int)), SLOT(parameterValueChanged(int, int, int))); + paramStrip->addWidget(paramSlider); + } + } + expLayout->activate(); + SS_TRACE_OUT + } + +/*! + \fn SS_PluginFront::parameterValueChanged(int fxid, int parameter, int val) + */ +void SS_PluginFront::parameterValueChanged(int fxid, int parameter, int val) + { + emit effectParameterChanged(fxid, parameter, val); + } + +/*! + \fn SS_PluginFront::setParameterValue(int param, float val) + */ +void SS_PluginFront::setParameterValue(int param, int val) + { + SS_TRACE_IN + int j=0; + for (SS_iParameterWidgetList i=paramWidgets.begin(); i != paramWidgets.end(); i++, j++) { + if (j == param) { + (*i)->setParamValue(val); + } + } + SS_TRACE_OUT + } + +SS_PluginGui::SS_PluginGui(QWidget* parent) + : QDialog(parent, false) + { + setWindowTitle("SimpleDrums LADSPA sendeffects"); + for (int i=0; i<SS_NR_OF_SENDEFFECTS; i++) { + pluginFronts[i] = 0; + } + layout = new QVBoxLayout(this); + + for (int i=0; i<SS_NR_OF_SENDEFFECTS; i++) { + pluginFronts[i] = new SS_PluginFront(this, i); + pluginFronts[i]->update(); + layout->addWidget(pluginFronts[i]); + connect(pluginFronts[i], SIGNAL(loadPlugin(int, QString, QString)), simplesynthgui_ptr, SLOT(loadEffectInvoked(int, QString, QString))); + connect(pluginFronts[i], SIGNAL(returnLevelChanged(int, int)), simplesynthgui_ptr, SLOT(returnLevelChanged(int, int))); + connect(pluginFronts[i], SIGNAL(fxToggled(int, int)), simplesynthgui_ptr, SLOT(toggleEffectOnOff(int, int))); + connect(pluginFronts[i], SIGNAL(clearPlugin(int)), simplesynthgui_ptr, SLOT(clearPlugin(int))); + connect(pluginFronts[i], SIGNAL(sizeChanged(int, int)), SLOT(pluginFrontSizeChanged(int, int))); + connect(pluginFronts[i], SIGNAL(effectParameterChanged(int, int, int)), simplesynthgui_ptr, SLOT(effectParameterChanged(int, int, int))); + } + setMinimumSize(QSize(SS_PLUGINGUI_WIDTH, geometry().height())); + setMaximumSize(QSize(SS_PLUGINGUI_MAX_WIDTH, geometry().height())); + } + + +/*! + \fn SS_PluginGui::pluginFrontSizeChanged(int fxid, int val) + */ +void SS_PluginGui::pluginFrontSizeChanged(int /*fxid*/, int val) + { + QRect r = geometry(); + r.setHeight(r.height() + val); + setMinimumSize(QSize(SS_PLUGINGUI_WIDTH, r.height())); + setMaximumSize(QSize(SS_PLUGINGUI_MAX_WIDTH, r.height())); + setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed)); + setGeometry(r); + adjustSize(); + } + +SS_PluginFront* SS_PluginGui::getPluginFront(unsigned i) + { + SS_TRACE_IN + if (i<SS_NR_OF_SENDEFFECTS) + SS_TRACE_OUT + return pluginFronts[i]; + } diff --git a/attic/muse_qt4_evolution/synti/simpledrums/ssplugingui.h b/attic/muse_qt4_evolution/synti/simpledrums/ssplugingui.h new file mode 100644 index 00000000..d613fd46 --- /dev/null +++ b/attic/muse_qt4_evolution/synti/simpledrums/ssplugingui.h @@ -0,0 +1,198 @@ +// +// C++ Interface: ssplugingui +// +// Description: +// +// +// Author: Mathias Lundgren <lunar_shuttle@users.sf.net>, (C) 2004 +// +// Copyright: See COPYING file that comes with this distribution +// +// + +#ifndef __SS_PLUGINGUI_H__ +#define __SS_PLUGINGUI_H__ + +#include "ui_sspluginchooserbase.h" +#include "common.h" +#include "ssplugin.h" + +class SS_ParameterWidget + { + protected: + int fxid; + int parameter; + + LadspaPlugin* plugin; + + public: + SS_ParameterWidget() { } + virtual ~SS_ParameterWidget() { } + int getFxId() { SS_TRACE_IN SS_TRACE_OUT return fxid; } + bool isBool() { SS_TRACE_IN SS_TRACE_OUT return plugin->isBool(parameter); } + bool isLog() { SS_TRACE_IN SS_TRACE_OUT return plugin->isLog(parameter); } + bool isInt() { SS_TRACE_IN SS_TRACE_OUT return plugin->isInt(parameter); } + virtual void setParamValue(int) { printf("Virtual function - should not be called!"); }; + }; + +class SS_ParameterCheckBox : public QCheckBox, public SS_ParameterWidget + { + Q_OBJECT + + public: + SS_ParameterCheckBox(QWidget* parent, LadspaPlugin* in_plugin, int in_id, int in_parameter) + : QCheckBox(parent) , SS_ParameterWidget() + { + SS_TRACE_IN + plugin = in_plugin; + fxid = in_id; + parameter = in_parameter; + connect(this, SIGNAL(clicked()), SLOT(isClicked())); + SS_TRACE_OUT + } + + virtual void setParamValue(int val) { SS_TRACE_IN setChecked(val); SS_TRACE_OUT} + + private slots: + void isClicked() { SS_TRACE_IN emit valueChanged(fxid, parameter, (int)this->isChecked()); SS_TRACE_OUT} + + signals: + void valueChanged(int id, int param, int val); + }; + +class SS_ParameterSlider : public QSlider, public SS_ParameterWidget + { + Q_OBJECT + + public: + SS_ParameterSlider(QWidget* parent, LadspaPlugin* in_plugin, int in_id, int in_parameter) + : QSlider(Qt::Horizontal, parent), SS_ParameterWidget() + { + SS_TRACE_IN + plugin = in_plugin; + fxid = in_id; + parameter = in_parameter; + SS_TRACE_OUT + } + + virtual void setParamValue(int val) { SS_TRACE_IN setValue(val); SS_TRACE_OUT} + + public slots: + virtual void setValue(int val) { SS_TRACE_IN QSlider::setValue(val); emit valueChanged(fxid, parameter, val); SS_TRACE_OUT } + + signals: + void valueChanged(int id, int param, int val); + }; + +typedef std::list<SS_ParameterWidget*> SS_ParameterWidgetList; +typedef std::list<SS_ParameterWidget*>::iterator SS_iParameterWidgetList ; + +//------------------------------- +// SS_PluginChooser +//------------------------------- +class SS_PluginChooser : public QDialog, Ui::SS_PluginChooserBase +{ + Q_OBJECT + private: + LadspaPlugin* selectedPlugin; + protected: + + public: + SS_PluginChooser(QWidget* parent); + LadspaPlugin* getSelectedPlugin() { SS_TRACE_IN SS_TRACE_OUT return selectedPlugin; } + + private slots: + void okPressed(); + void cancelPressed(); + void selectionChanged(QTreeWidgetItem* item); + void doubleClicked(QTreeWidgetItem* item); + + private: + QTreeWidgetItem* selectedItem; + LadspaPlugin* findSelectedPlugin(); + +}; + +//------------------------------- +// SS_PluginGuiFront +//------------------------------- +class SS_PluginFront : public QGroupBox + { + Q_OBJECT + private: + QHBoxLayout* layout; + QVBoxLayout* expLayout; + QLineEdit* pluginName; + QCheckBox* onOff; + QPushButton* loadFxButton; + QPushButton* clearFxButton; + QPushButton* expandButton; + QSlider* outGainSlider; + SS_PluginChooser* pluginChooser; + LadspaPlugin* plugin; + QGroupBox* expGroup; + + int fxid; + bool expanded; + + //For effect parameters: + SS_ParameterWidgetList paramWidgets; + + protected: + + public: + SS_PluginFront(QWidget* parent, int id); + void setPluginName(QString name); + ~SS_PluginFront(); + void updatePluginValue(unsigned i); + void clearPluginDisplay(); + void setParameterValue(int param, int val); + void setRetGain(int val); + + protected: + virtual QSize sizeHint() const; + virtual QSizePolicy sizePolicy() const; + + private slots: + void loadButton(); + void returnSliderMoved(int val); + void onOffToggled(bool state); + void clearButtonPressed(); + void expandButtonPressed(); + void parameterValueChanged(int fxid, int parameter, int val); + + signals: + void loadPlugin(int fxid, QString lib, QString name); + void returnLevelChanged(int fxid, int val); + void fxToggled(int fxid, int state); + void clearPlugin(int fxid); + void sizeChanged(int fxid, int val); + void effectParameterChanged(int fxid, int param, int val); + + private: + void createPluginParameters(); + }; + + +//------------------------------- +// SS_PluginGui +// Main plugin class, dialog +//------------------------------- +class SS_PluginGui : public QDialog + { + Q_OBJECT + private: + QVBoxLayout* layout; + SS_PluginFront* pluginFronts[4]; + + public: + SS_PluginGui(QWidget* parent); + SS_PluginFront* getPluginFront(unsigned i); + ~SS_PluginGui() {} +private slots: + void pluginFrontSizeChanged(int fxid, int val); + }; + + +#endif + |