Loading...
Searching...
No Matches
gx_modulesequencer.h
Go to the documentation of this file.
/*
* Copyright (C) 2009, 2010 Hermann Meyer, James Warden, Andreas Degert
* Copyright (C) 2011 Pete Shorthose
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
* --------------------------------------------------------------------------
*/
#pragma once
namespace gx_engine {
/****************************************************************
** class ModuleSelector
*/
class ModuleSelector {
protected:
EngineControl& seq;
public:
ModuleSelector(EngineControl& seq_)
: seq(seq_) {}
virtual ~ModuleSelector() {}
virtual void set_module() = 0;
};
/****************************************************************
** class ProcessingChainBase
** members and methods accessed by the rt thread are marked RT
*/
class ProcessingChainBase {
public:
enum RampMode { ramp_mode_down_dead, ramp_mode_down, ramp_mode_up_dead, ramp_mode_up, ramp_mode_off };
private:
sem_t sync_sem; // RT
list<Plugin*> to_release;
int ramp_value; // RT
int ramp_mode; // RT should be RampMode, but gcc 4.5 doesn't accept it for g_atomic_int_compare_and_exchange
volatile bool stopped;
protected:
int steps_up; // RT; >= 1
int steps_up_dead; // RT; >= 0
int steps_down; // RT; >= 1
list<Plugin*> modules;
inline void set_ramp_value(int n) { gx_system::atomic_set(&ramp_value, n); } // RT
inline void set_ramp_mode(RampMode n) { gx_system::atomic_set(&ramp_mode, n); } // RT
void try_set_ramp_mode(RampMode oldmode, RampMode newmode, int oldrv, int newrv); // RT
public:
bool next_commit_needs_ramp;
ProcessingChainBase();
inline RampMode get_ramp_mode() {
return static_cast<RampMode>(gx_system::atomic_get(ramp_mode)); // RT
}
inline int get_ramp_value() { return gx_system::atomic_get(ramp_value); } // RT
void set_samplerate(int samplerate);
bool set_plugin_list(const list<Plugin*> &p);
void clear_module_states();
inline void post_rt_finished() { // RT
int val;
sem_getvalue(&sync_sem, &val);
if (val == 0) {
sem_post(&sync_sem);
}
}
bool wait_rt_finished();
void set_latch();
void wait_latch() { wait_rt_finished(); }
void sync() { set_latch(); wait_latch(); }
inline bool check_release() { return !to_release.empty(); }
void release();
#ifdef GUITARIX_AS_PLUGIN
void process_ramp(int count);
#endif
void wait_ramp_down_finished();
void start_ramp_up();
void start_ramp_down();
inline void set_down_dead() { set_ramp_mode(ramp_mode_down_dead); }
inline bool is_down_dead() { return get_ramp_mode() == ramp_mode_down_dead; }
void set_stopped(bool v);
bool is_stopped() { return stopped; }
#ifndef NDEBUG
void print_chain_state(const char *title);
#endif
};
/****************************************************************
** template class ThreadSafeChainPointer
** members and methods accessed by the rt thread are marked RT
*/
template <class F>
class ThreadSafeChainPointer: public ProcessingChainBase {
private:
F *rack_order_ptr[2]; // RT
int size[2];
int current_index;
F *current_pointer;
void setsize(int n);
inline F get_audio(PluginDef *p);
protected:
F *processing_pointer; // RT
inline F* get_rt_chain() { return gx_system::atomic_get(processing_pointer); } // RT
public:
ThreadSafeChainPointer();
~ThreadSafeChainPointer();
inline void empty_chain(ParamMap& pmap) {
list<Plugin*> p;
if (set_plugin_list(p)) {
commit(true, pmap);
}
}
void commit(bool clear, ParamMap& pmap);
};
typedef void (*monochainorder)(int count, float *output, float *output1,
PluginDef *plugin);
typedef void (*stereochainorder)(int count, float* input, float* input1,
float *output, float *output1, PluginDef *plugin);
struct monochain_data {
monochainorder func;
PluginDef *plugin;
monochain_data(monochainorder func_, PluginDef *plugin_): func(func_), plugin(plugin_) {}
monochain_data(): func(), plugin() {}
};
struct stereochain_data {
stereochainorder func;
PluginDef *plugin;
stereochain_data(stereochainorder func_, PluginDef *plugin_): func(func_), plugin(plugin_) {}
stereochain_data(): func(), plugin() {}
};
template <>
inline monochain_data ThreadSafeChainPointer<monochain_data>::get_audio(PluginDef *p)
{
return monochain_data(p->mono_audio, p);
}
template <>
inline stereochain_data ThreadSafeChainPointer<stereochain_data>::get_audio(PluginDef *p)
{
return stereochain_data(p->stereo_audio, p);
}
template <class F>
ThreadSafeChainPointer<F>::ThreadSafeChainPointer():
rack_order_ptr(),
size(),
current_index(0),
current_pointer(),
processing_pointer() {
setsize(1);
current_pointer[0].func = 0;
processing_pointer = current_pointer;
current_index = 1;
current_pointer = rack_order_ptr[1];
}
template <class F>
ThreadSafeChainPointer<F>::~ThreadSafeChainPointer() {
delete[] rack_order_ptr[0];
delete[] rack_order_ptr[1];
}
template <class F>
void ThreadSafeChainPointer<F>::setsize(int n)
{
if (n <= size[current_index]) {
return;
}
delete[] rack_order_ptr[current_index];
rack_order_ptr[current_index] = new F[n];
size[current_index] = n;
current_pointer = rack_order_ptr[current_index];
}
template <class F>
void ThreadSafeChainPointer<F>::commit(bool clear, ParamMap& pmap) {
setsize(modules.size()+1); // leave one slot for 0 marker
int active_counter = 0;
for (list<Plugin*>::const_iterator p = modules.begin(); p != modules.end(); p++) {
PluginDef* pd = (*p)->get_pdef();
if (pd->activate_plugin) {
if (pd->activate_plugin(true, pd) != 0) {
(*p)->set_on_off(false);
continue;
}
} else if (pd->clear_state && clear) {
pd->clear_state(pd);
}
F f = get_audio(pd);
assert(f.func);
current_pointer[active_counter++] = f;
}
current_pointer[active_counter].func = 0;
gx_system::atomic_set(&processing_pointer, current_pointer);
set_latch();
current_index = (current_index+1) % 2;
current_pointer = rack_order_ptr[current_index];
}
/****************************************************************
** class MonoModuleChain, class StereoModuleChain
*/
class MonoModuleChain: public ThreadSafeChainPointer<monochain_data> {
public:
MonoModuleChain(): ThreadSafeChainPointer<monochain_data>() {}
void process(int count, float *input, float *output);
inline void print() { printlist("Mono", modules); }
};
class StereoModuleChain: public ThreadSafeChainPointer<stereochain_data> {
public:
StereoModuleChain(): ThreadSafeChainPointer<stereochain_data>() {}
#ifndef GUITARIX_AS_PLUGIN
void process(int count, float *input1, float *input2, float *output1, float *output2);
#else
void process(int count, float *input1, float *input2, float *output1, float *output2, bool feed=true);
#endif
inline void print() { printlist("Stereo", modules); }
};
/****************************************************************
** class EngineControl
*/
class EngineControl {
protected:
list<ModuleSelector*> selectors; // selectors that modify the on/off state of
// modules at start of reconfiguration
sigc::connection rack_changed; // idle signal for reconfiguration of module chains
ParamMap pmap;
int policy; // jack realtime policy,
int priority; // and priority, for internal modules
// signal anyone who needs to be synchronously notified
// BE CAREFUL: executed by RT thread (though not concurrent with audio
// modules, and timing requirements are relaxed)
sigc::signal<void, unsigned int> buffersize_change;
sigc::signal<void, unsigned int> samplerate_change;
unsigned int buffersize;
unsigned int samplerate;
public:
ParallelThread pro;
enum OverloadType { // type of overload condition
ov_User = 0x1, // idle thread probe starved
ov_Convolver = 0x2, // convolver overload
ov_XRun = 0x4, // jack audio loop overload
ov_NoWarn = 0x8 // disable overlaod warning
};
PluginList pluginlist;
EngineControl();
~EngineControl();
void init(unsigned int samplerate, unsigned int buffersize,
int policy, int priority);
virtual void wait_ramp_down_finished() = 0;
virtual bool update_module_lists() = 0;
virtual void start_ramp_up() = 0;
virtual void start_ramp_down() = 0;
virtual void overload(OverloadType tp, const char *reason) = 0; // RT
void set_samplerate(unsigned int samplerate_);
unsigned int get_samplerate() { return samplerate; }
void set_buffersize(unsigned int buffersize_);
unsigned int get_buffersize() { return buffersize; }
virtual void set_rack_changed() = 0;
void clear_rack_changed();
bool get_rack_changed();
sigc::signal<void, unsigned int>& signal_buffersize_change() { return buffersize_change; }
sigc::signal<void, unsigned int>& signal_samplerate_change() { return samplerate_change; }
void add_selector(ModuleSelector& sel);
void registerParameter(ParameterGroups& groups);
void get_sched_priority(int &policy, int &priority, int prio_dim = 0);
ParamMap& get_param() { return pmap; }
#ifdef GUITARIX_AS_PLUGIN
virtual sigc::signal<bool ()>& signal_timeout()=0;
#endif
};
/****************************************************************
** class ModuleSequencer
*/
enum GxEngineState { // engine states set by user (ModuleSequencer set_state/get_state)
kEngineOff = 0, // mute, no output (but tuner or something might run)
kEngineOn = 1, // normal operation
kEngineBypass = 2 // just some balance or level control
};
class ModuleSequencer: public EngineControl {
protected:
int audio_mode; // GxEngineState coded as PGN_MODE_XX flags
boost::mutex stateflags_mutex;
int stateflags;
sigc::signal<void, GxEngineState> state_change;
Glib::Dispatcher overload_detected;
const char *overload_reason; // name of unit which detected overload
int ov_disabled; // bitmask of OverloadType
static int sporadic_interval; // seconds; overload if at least 2 events in the timespan
#ifdef GUITARIX_AS_PLUGIN
sigc::signal<bool ()> _signal_timeout;
sigc::connection clearoverride_conn;
#endif
protected:
void check_overload();
public:
MonoModuleChain mono_chain; // active modules (amp chain, input to insert output)
StereoModuleChain stereo_chain; // active stereo modules (effect chain, after insert input)
enum StateFlag { // engine is off if one of these flags is set
SF_NO_CONNECTION = 0x01, // no jack connection at amp input
SF_JACK_RECONFIG = 0x02, // jack buffersize reconfiguration in progress
SF_INITIALIZING = 0x04, // jack or engine not ready
SF_OVERLOAD = 0x08, // engine overload
};
public:
ModuleSequencer();
~ModuleSequencer();
void clear_module_states() {
mono_chain.clear_module_states();
stereo_chain.clear_module_states();
}
virtual void set_samplerate(unsigned int samplerate);
virtual void start_ramp_up();
virtual void start_ramp_down();
virtual void wait_ramp_down_finished();
void ramp_down() {
start_ramp_down();
wait_ramp_down_finished();
}
void set_down_dead() {
mono_chain.set_down_dead();
stereo_chain.set_down_dead();
}
bool prepare_module_lists();
void commit_module_lists();
virtual void set_rack_changed();
virtual bool update_module_lists();
bool check_module_lists();
virtual void overload(OverloadType tp, const char *reason); // RT
void set_stateflag(StateFlag flag); // RT
void clear_stateflag(StateFlag flag); // RT
void set_state(GxEngineState state);
GxEngineState get_state();
sigc::signal<void, GxEngineState>& signal_state_change() { return state_change; }
static void set_overload_interval(int i) { sporadic_interval = i; }
#ifdef GUITARIX_AS_PLUGIN
sigc::signal<bool ()>& signal_timeout() override { return _signal_timeout; }
#endif
#ifndef NDEBUG
void print_engine_state();
#endif
};
} /* end of gx_engine namespace */
ParallelThread
Definition ParallelThread.h:130
gx_engine::EngineControl
Definition gx_modulesequencer.h:245
gx_engine::EngineControl::priority
int priority
Definition gx_modulesequencer.h:252
gx_engine::EngineControl::pluginlist
PluginList pluginlist
Definition gx_modulesequencer.h:268
gx_engine::EngineControl::overload
virtual void overload(OverloadType tp, const char *reason)=0
gx_engine::EngineControl::get_sched_priority
void get_sched_priority(int &policy, int &priority, int prio_dim=0)
gx_engine::EngineControl::EngineControl
EngineControl()
gx_engine::EngineControl::OverloadType
OverloadType
Definition gx_modulesequencer.h:262
gx_engine::EngineControl::ov_XRun
@ ov_XRun
Definition gx_modulesequencer.h:265
gx_engine::EngineControl::ov_Convolver
@ ov_Convolver
Definition gx_modulesequencer.h:264
gx_engine::EngineControl::ov_NoWarn
@ ov_NoWarn
Definition gx_modulesequencer.h:266
gx_engine::EngineControl::ov_User
@ ov_User
Definition gx_modulesequencer.h:263
gx_engine::EngineControl::buffersize
unsigned int buffersize
Definition gx_modulesequencer.h:258
gx_engine::EngineControl::add_selector
void add_selector(ModuleSelector &sel)
gx_engine::EngineControl::signal_buffersize_change
sigc::signal< void, unsigned int > & signal_buffersize_change()
Definition gx_modulesequencer.h:285
gx_engine::EngineControl::pmap
ParamMap pmap
Definition gx_modulesequencer.h:250
gx_engine::EngineControl::samplerate
unsigned int samplerate
Definition gx_modulesequencer.h:259
gx_engine::EngineControl::init
void init(unsigned int samplerate, unsigned int buffersize, int policy, int priority)
gx_engine::EngineControl::get_samplerate
unsigned int get_samplerate()
Definition gx_modulesequencer.h:279
gx_engine::EngineControl::selectors
list< ModuleSelector * > selectors
Definition gx_modulesequencer.h:247
gx_engine::EngineControl::get_buffersize
unsigned int get_buffersize()
Definition gx_modulesequencer.h:281
gx_engine::EngineControl::signal_samplerate_change
sigc::signal< void, unsigned int > & signal_samplerate_change()
Definition gx_modulesequencer.h:286
gx_engine::EngineControl::registerParameter
void registerParameter(ParameterGroups &groups)
gx_engine::EngineControl::update_module_lists
virtual bool update_module_lists()=0
gx_engine::EngineControl::pro
ParallelThread pro
Definition gx_modulesequencer.h:261
gx_engine::EngineControl::set_rack_changed
virtual void set_rack_changed()=0
gx_engine::EngineControl::~EngineControl
~EngineControl()
gx_engine::EngineControl::set_buffersize
void set_buffersize(unsigned int buffersize_)
gx_engine::EngineControl::policy
int policy
Definition gx_modulesequencer.h:251
gx_engine::EngineControl::clear_rack_changed
void clear_rack_changed()
gx_engine::EngineControl::wait_ramp_down_finished
virtual void wait_ramp_down_finished()=0
gx_engine::EngineControl::samplerate_change
sigc::signal< void, unsigned int > samplerate_change
Definition gx_modulesequencer.h:257
gx_engine::EngineControl::start_ramp_down
virtual void start_ramp_down()=0
gx_engine::EngineControl::rack_changed
sigc::connection rack_changed
Definition gx_modulesequencer.h:249
gx_engine::EngineControl::get_rack_changed
bool get_rack_changed()
gx_engine::EngineControl::get_param
ParamMap & get_param()
Definition gx_modulesequencer.h:290
gx_engine::EngineControl::buffersize_change
sigc::signal< void, unsigned int > buffersize_change
Definition gx_modulesequencer.h:256
gx_engine::EngineControl::set_samplerate
void set_samplerate(unsigned int samplerate_)
gx_engine::EngineControl::start_ramp_up
virtual void start_ramp_up()=0
gx_engine::ModuleSelector
Definition gx_modulesequencer.h:29
gx_engine::ModuleSelector::ModuleSelector
ModuleSelector(EngineControl &seq_)
Definition gx_modulesequencer.h:33
gx_engine::ModuleSelector::seq
EngineControl & seq
Definition gx_modulesequencer.h:31
gx_engine::ModuleSelector::~ModuleSelector
virtual ~ModuleSelector()
Definition gx_modulesequencer.h:35
gx_engine::ModuleSelector::set_module
virtual void set_module()=0
gx_engine::ModuleSequencer::~ModuleSequencer
~ModuleSequencer()
gx_engine::ModuleSequencer::StateFlag
StateFlag
Definition gx_modulesequencer.h:327
gx_engine::ModuleSequencer::SF_NO_CONNECTION
@ SF_NO_CONNECTION
Definition gx_modulesequencer.h:328
gx_engine::ModuleSequencer::SF_INITIALIZING
@ SF_INITIALIZING
Definition gx_modulesequencer.h:330
gx_engine::ModuleSequencer::SF_OVERLOAD
@ SF_OVERLOAD
Definition gx_modulesequencer.h:331
gx_engine::ModuleSequencer::SF_JACK_RECONFIG
@ SF_JACK_RECONFIG
Definition gx_modulesequencer.h:329
gx_engine::ModuleSequencer::overload
virtual void overload(OverloadType tp, const char *reason)
gx_engine::ModuleSequencer::state_change
sigc::signal< void, GxEngineState > state_change
Definition gx_modulesequencer.h:313
gx_engine::ModuleSequencer::print_engine_state
void print_engine_state()
gx_engine::ModuleSequencer::set_samplerate
virtual void set_samplerate(unsigned int samplerate)
gx_engine::ModuleSequencer::prepare_module_lists
bool prepare_module_lists()
gx_engine::ModuleSequencer::overload_reason
const char * overload_reason
Definition gx_modulesequencer.h:315
gx_engine::ModuleSequencer::check_module_lists
bool check_module_lists()
gx_engine::ModuleSequencer::start_ramp_up
virtual void start_ramp_up()
gx_engine::ModuleSequencer::start_ramp_down
virtual void start_ramp_down()
gx_engine::ModuleSequencer::sporadic_interval
static int sporadic_interval
Definition gx_modulesequencer.h:317
gx_engine::ModuleSequencer::set_down_dead
void set_down_dead()
Definition gx_modulesequencer.h:348
gx_engine::ModuleSequencer::stateflags
int stateflags
Definition gx_modulesequencer.h:312
gx_engine::ModuleSequencer::get_state
GxEngineState get_state()
gx_engine::ModuleSequencer::set_rack_changed
virtual void set_rack_changed()
gx_engine::ModuleSequencer::ModuleSequencer
ModuleSequencer()
gx_engine::ModuleSequencer::set_stateflag
void set_stateflag(StateFlag flag)
gx_engine::ModuleSequencer::stereo_chain
StereoModuleChain stereo_chain
Definition gx_modulesequencer.h:326
gx_engine::ModuleSequencer::signal_state_change
sigc::signal< void, GxEngineState > & signal_state_change()
Definition gx_modulesequencer.h:362
gx_engine::ModuleSequencer::mono_chain
MonoModuleChain mono_chain
Definition gx_modulesequencer.h:325
gx_engine::ModuleSequencer::set_state
void set_state(GxEngineState state)
gx_engine::ModuleSequencer::clear_stateflag
void clear_stateflag(StateFlag flag)
gx_engine::ModuleSequencer::set_overload_interval
static void set_overload_interval(int i)
Definition gx_modulesequencer.h:363
gx_engine::ModuleSequencer::check_overload
void check_overload()
gx_engine::ModuleSequencer::wait_ramp_down_finished
virtual void wait_ramp_down_finished()
gx_engine::ModuleSequencer::overload_detected
Glib::Dispatcher overload_detected
Definition gx_modulesequencer.h:314
gx_engine::ModuleSequencer::stateflags_mutex
boost::mutex stateflags_mutex
Definition gx_modulesequencer.h:311
gx_engine::ModuleSequencer::clear_module_states
void clear_module_states()
Definition gx_modulesequencer.h:336
gx_engine::ModuleSequencer::commit_module_lists
void commit_module_lists()
gx_engine::ModuleSequencer::ramp_down
void ramp_down()
Definition gx_modulesequencer.h:344
gx_engine::ModuleSequencer::ov_disabled
int ov_disabled
Definition gx_modulesequencer.h:316
gx_engine::ModuleSequencer::update_module_lists
virtual bool update_module_lists()
gx_engine::ModuleSequencer::audio_mode
int audio_mode
Definition gx_modulesequencer.h:310
gx_engine::MonoModuleChain
Definition gx_modulesequencer.h:222
gx_engine::MonoModuleChain::print
void print()
Definition gx_modulesequencer.h:226
gx_engine::MonoModuleChain::process
void process(int count, float *input, float *output)
gx_engine::MonoModuleChain::MonoModuleChain
MonoModuleChain()
Definition gx_modulesequencer.h:224
gx_engine::ParamMap
Definition gx_parameter.h:535
gx_engine::ParameterGroups
Definition gx_parameter.h:47
gx_engine::PluginList
Definition gx_pluginloader.h:156
gx_engine::ProcessingChainBase::steps_up_dead
int steps_up_dead
Definition gx_modulesequencer.h:56
gx_engine::ProcessingChainBase::set_stopped
void set_stopped(bool v)
gx_engine::ProcessingChainBase::sync
void sync()
Definition gx_modulesequencer.h:82
gx_engine::ProcessingChainBase::set_latch
void set_latch()
gx_engine::ProcessingChainBase::is_stopped
bool is_stopped()
Definition gx_modulesequencer.h:94
gx_engine::ProcessingChainBase::sync_sem
sem_t sync_sem
Definition gx_modulesequencer.h:49
gx_engine::ProcessingChainBase::ramp_mode
int ramp_mode
Definition gx_modulesequencer.h:52
gx_engine::ProcessingChainBase::post_rt_finished
void post_rt_finished()
Definition gx_modulesequencer.h:72
gx_engine::ProcessingChainBase::start_ramp_down
void start_ramp_down()
gx_engine::ProcessingChainBase::get_ramp_mode
RampMode get_ramp_mode()
Definition gx_modulesequencer.h:65
gx_engine::ProcessingChainBase::get_ramp_value
int get_ramp_value()
Definition gx_modulesequencer.h:68
gx_engine::ProcessingChainBase::release
void release()
gx_engine::ProcessingChainBase::set_samplerate
void set_samplerate(int samplerate)
gx_engine::ProcessingChainBase::ProcessingChainBase
ProcessingChainBase()
gx_engine::ProcessingChainBase::check_release
bool check_release()
Definition gx_modulesequencer.h:83
gx_engine::ProcessingChainBase::next_commit_needs_ramp
bool next_commit_needs_ramp
Definition gx_modulesequencer.h:63
gx_engine::ProcessingChainBase::set_down_dead
void set_down_dead()
Definition gx_modulesequencer.h:91
gx_engine::ProcessingChainBase::clear_module_states
void clear_module_states()
gx_engine::ProcessingChainBase::wait_rt_finished
bool wait_rt_finished()
gx_engine::ProcessingChainBase::steps_down
int steps_down
Definition gx_modulesequencer.h:57
gx_engine::ProcessingChainBase::set_ramp_mode
void set_ramp_mode(RampMode n)
Definition gx_modulesequencer.h:60
gx_engine::ProcessingChainBase::try_set_ramp_mode
void try_set_ramp_mode(RampMode oldmode, RampMode newmode, int oldrv, int newrv)
gx_engine::ProcessingChainBase::wait_ramp_down_finished
void wait_ramp_down_finished()
gx_engine::ProcessingChainBase::is_down_dead
bool is_down_dead()
Definition gx_modulesequencer.h:92
gx_engine::ProcessingChainBase::set_ramp_value
void set_ramp_value(int n)
Definition gx_modulesequencer.h:59
gx_engine::ProcessingChainBase::wait_latch
void wait_latch()
Definition gx_modulesequencer.h:81
gx_engine::ProcessingChainBase::start_ramp_up
void start_ramp_up()
gx_engine::ProcessingChainBase::stopped
volatile bool stopped
Definition gx_modulesequencer.h:53
gx_engine::ProcessingChainBase::to_release
list< Plugin * > to_release
Definition gx_modulesequencer.h:50
gx_engine::ProcessingChainBase::print_chain_state
void print_chain_state(const char *title)
gx_engine::ProcessingChainBase::set_plugin_list
bool set_plugin_list(const list< Plugin * > &p)
gx_engine::ProcessingChainBase::steps_up
int steps_up
Definition gx_modulesequencer.h:55
gx_engine::ProcessingChainBase::ramp_value
int ramp_value
Definition gx_modulesequencer.h:51
gx_engine::ProcessingChainBase::modules
list< Plugin * > modules
Definition gx_modulesequencer.h:58
gx_engine::ProcessingChainBase::RampMode
RampMode
Definition gx_modulesequencer.h:47
gx_engine::ProcessingChainBase::ramp_mode_up_dead
@ ramp_mode_up_dead
Definition gx_modulesequencer.h:47
gx_engine::ProcessingChainBase::ramp_mode_down
@ ramp_mode_down
Definition gx_modulesequencer.h:47
gx_engine::ProcessingChainBase::ramp_mode_down_dead
@ ramp_mode_down_dead
Definition gx_modulesequencer.h:47
gx_engine::ProcessingChainBase::ramp_mode_off
@ ramp_mode_off
Definition gx_modulesequencer.h:47
gx_engine::ProcessingChainBase::ramp_mode_up
@ ramp_mode_up
Definition gx_modulesequencer.h:47
gx_engine::StereoModuleChain
Definition gx_modulesequencer.h:229
gx_engine::StereoModuleChain::print
void print()
Definition gx_modulesequencer.h:237
gx_engine::StereoModuleChain::StereoModuleChain
StereoModuleChain()
Definition gx_modulesequencer.h:231
gx_engine::StereoModuleChain::process
void process(int count, float *input1, float *input2, float *output1, float *output2)
gx_engine::ThreadSafeChainPointer::current_pointer
F * current_pointer
Definition gx_modulesequencer.h:112
gx_engine::ThreadSafeChainPointer::commit
void commit(bool clear, ParamMap &pmap)
Definition gx_modulesequencer.h:194
gx_engine::ThreadSafeChainPointer::current_index
int current_index
Definition gx_modulesequencer.h:111
gx_engine::ThreadSafeChainPointer::~ThreadSafeChainPointer
~ThreadSafeChainPointer()
Definition gx_modulesequencer.h:176
gx_engine::ThreadSafeChainPointer::setsize
void setsize(int n)
Definition gx_modulesequencer.h:182
gx_engine::ThreadSafeChainPointer::get_audio
F get_audio(PluginDef *p)
gx_engine::ThreadSafeChainPointer::ThreadSafeChainPointer
ThreadSafeChainPointer()
Definition gx_modulesequencer.h:162
gx_engine::ThreadSafeChainPointer::empty_chain
void empty_chain(ParamMap &pmap)
Definition gx_modulesequencer.h:121
gx_engine::ThreadSafeChainPointer::rack_order_ptr
F * rack_order_ptr[2]
Definition gx_modulesequencer.h:109
gx_engine::ThreadSafeChainPointer::size
int size[2]
Definition gx_modulesequencer.h:110
gx_engine::ThreadSafeChainPointer::processing_pointer
F * processing_pointer
Definition gx_modulesequencer.h:116
gx_engine::ThreadSafeChainPointer::get_rt_chain
F * get_rt_chain()
Definition gx_modulesequencer.h:117
gx_engine
Definition gx_convolver.h:37
gx_engine::printlist
void printlist(const char *title, const list< Plugin * > &modules, bool header=true)
gx_engine::GxEngineState
GxEngineState
Definition gx_modulesequencer.h:301
gx_engine::kEngineOn
@ kEngineOn
Definition gx_modulesequencer.h:303
gx_engine::kEngineBypass
@ kEngineBypass
Definition gx_modulesequencer.h:304
gx_engine::kEngineOff
@ kEngineOff
Definition gx_modulesequencer.h:302
gx_engine::monochainorder
void(* monochainorder)(int count, float *output, float *output1, PluginDef *plugin)
Definition gx_modulesequencer.h:130
gx_engine::stereochainorder
void(* stereochainorder)(int count, float *input, float *input1, float *output, float *output1, PluginDef *plugin)
Definition gx_modulesequencer.h:132
gx_system::atomic_get
int atomic_get(volatile int &p)
Definition gx_system.h:98
gx_system::atomic_set
void atomic_set(volatile int *p, int v)
Definition gx_system.h:90
PluginDef
Definition gx_plugin.h:195
PluginDef::clear_state
clearstatefunc clear_state
Definition gx_plugin.h:216
PluginDef::mono_audio
process_mono_audio mono_audio
Definition gx_plugin.h:209
PluginDef::stereo_audio
process_stereo_audio stereo_audio
Definition gx_plugin.h:210
PluginDef::activate_plugin
activatefunc activate_plugin
Definition gx_plugin.h:213
gx_engine::monochain_data
Definition gx_modulesequencer.h:135
gx_engine::monochain_data::monochain_data
monochain_data(monochainorder func_, PluginDef *plugin_)
Definition gx_modulesequencer.h:138
gx_engine::monochain_data::func
monochainorder func
Definition gx_modulesequencer.h:136
gx_engine::monochain_data::plugin
PluginDef * plugin
Definition gx_modulesequencer.h:137
gx_engine::monochain_data::monochain_data
monochain_data()
Definition gx_modulesequencer.h:139
gx_engine::stereochain_data
Definition gx_modulesequencer.h:142
gx_engine::stereochain_data::stereochain_data
stereochain_data(stereochainorder func_, PluginDef *plugin_)
Definition gx_modulesequencer.h:145
gx_engine::stereochain_data::func
stereochainorder func
Definition gx_modulesequencer.h:143
gx_engine::stereochain_data::stereochain_data
stereochain_data()
Definition gx_modulesequencer.h:146
gx_engine::stereochain_data::plugin
PluginDef * plugin
Definition gx_modulesequencer.h:144