Loading...
Searching...
No Matches
gx_internal_plugins.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.
* --------------------------------------------------------------------------
*/
/* ------- This is the guitarix Engine namespace ------- */
#pragma once
#include "gx_neural_plugins.h"
namespace gx_jack { class GxJack; }
namespace gx_engine {
/****************************************************************
** MonoMute, StereoMute, MaxLevel
*/
class MonoMute: public PluginDef {
private:
static void process(int count, float *input, float *output, PluginDef*);
public:
MonoMute();
};
class StereoMute: public PluginDef {
private:
static void process(int count, float *input0, float *input1,
float *output0, float *output1, PluginDef*);
public:
StereoMute();
};
class MaxLevel: public PluginDef {
public:
static const unsigned int channelcount = 2;
private:
static float maxlevel[channelcount];
static void process(int count, float *input0, float *input1,
float *output0, float *output1, PluginDef*);
static int activate(bool start, PluginDef *plugin);
static int regparam(const ParamReg& reg);
public:
static float get(unsigned int channel) {
assert(channel < channelcount);
float v = maxlevel[channel];
maxlevel[channel] = 0;
return v;
}
MaxLevel();
};
/****************************************************************
** class TunerAdapter
*/
#ifndef GUITARIX_AS_PLUGIN
#include "faust/low_high_cut.h"
#else
#include "low_high_cut.h"
#endif
class TunerAdapter: public ModuleSelector, private PluginDef, public sigc::trackable {
private:
static void feed_tuner(int count, float *input, float *output, PluginDef*);
static int regparam(const ParamReg& reg);
static int activate(bool start, PluginDef *plugin);
static void init(unsigned int samplingFreq, PluginDef *plugin);
low_high_cut::Dsp lhc;
PitchTracker pitch_tracker;
int state;
ModuleSequencer& engine;
enum { tuner_use = 0x01, switcher_use = 0x02, midi_use = 0x04 };
void set_and_check(int use, bool on);
Plugin* dep_plugin;
public:
Plugin plugin;
TunerAdapter(ModuleSequencer& engine);
void used_for_switching(bool on) { set_and_check(switcher_use, on); }
void used_for_display(bool on) { set_and_check(tuner_use, on); }
bool used_for_display() { return state & tuner_use; }
void used_by_midi(bool on) { set_and_check(midi_use, on); }
void set_dep_module(Plugin* dep) { dep_plugin = dep; }
void set_module();
void set_fast_note_detection(bool on) { return pitch_tracker.set_fast_note_detection(on); }
sigc::signal<void >& signal_freq_changed() { return pitch_tracker.new_freq; }
float get_freq() { return pitch_tracker.get_estimated_freq(); }
float get_note() { return pitch_tracker.get_estimated_note(); }
};
/****************************************************************
** class NoiseGate
*/
class NoiseGate : public PluginDef {
private:
inline void inputlevel_process(int count, float *input0, float *output0);
inline int noisegate_register(const ParamReg& reg);
inline int noisegate_start(bool start);
static int noisegate_params_static(const ParamReg& reg);
static void inputlevel_compute(int count, float *input0, float *output0, PluginDef*);
static int noisegate_activate(bool start, PluginDef *pdef);
public:
bool off;
float fnglevel;
float ngate;
PluginDef inputdef;
Plugin inputlevel;
NoiseGate();
};
/****************************************************************
** class OutPutGate
*/
class OutPutGate : public PluginDef {
private:
inline void outputgate_process(int count, float *input, float *output);
static void outputgate_compute(int count, float *input, float *output, PluginDef*);
public:
const NoiseGate *noisegate;
PluginDef outputdef;
Plugin outputlevel;
OutPutGate(const NoiseGate *noisegate);
};
/****************************************************************
** class OscilloscopeAdapter
*/
class OscilloscopeInfo {
private:
gx_jack::GxJack *jack;
sigc::signal<void(unsigned int, float*)> size_change;
float *buffer;
unsigned int buffer_size;
friend class OscilloscopeAdapter;
public:
int load;
int frames;
bool is_rt;
jack_nframes_t bsize;
public:
OscilloscopeInfo():
jack(nullptr), size_change(), buffer(nullptr), buffer_size(0),
load(0), frames(0), is_rt(false), bsize(0) {}
void readJSON(gx_system::JsonParser& jp);
void writeJSON(gx_system::JsonWriter& w) const;
void update();
float *get_buffer() const { return buffer; }
unsigned int get_buffer_size() const { return buffer_size; }
sigc::signal<void(unsigned int, float*)> signal_size_change() { return size_change; }
};
template<>
class ParameterV<OscilloscopeInfo>: public Parameter {
private:
OscilloscopeInfo value_storage;
OscilloscopeInfo *value;
sigc::signal<void, const OscilloscopeInfo&> changed;
void trigger_changed() override;
public:
ParameterV(const string& id, OscilloscopeInfo *v);
ParameterV(gx_system::JsonParser& jp);
~ParameterV();
virtual void serializeJSON(gx_system::JsonWriter& jw) override;
sigc::signal<void, const OscilloscopeInfo&>& signal_changed() { return changed; }
static ParameterV<OscilloscopeInfo> *insert_param(
ParamMap &pmap, const string& id, OscilloscopeInfo *v);
OscilloscopeInfo& get_value() const { return *value; }
virtual void stdJSON_value() override;
virtual bool on_off_value() override;
virtual void writeJSON(gx_system::JsonWriter& jw) const override;
virtual bool compareJSON_value() override;
virtual void setJSON_value() override;
virtual void readJSON_value(gx_system::JsonParser& jp) override;
};
typedef ParameterV<OscilloscopeInfo> OscParameter;
class OscilloscopeAdapter: PluginDef {
public:
OscilloscopeInfo info;
private:
ParamMap &pmap;
static void fill_buffer(int count, float *input0, float *output0, PluginDef*);
static int osc_register(const ParamReg& reg);
static int osc_load_ui(const UiBuilder& builder, int format);
void change_buffersize(unsigned int);
int mul_buffer;
public:
Plugin plugin;
void clear_buffer();
unsigned int get_size() const { return info.buffer_size; }
inline float *get_buffer() const { return info.buffer; }
int get_mul_buffer() { return mul_buffer; }
void set_mul_buffer(int a, unsigned int b) { mul_buffer = a; change_buffersize(b); }
OscilloscopeAdapter(ModuleSequencer& engine);
void set_jack(gx_jack::GxJack& jack) { info.jack = &jack; }
};
/****************************************************************
** class GxSeqSettings
*/
class GxSeqSettings {
private:
std::vector<int> seqline;
void read_seqline(gx_system::JsonParser& jp);
friend class SequencerAdapter;
friend class ParameterV<GxSeqSettings>;
public:
GxSeqSettings();
GxSeqSettings& operator=(GxSeqSettings const& seqset);
bool operator==(const GxSeqSettings& seqset) const;
// getters and setters
inline const std::vector<int>& getseqline() const { return seqline; }
inline void setseqline(const std::vector<int>& seq) { seqline = seq; }
public:
void readJSON(gx_system::JsonParser& jp);
void writeJSON(gx_system::JsonWriter& w) const;
};
template<>
class ParameterV<GxSeqSettings>: public Parameter {
private:
GxSeqSettings json_value;
GxSeqSettings *value;
GxSeqSettings std_value;
GxSeqSettings value_storage;
sigc::signal<void, const GxSeqSettings*> changed;
public:
ParameterV(const string& id, GxSeqSettings *v);
ParameterV(gx_system::JsonParser& jp);
~ParameterV();
virtual void serializeJSON(gx_system::JsonWriter& jw);
sigc::signal<void, const GxSeqSettings*>& signal_changed() { return changed; }
static ParameterV<GxSeqSettings> *insert_param(
ParamMap &pmap, const string& id, GxSeqSettings *v);
bool set(const GxSeqSettings& val) const;
const GxSeqSettings& get_value() const { return *value; }
virtual void stdJSON_value();
virtual bool on_off_value();
virtual void writeJSON(gx_system::JsonWriter& jw) const;
virtual bool compareJSON_value();
virtual void setJSON_value();
virtual void readJSON_value(gx_system::JsonParser& jp);
};
typedef ParameterV<GxSeqSettings> SeqParameter;
/****************************************************************
** class GxJConvSettings
*/
class GxJConvSettings {
private:
// main jconv setting
std::string fIRFile;
std::string fIRDir;
float fGain; // jconv gain
guint fOffset; // offset in IR where to start comvolution
guint fLength; // length of the IR to use for convolution
guint fDelay; // delay when to apply reverb
Gainline gainline;
bool fGainCor;
void read_gainline(gx_system::JsonParser& jp);
inline void setIRDir(string name) { fIRDir = name; }
friend class ConvolverAdapter;
friend class ParameterV<GxJConvSettings>;
public:
GxJConvSettings();
GxJConvSettings& operator=(GxJConvSettings const& jcset);
bool operator==(const GxJConvSettings& jcset) const;
// getters and setters
inline const std::string& getIRFile() const { return fIRFile; }
std::string getFullIRPath() const;
inline float getGain() const { return fGain; }
inline guint getOffset() const { return fOffset; }
inline guint getLength() const { return fLength; }
inline guint getDelay() const { return fDelay; }
inline bool getGainCor() const { return fGainCor; }
inline const Gainline& getGainline() const { return gainline; }
const std::string& getIRDir() const { return fIRDir; }
void setFullIRPath(string name);
inline void setIRFile(string name) { fIRFile = name; }
inline void setGain(float gain) { fGain = gain; }
inline void setGainCor(bool gain) { fGainCor = gain; }
inline void setOffset(guint offs) { fOffset = offs; }
inline void setLength(guint leng) { fLength = leng; }
inline void setDelay(guint del) { fDelay = del; }
inline void setGainline(const Gainline& gain) { gainline = gain; }
public:
void readJSON(gx_system::JsonParser& jp);
void writeJSON(gx_system::JsonWriter& w) const;
};
class ConvolverAdapter;
template<>
class ParameterV<GxJConvSettings>: public Parameter {
private:
GxJConvSettings json_value;
GxJConvSettings *value;
GxJConvSettings std_value;
GxJConvSettings value_storage;
sigc::signal<void, const GxJConvSettings*> changed;
public:
ParameterV(const string& id, ConvolverAdapter &conv, GxJConvSettings *v);
ParameterV(gx_system::JsonParser& jp);
~ParameterV();
virtual void serializeJSON(gx_system::JsonWriter& jw);
sigc::signal<void, const GxJConvSettings*>& signal_changed() { return changed; }
static ParameterV<GxJConvSettings> *insert_param(
ParamMap &pmap, const string& id, ConvolverAdapter &conv, GxJConvSettings *v);
bool set(const GxJConvSettings& val) const;
const GxJConvSettings& get_value() const { return *value; }
virtual void stdJSON_value();
virtual bool on_off_value();
virtual void writeJSON(gx_system::JsonWriter& jw) const;
virtual bool compareJSON_value();
virtual void setJSON_value();
virtual void readJSON_value(gx_system::JsonParser& jp);
};
typedef ParameterV<GxJConvSettings> JConvParameter;
/****************************************************************
** class ConvolverAdapter
*/
class ConvolverAdapter: protected PluginDef, public sigc::trackable {
protected:
GxConvolver conv;
boost::mutex activate_mutex;
EngineControl& engine;
sigc::slot<void> sync;
bool activated;
// wrapper for the rack order function pointers
void change_buffersize(unsigned int size);
GxJConvSettings jcset;
JConvParameter *jcp;
public:
Plugin plugin;
public:
ConvolverAdapter(EngineControl& engine, sigc::slot<void> sync);
~ConvolverAdapter();
void restart();
bool conv_start();
inline const std::string& getIRFile() const { return jcset.getIRFile(); }
inline void set_sync(bool val) { conv.set_sync(val); }
inline std::string getFullIRPath() const { return jcset.getFullIRPath(); }
inline const std::string& getIRDir() const { return jcset.getIRDir(); }
bool set(const GxJConvSettings& jcset) const { return jcp->set(jcset); }
const GxJConvSettings& get_jcset() const { return jcset; }
ParamMap& get_parameter_map() const { return engine.get_param(); }
};
/****************************************************************
** class ConvolverStereoAdapter
*/
#ifndef GUITARIX_AS_PLUGIN
#include "faust/jconv_post.h"
#include "faust/jconv_post_mono.h"
#else
#include "jconv_post.h"
#include "jconv_post_mono.h"
#endif
class ConvolverStereoAdapter: public ConvolverAdapter {
private:
jconv_post::Dsp jc_post;
// wrapper for the rack order function pointers
static void convolver_init(unsigned int samplingFreq, PluginDef *pdef);
static int activate(bool start, PluginDef *pdef);
static void convolver(int count, float *input0, float *input1,
float *output0, float *output1, PluginDef*);
static int convolver_register(const ParamReg& reg);
static int jconv_load_ui(const UiBuilder& builder, int format);
public:
ConvolverStereoAdapter(EngineControl& engine, sigc::slot<void> sync);
~ConvolverStereoAdapter();
};
/****************************************************************
** class ConvolverMonoAdapter
*/
class ConvolverMonoAdapter: public ConvolverAdapter {
private:
jconv_post_mono::Dsp jc_post_mono;
// wrapper for the rack order function pointers
static void convolver_init(unsigned int samplingFreq, PluginDef *pdef);
static int activate(bool start, PluginDef *pdef);
static void convolver(int count, float *input, float *output, PluginDef*);
static int convolver_register(const ParamReg& reg);
static int jconv_load_ui(const UiBuilder& builder, int format);
public:
ConvolverMonoAdapter(EngineControl& engine, sigc::slot<void> sync);
~ConvolverMonoAdapter();
};
/****************************************************************
** class BaseConvolver
*/
class BaseConvolver: protected PluginDef {
protected:
GxSimpleConvolver conv;
boost::mutex activate_mutex;
EngineControl& engine;
sigc::slot<void> sync;
bool activated;
sigc::connection update_conn;
static void init(unsigned int samplingFreq, PluginDef *p);
static int activate(bool start, PluginDef *pdef);
void change_buffersize(unsigned int);
int conv_start();
bool check_update_timeout();
virtual void check_update() = 0;
virtual bool start(bool force = false) = 0;
public:
Plugin plugin;
public:
BaseConvolver(EngineControl& engine, sigc::slot<void> sync, gx_resample::BufferResampler& resamp);
virtual ~BaseConvolver();
inline void set_sync(bool val) { conv.set_sync(val); }
};
/****************************************************************
** class FixedBaseConvolver
*/
class FixedBaseConvolver: protected PluginDef {
protected:
GxSimpleConvolver conv;
boost::mutex activate_mutex;
EngineControl& engine;
sigc::slot<void> sync;
bool activated;
unsigned int SamplingFreq;
unsigned int buffersize;
unsigned int bz;
sigc::connection update_conn;
static void init(unsigned int samplingFreq, PluginDef *p);
unsigned int getSamplingFreq() { return SamplingFreq;};
static int activate(bool start, PluginDef *pdef);
void change_buffersize(unsigned int);
int conv_start();
bool check_update_timeout();
virtual void check_update() = 0;
virtual bool start(bool force = false) = 0;
public:
Plugin plugin;
public:
FixedBaseConvolver(EngineControl& engine, sigc::slot<void> sync, gx_resample::BufferResampler& resamp);
virtual ~FixedBaseConvolver();
inline void set_sync(bool val) { conv.set_sync(val); }
};
/****************************************************************
** class CabinetConvolver
*/
#ifndef GUITARIX_AS_PLUGIN
#include "faust/cabinet_impulse_former.h"
#else
#include "cabinet_impulse_former.h"
#endif
class CabinetConvolver: public FixedBaseConvolver {
private:
int current_cab;
float level;
int cabinet;
float bass;
float treble;
value_pair *cab_names;
cabinet_impulse_former::Dsp impf;
gx_resample::FixedRateResampler smp;
static void run_cab_conf(int count, float *input, float *output, PluginDef*);
static int register_cab(const ParamReg& reg);
bool do_update();
virtual void check_update() override;
virtual bool start(bool force = false) override;
bool cabinet_changed() { return current_cab != cabinet; }
void update_cabinet() { current_cab = cabinet; }
public:
CabinetConvolver(EngineControl& engine, sigc::slot<void> sync,
gx_resample::BufferResampler& resamp);
~CabinetConvolver();
#ifdef GUITARIX_AS_PLUGIN
void pl_check_update() { return check_update();}
#endif
};
#ifndef GUITARIX_AS_PLUGIN
#include "faust/cabinet_impulse_former_st.h"
#else
#include "cabinet_impulse_former_st.h"
#endif
class CabinetStereoConvolver: public FixedBaseConvolver {
private:
int current_cab;
float level;
int cabinet;
float bass;
float treble;
value_pair *cab_names;
cabinet_impulse_former_st::Dsp impf;
gx_resample::FixedRateResampler smp;
gx_resample::FixedRateResampler smps;
static void run_cab_conf(int count, float *input, float *input1, float *output, float *output1, PluginDef*);
static int register_cab(const ParamReg& reg);
bool do_update();
virtual void check_update() override;
virtual bool start(bool force = false) override;
bool cabinet_changed() { return current_cab != cabinet; }
void update_cabinet() { current_cab = cabinet; }
public:
CabinetStereoConvolver(EngineControl& engine, sigc::slot<void> sync,
gx_resample::BufferResampler& resamp);
~CabinetStereoConvolver();
#ifdef GUITARIX_AS_PLUGIN
void pl_check_update() { return check_update();}
#endif
};
/****************************************************************
** class PreampConvolver
*/
#ifndef GUITARIX_AS_PLUGIN
#include "faust/preamp_impulse_former.h"
#else
#include "preamp_impulse_former.h"
#endif
class PreampConvolver: public FixedBaseConvolver {
private:
int current_pre;
float level;
int preamp;
float bass;
float treble;
value_pair *pre_names;
preamp_impulse_former::Dsp impf;
gx_resample::FixedRateResampler smp;
static void run_pre_conf(int count, float *input, float *output, PluginDef*);
static int register_pre(const ParamReg& reg);
bool do_update();
virtual void check_update() override;
virtual bool start(bool force = false) override;
bool preamp_changed() { return current_pre != preamp; }
void update_preamp() { current_pre = preamp; }
public:
PreampConvolver(EngineControl& engine, sigc::slot<void> sync,
gx_resample::BufferResampler& resamp);
~PreampConvolver();
#ifdef GUITARIX_AS_PLUGIN
void pl_check_update() { return check_update();}
#endif
};
#ifndef GUITARIX_AS_PLUGIN
#include "faust/preamp_impulse_former_st.h"
#else
#include "preamp_impulse_former_st.h"
#endif
class PreampStereoConvolver: public FixedBaseConvolver {
private:
int current_pre;
float level;
int preamp;
float bass;
float treble;
value_pair *pre_names;
preamp_impulse_former_st::Dsp impf;
gx_resample::FixedRateResampler smp;
gx_resample::FixedRateResampler smps;
static void run_pre_conf(int count, float *input, float *input1, float *output, float *output1, PluginDef*);
static int register_pre(const ParamReg& reg);
bool do_update();
virtual void check_update() override;
virtual bool start(bool force = false) override;
bool preamp_changed() { return current_pre != preamp; }
void update_preamp() { current_pre = preamp; }
public:
PreampStereoConvolver(EngineControl& engine, sigc::slot<void> sync,
gx_resample::BufferResampler& resamp);
~PreampStereoConvolver();
#ifdef GUITARIX_AS_PLUGIN
void pl_check_update() { return check_update();}
#endif
};
/****************************************************************
** class ContrastConvolver
*/
#ifndef GUITARIX_AS_PLUGIN
#include "faust/presence_level.h"
#else
#include "presence_level.h"
#endif
class ContrastConvolver: public FixedBaseConvolver {
private:
float level;
float sum;
presence_level::Dsp presl;
gx_resample::FixedRateResampler smp;
static void run_contrast(int count, float *input, float *output, PluginDef*);
static int register_con(const ParamReg& reg);
inline void update_sum() { sum = level; }
virtual void check_update() override;
bool do_update();
inline bool sum_changed() { return std::abs(sum - level) > 0.01; }
virtual bool start(bool force = false) override;
public:
ContrastConvolver(EngineControl& engine, sigc::slot<void> sync,
gx_resample::BufferResampler& resamp);
~ContrastConvolver();
#ifdef GUITARIX_AS_PLUGIN
void pl_check_update() { return check_update();}
#endif
};
/****************************************************************
** class LV2Features
*/
class LV2Features {
private:
static LV2_Options_Option gx_options[2];
static LV2_Feature gx_options_feature;
static LV2_URID lv2_urid_map(LV2_URID_Map_Handle, const char* const uri_);
static LV2_Feature gx_urid_map_feature;
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
static uint32_t lv2_uri_to_id(LV2_URI_Map_Callback_Data handle, const char*, const char* uri);
static LV2_URI_Map_Feature gx_uri_map;
static LV2_Feature gx_uri_map_feature;
#pragma GCC diagnostic pop
static const char* lv2_urid_unmap(LV2_URID_Unmap_Handle, const LV2_URID urid);
static LV2_Feature gx_urid_unmap_feature;
LV2Features() {};
public:
static LV2Features& getInstance()
{
static LV2Features instance;
return instance;
}
static LV2_Feature* gx_features[];
static LV2_URID_Map gx_urid_map;
static LV2_URID_Unmap gx_urid_unmap;
LV2Features(LV2Features const&) = delete;
void operator=(LV2Features const&) = delete;
};
/****************************************************************
** class LadspaLoader
*/
enum widget_type { tp_scale, tp_scale_log, tp_toggle, tp_enum, tp_display, tp_display_toggle, tp_none, tp_int, tp_enabled, tp_atom };
struct paradesc: boost::noncopyable {
int index;
std::string name;
float dflt;
float low;
float up;
float step;
widget_type tp;
bool newrow;
bool has_caption;
value_pair* values;
paradesc(): index(), name(), dflt(), low(), up(), step(), tp(), newrow(), has_caption(true), values() {}
~paradesc();
void set_valuelist(const std::vector<std::string>& v);
void readJSON(gx_system::JsonParser& jp);
void writeJSON(gx_system::JsonWriter& jw);
};
enum quirkflag { need_activate = 1, no_cleanup = 2, is_lv2 = 4 };
class plugdesc {
public:
std::string path;
unsigned int index;
unsigned long UniqueID;
Glib::ustring Label;
Glib::ustring shortname;
Glib::ustring category;
int quirks; // quirkflag bits
int add_wet_dry;
int stereo_to_mono;
int master_idx;
Glib::ustring master_label;
std::vector<paradesc*> names;
std::string id_str;
private:
plugdesc() {}
~plugdesc();
friend class LadspaLoader;
public:
void readJSON(gx_system::JsonParser& jp);
void writeJSON(gx_system::JsonWriter& jw);
};
class LadspaLoader {
public:
typedef std::vector<plugdesc*> pluginarray;
private:
const gx_system::CmdlineOptions& options;
pluginarray plugins;
LilvWorld* world;
ParamMap& param;
const LilvPlugins* lv2_plugins;
LilvNode* lv2_AudioPort;
LilvNode* lv2_ControlPort;
LilvNode* lv2_InputPort;
LilvNode* lv2_OutputPort;
LilvNode* lv2_AtomPort;
private:
void read_module_config(const std::string& filename, plugdesc *p);
void read_module_list(pluginarray& p);
public:
LadspaLoader(const gx_system::CmdlineOptions& options, ParamMap& param);
~LadspaLoader();
bool load(pluginarray& p);
unsigned int size() { return plugins.size(); }
PluginDef *create(unsigned int idx) { return create(plugins[idx]); }
PluginDef *create(const plugdesc *p);
pluginarray::iterator begin() { return plugins.begin(); }
pluginarray::iterator end() { return plugins.end(); }
pluginarray::iterator find(plugdesc* desc);
void clear_list();
void set_plugins(pluginarray& new_plugins);
void update_instance(PluginDef *pdef, plugdesc *pdesc);
static std::string get_ladspa_filename(unsigned long uid)
{ return "ladspa"+gx_system::to_string(uid)+".js"; }
static std::string get_ladspa_filename(std::string uid_key)
{ return "ladspa"+uid_key.substr(9)+".js"; }
ParamMap& get_parameter_map() const { return param; }
friend class Lv2Dsp;
};
/****************************************************************
** class Directout
*/
class Directout: public PluginDef {
public:
float* outdata;
private:
int fSamplingFreq;
int bsize;
bool fdfill;
EngineControl& engine;
sigc::slot<void> sync;
void mem_alloc();
void mem_free();
void init(unsigned int samplingFreq);
void compute(int count, float *input0, float *input1, float *output0, float *output1);
void change_buffersize(unsigned int size);
static void init_static(unsigned int samplingFreq, PluginDef*);
static void compute_static(int count, float *input0, float *input1, float *output0, float *output1, PluginDef*);
public:
bool mem_allocated;
float* get_buffer() {return outdata;};
void set_data(bool dfill);
Plugin plugin;
Directout( EngineControl& engine, sigc::slot<void> sync);
~Directout();
};
/****************************************************************
** class LiveLooper
*/
class LiveLooper: public PluginDef {
class FileResampler {
private:
Resampler r_file;
int inputRate, outputRate;
public:
int setup(int _inputRate, int _outputRate);
int run(int count, float *input, float *output);
int max_out_count(int in_count) {
return static_cast<int>(ceil((in_count*static_cast<double>(outputRate))/inputRate)); }
};
private:
int fSamplingFreq;
float gain;
float fRec0[2];
float gain_out;
float fclip1;
float fclip2;
float fclip3;
float fclip4;
float fclips1;
float fclips2;
float fclips3;
float fclips4;
float fspeed1;
float fspeed2;
float fspeed3;
float fspeed4;
float rplay1;
float rplay2;
float rplay3;
float rplay4;
float od1;
float od2;
float od3;
float od4;
float fod1;
float fod2;
float fod3;
float fod4;
float record1;
int iVec0[2];
int IOTA1;
int IOTA2;
int IOTA3;
int IOTA4;
float IOTAR1;
float IOTAR2;
float IOTAR3;
float IOTAR4;
float *tape1;
int tape1_size;
float fConst0;
float fConst1;
float fConst2;
float reset1;
int RecSize1[2];
float rectime0;
float fRec1[2];
float fRec2[2];
int iRec3[2];
int iRec4[2];
float play1;
float playh1;
float gain1;
float record2;
int iVec2[2];
float *tape2;
int tape2_size;
float reset2;
int RecSize2[2];
float rectime1;
float fRec6[2];
float fRec7[2];
int iRec8[2];
int iRec9[2];
float play2;
float playh2;
float gain2;
float record3;
int iVec4[2];
float *tape3;
int tape3_size;
float reset3;
int RecSize3[2];
float rectime2;
float fRec11[2];
float fRec12[2];
int iRec13[2];
int iRec14[2];
float play3;
float playh3;
float gain3;
float record4;
int iVec6[2];
float *tape4;
int tape4_size;
float reset4;
int RecSize4[2];
float rectime3;
float fRec16[2];
float fRec17[2];
int iRec18[2];
int iRec19[2];
float play4;
float playh4;
float gain4;
float play_all;
float dout;
float* outbuffer;
bool save1;
bool save2;
bool save3;
bool save4;
bool first1;
bool first2;
bool first3;
bool first4;
bool RP1;
bool RP2;
bool RP3;
bool RP4;
Glib::ustring preset_name;
Glib::ustring load_file1;
Glib::ustring load_file2;
Glib::ustring load_file3;
Glib::ustring load_file4;
Glib::ustring cur_name;
Glib::ustring loop_dir;
bool save_p;
ParamMap& param;
bool mem_allocated;
sigc::slot<void> sync;
volatile int ready;
FileResampler smp;
Directout* d;
int do_resample(int inrate, int insize, float *input, int maxsize);
int do_mono(int c, int f, float *oIn, float *tape, int n);
void play_all_tapes();
void mem_alloc();
void mem_free();
void clear_state_f();
int activate(bool start);
int load_ui_f(const UiBuilder& b, int form);
void init(unsigned int samplingFreq);
void compute(int count, float *input0, float *output0);
int register_par(const ParamReg& reg);
void save_array(std::string name);
void load_array(std::string name);
void save_to_wave(std::string fname, float *tape, float fSize, int tape_size);
int load_from_wave(std::string fname, float **tape, int tape_size);
void set_p_state();
void load_tape1();
void load_tape2();
void load_tape3();
void load_tape4();
static void clear_state_f_static(PluginDef*);
static int activate_static(bool start, PluginDef*);
static int load_ui_f_static(const UiBuilder& b, int form);
static void init_static(unsigned int samplingFreq, PluginDef*);
static void compute_static(int count, float *input0, float *output0, PluginDef*);
static int register_params_static(const ParamReg& reg);
static void del_instance(PluginDef *p);
public:
Plugin plugin;
LiveLooper(ParamMap& param_, Directout* d, sigc::slot<void> sync, const string& loop_dir_);
~LiveLooper();
};
/****************************************************************
** class SCapture
*/
class SCapture: public PluginDef {
private:
SNDFILE * recfile;
EngineControl& engine;
int fSamplingFreq;
int channel;
float fcheckbox0;
float fcheckbox1;
float fslider0;
float fbargraph0;
float fRecC0[2];
float fformat;
int IOTA;
int iA;
int savesize;
int filesize;
float *fRec0;
float *fRec1;
float *tape;
sem_t m_trig;
pthread_t m_pthr;
volatile bool keep_stream;
bool mem_allocated;
bool is_wav;
bool err;
float fConst0;
float fRecb0[2];
int iRecb1[2];
float fRecb2[2];
void mem_alloc();
void mem_free();
void clear_state_f();
int activate(bool start);
int load_ui_f(const UiBuilder& b, int form);
void init(unsigned int samplingFreq);
void compute(int count, float *input0, float *output0);
void compute_st(int count, float *input0, float *input1, float *output0, float *output1);
int register_par(const ParamReg& reg);
void save_to_wave(SNDFILE * sf, float *tape, int lSize);
SNDFILE *open_stream(std::string fname);
void close_stream(SNDFILE **sf);
void stop_thread();
void start_thread();
void disc_stream();
inline std::string get_ffilename();
static void *run_thread(void* p);
static void clear_state_f_static(PluginDef*);
static int activate_static(bool start, PluginDef*);
static const char *glade_def;
static const char *glade_def_st;
static int load_ui_f_static(const UiBuilder& b, int form);
static void init_static(unsigned int samplingFreq, PluginDef*);
static void compute_static(int count, float *input0, float *output0, PluginDef*);
static void compute_static_st(int count, float *input0, float *input1, float *output0, float *output1, PluginDef*);
static int register_params_static(const ParamReg& reg);
static void del_instance(PluginDef *p);
public:
Plugin plugin;
SCapture(EngineControl& engine, int channel_);
~SCapture();
};
/****************************************************************
** class DrumSequencer
*/
#ifndef GUITARIX_AS_PLUGIN
#include "faust/drumseq.h"
#else
#include "drumseq.h"
#endif
class Drumout {
private:
static float* set;
static bool mb;
static float* data;
static Plugin input_drum;
static void outputdrum_compute(int count, float *input0, float *input1, float *output0, float *output1, PluginDef*);
public:
static void set_plugin(Plugin p);
static void set_data(float* mode, bool ready, float* buf);
static Plugin output_drum;
static PluginDef outputdrum;
Drumout();
};
class DrumSequencer: public PluginDef {
private:
int fSamplingFreq;
FAUSTFLOAT position;
FAUSTFLOAT ftact;
FAUSTFLOAT fsec;
FAUSTFLOAT fsliderbpm;
FAUSTFLOAT fsliderhum;
drumseq::Dsp drums;
int counter;
int seq_size;
int bsize;
FAUSTFLOAT step;
FAUSTFLOAT step_orig;
FAUSTFLOAT fSlow1;
FAUSTFLOAT fSlow3;
FAUSTFLOAT fSlow5;
FAUSTFLOAT fSlow7;
FAUSTFLOAT fSlow12;
FAUSTFLOAT fSlow14;
FAUSTFLOAT fSlow16;
FAUSTFLOAT fSlow18;
FAUSTFLOAT fSlow20;
FAUSTFLOAT fSlow22;
std::vector<int> Vectom;
std::vector<int> Vectom1;
std::vector<int> Vectom2;
std::vector<int> Veckick;
std::vector<int> Vecsnare;
std::vector<int> Vechat;
EngineControl& engine;
bool mem_allocated;
sigc::slot<void> sync;
volatile bool ready;
float *outdata;
GxSeqSettings tomset;
SeqParameter *tomp;
GxSeqSettings tomset1;
SeqParameter *tomp1;
GxSeqSettings tomset2;
SeqParameter *tomp2;
GxSeqSettings snareset;
SeqParameter *snarep;
GxSeqSettings hatset;
SeqParameter *hatp;
GxSeqSettings kickset;
SeqParameter *kickp;
void mem_alloc();
void mem_free();
void init(unsigned int samplingFreq);
void compute(int count, FAUSTFLOAT *input0, FAUSTFLOAT *output0);
void change_buffersize(unsigned int size);
int register_par(const ParamReg& reg);
int min_seq_size();
void reset_tom();
void reset_tom1();
void reset_tom2();
void reset_kick();
void reset_hat();
void reset_snare();
static void init_static(unsigned int samplingFreq, PluginDef*);
static void compute_static(int count, FAUSTFLOAT *input0, FAUSTFLOAT *output0, PluginDef*);
static int register_params_static(const ParamReg& reg);
static void del_instance(PluginDef *p);
static int drum_load_ui(const UiBuilder& builder, int format);
public:
Plugin plugin;
DrumSequencer(EngineControl& engine, sigc::slot<void> sync);
~DrumSequencer();
};
/****************************************************************************
*
* NAME: smbPitchShift.cpp
* VERSION: 1.2
* HOME URL: http://www.dspdimension.com
* KNOWN BUGS: none
*
*
* COPYRIGHT 1999-2009 Stephan M. Bernsee <smb [AT] dspdimension [DOT] com>
*
* Modified for guitarix by Hermann Meyer 2014
*
* The Wide Open License (WOL)
*
* Permission to use, copy, modify, distribute and sell this software and its
* documentation for any purpose is hereby granted without fee, provided that
* the above copyright notice and this license appear in all source copies.
* THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY OF
* ANY KIND. See http://www.dspguru.com/wol.htm for more information.
*
*****************************************************************************/
#define M_PI 3.14159265358979323846
#define MAX_FRAME_LENGTH 8096
class smbPitchShift : public PluginDef {
private:
gx_resample::SimpleResampler resamp;
EngineControl& engine;
bool mem_allocated;
sigc::slot<void> sync;
volatile bool ready;
float gInFIFO[MAX_FRAME_LENGTH];
float gOutFIFO[MAX_FRAME_LENGTH];
float *fpb;
float *expect;
float *hanning;
float *hanningd;
float *resampin;
float *resampin2;
float *resampout;
float *indata2;
float gLastPhase[MAX_FRAME_LENGTH/2+1];
float gSumPhase[MAX_FRAME_LENGTH/2+1];
float gOutputAccum[2*MAX_FRAME_LENGTH];
float gAnaFreq[MAX_FRAME_LENGTH];
float gAnaMagn[MAX_FRAME_LENGTH];
float gSynFreq[MAX_FRAME_LENGTH];
float gSynMagn[MAX_FRAME_LENGTH];
float semitones;
float a,b,c,d,l;
float wet;
float dry;
float mpi, mpi1;
float tone;
int octave, osamp, numSampsToResamp, numSampsToProcess, fftFrameSize, sampleRate ;
int latency;
int ai;
int aio;
int ii;
long gRover ;
double magn, phase, tmp, real, imag;
double freqPerBin, freqPerBin1, freqPerBin2, expct;
double fftFrameSize3;
double fftFrameSize4;
double osamp1,osamp2;
long i,k, qpd, index, inFifoLatency, stepSize, fftFrameSize2;
fftwf_complex fftw_in[MAX_FRAME_LENGTH], fftw_out[MAX_FRAME_LENGTH];
fftwf_plan ftPlanForward, ftPlanInverse;
inline int load_ui_f(const UiBuilder& b, int form);
int register_par(const ParamReg& reg);
void change_latency();
void mem_alloc();
void mem_free();
void clear_state();
int activate(bool start);
bool setParameters( int sampleRate);
void PitchShift(int count, float *indata, float *outdata);
void change_buffersize(unsigned int size);
static int activate_static(bool start, PluginDef*);
static void del_instance(PluginDef *p);
static int registerparam(const ParamReg& reg);
static int load_ui_f_static(const UiBuilder& b, int form);
static void init(unsigned int sampleRate, PluginDef *plugin);
static void compute_static(int count, float *input0, float *output0, PluginDef *p);
public:
Plugin plugin;
smbPitchShift(EngineControl& engine, sigc::slot<void> sync);
~smbPitchShift();
};
} // namespace gx_engine
gx_engine::BaseConvolver::activated
bool activated
Definition gx_internal_plugins.h:444
gx_engine::BaseConvolver::sync
sigc::slot< void > sync
Definition gx_internal_plugins.h:443
gx_engine::BaseConvolver::engine
EngineControl & engine
Definition gx_internal_plugins.h:442
gx_engine::BaseConvolver::plugin
Plugin plugin
Definition gx_internal_plugins.h:454
gx_engine::BaseConvolver::start
virtual bool start(bool force=false)=0
gx_engine::BaseConvolver::activate
static int activate(bool start, PluginDef *pdef)
gx_engine::BaseConvolver::set_sync
void set_sync(bool val)
Definition gx_internal_plugins.h:458
gx_engine::BaseConvolver::BaseConvolver
BaseConvolver(EngineControl &engine, sigc::slot< void > sync, gx_resample::BufferResampler &resamp)
gx_engine::BaseConvolver::check_update_timeout
bool check_update_timeout()
gx_engine::BaseConvolver::update_conn
sigc::connection update_conn
Definition gx_internal_plugins.h:445
gx_engine::BaseConvolver::check_update
virtual void check_update()=0
gx_engine::BaseConvolver::change_buffersize
void change_buffersize(unsigned int)
gx_engine::BaseConvolver::init
static void init(unsigned int samplingFreq, PluginDef *p)
gx_engine::BaseConvolver::conv_start
int conv_start()
gx_engine::BaseConvolver::activate_mutex
boost::mutex activate_mutex
Definition gx_internal_plugins.h:441
gx_engine::BaseConvolver::~BaseConvolver
virtual ~BaseConvolver()
gx_engine::BaseConvolver::conv
GxSimpleConvolver conv
Definition gx_internal_plugins.h:440
gx_engine::CabinetConvolver::bass
float bass
Definition gx_internal_plugins.h:508
gx_engine::CabinetConvolver::check_update
virtual void check_update() override
gx_engine::CabinetConvolver::update_cabinet
void update_cabinet()
Definition gx_internal_plugins.h:519
gx_engine::CabinetConvolver::impf
cabinet_impulse_former::Dsp impf
Definition gx_internal_plugins.h:511
gx_engine::CabinetConvolver::smp
gx_resample::FixedRateResampler smp
Definition gx_internal_plugins.h:512
gx_engine::CabinetConvolver::cab_names
value_pair * cab_names
Definition gx_internal_plugins.h:510
gx_engine::CabinetConvolver::level
float level
Definition gx_internal_plugins.h:506
gx_engine::CabinetConvolver::do_update
bool do_update()
gx_engine::CabinetConvolver::run_cab_conf
static void run_cab_conf(int count, float *input, float *output, PluginDef *)
gx_engine::CabinetConvolver::CabinetConvolver
CabinetConvolver(EngineControl &engine, sigc::slot< void > sync, gx_resample::BufferResampler &resamp)
gx_engine::CabinetConvolver::~CabinetConvolver
~CabinetConvolver()
gx_engine::CabinetConvolver::cabinet_changed
bool cabinet_changed()
Definition gx_internal_plugins.h:518
gx_engine::CabinetConvolver::cabinet
int cabinet
Definition gx_internal_plugins.h:507
gx_engine::CabinetConvolver::current_cab
int current_cab
Definition gx_internal_plugins.h:505
gx_engine::CabinetConvolver::register_cab
static int register_cab(const ParamReg &reg)
gx_engine::CabinetConvolver::start
virtual bool start(bool force=false) override
gx_engine::CabinetConvolver::treble
float treble
Definition gx_internal_plugins.h:509
gx_engine::CabinetStereoConvolver::level
float level
Definition gx_internal_plugins.h:538
gx_engine::CabinetStereoConvolver::start
virtual bool start(bool force=false) override
gx_engine::CabinetStereoConvolver::check_update
virtual void check_update() override
gx_engine::CabinetStereoConvolver::CabinetStereoConvolver
CabinetStereoConvolver(EngineControl &engine, sigc::slot< void > sync, gx_resample::BufferResampler &resamp)
gx_engine::CabinetStereoConvolver::cab_names
value_pair * cab_names
Definition gx_internal_plugins.h:542
gx_engine::CabinetStereoConvolver::current_cab
int current_cab
Definition gx_internal_plugins.h:537
gx_engine::CabinetStereoConvolver::bass
float bass
Definition gx_internal_plugins.h:540
gx_engine::CabinetStereoConvolver::smps
gx_resample::FixedRateResampler smps
Definition gx_internal_plugins.h:545
gx_engine::CabinetStereoConvolver::update_cabinet
void update_cabinet()
Definition gx_internal_plugins.h:552
gx_engine::CabinetStereoConvolver::run_cab_conf
static void run_cab_conf(int count, float *input, float *input1, float *output, float *output1, PluginDef *)
gx_engine::CabinetStereoConvolver::~CabinetStereoConvolver
~CabinetStereoConvolver()
gx_engine::CabinetStereoConvolver::do_update
bool do_update()
gx_engine::CabinetStereoConvolver::cabinet
int cabinet
Definition gx_internal_plugins.h:539
gx_engine::CabinetStereoConvolver::treble
float treble
Definition gx_internal_plugins.h:541
gx_engine::CabinetStereoConvolver::smp
gx_resample::FixedRateResampler smp
Definition gx_internal_plugins.h:544
gx_engine::CabinetStereoConvolver::cabinet_changed
bool cabinet_changed()
Definition gx_internal_plugins.h:551
gx_engine::CabinetStereoConvolver::impf
cabinet_impulse_former_st::Dsp impf
Definition gx_internal_plugins.h:543
gx_engine::CabinetStereoConvolver::register_cab
static int register_cab(const ParamReg &reg)
gx_engine::ContrastConvolver::~ContrastConvolver
~ContrastConvolver()
gx_engine::ContrastConvolver::register_con
static int register_con(const ParamReg &reg)
gx_engine::ContrastConvolver::smp
gx_resample::FixedRateResampler smp
Definition gx_internal_plugins.h:647
gx_engine::ContrastConvolver::sum
float sum
Definition gx_internal_plugins.h:645
gx_engine::ContrastConvolver::update_sum
void update_sum()
Definition gx_internal_plugins.h:650
gx_engine::ContrastConvolver::sum_changed
bool sum_changed()
Definition gx_internal_plugins.h:653
gx_engine::ContrastConvolver::run_contrast
static void run_contrast(int count, float *input, float *output, PluginDef *)
gx_engine::ContrastConvolver::do_update
bool do_update()
gx_engine::ContrastConvolver::start
virtual bool start(bool force=false) override
gx_engine::ContrastConvolver::ContrastConvolver
ContrastConvolver(EngineControl &engine, sigc::slot< void > sync, gx_resample::BufferResampler &resamp)
gx_engine::ContrastConvolver::check_update
virtual void check_update() override
gx_engine::ContrastConvolver::presl
presence_level::Dsp presl
Definition gx_internal_plugins.h:646
gx_engine::ContrastConvolver::level
float level
Definition gx_internal_plugins.h:644
gx_engine::ConvolverAdapter
Definition gx_internal_plugins.h:358
gx_engine::ConvolverAdapter::set_sync
void set_sync(bool val)
Definition gx_internal_plugins.h:377
gx_engine::ConvolverAdapter::plugin
Plugin plugin
Definition gx_internal_plugins.h:370
gx_engine::ConvolverAdapter::~ConvolverAdapter
~ConvolverAdapter()
gx_engine::ConvolverAdapter::jcp
JConvParameter * jcp
Definition gx_internal_plugins.h:368
gx_engine::ConvolverAdapter::activated
bool activated
Definition gx_internal_plugins.h:364
gx_engine::ConvolverAdapter::getIRFile
const std::string & getIRFile() const
Definition gx_internal_plugins.h:376
gx_engine::ConvolverAdapter::sync
sigc::slot< void > sync
Definition gx_internal_plugins.h:363
gx_engine::ConvolverAdapter::change_buffersize
void change_buffersize(unsigned int size)
gx_engine::ConvolverAdapter::activate_mutex
boost::mutex activate_mutex
Definition gx_internal_plugins.h:361
gx_engine::ConvolverAdapter::getIRDir
const std::string & getIRDir() const
Definition gx_internal_plugins.h:379
gx_engine::ConvolverAdapter::restart
void restart()
gx_engine::ConvolverAdapter::conv
GxConvolver conv
Definition gx_internal_plugins.h:360
gx_engine::ConvolverAdapter::get_parameter_map
ParamMap & get_parameter_map() const
Definition gx_internal_plugins.h:382
gx_engine::ConvolverAdapter::conv_start
bool conv_start()
gx_engine::ConvolverAdapter::jcset
GxJConvSettings jcset
Definition gx_internal_plugins.h:367
gx_engine::ConvolverAdapter::get_jcset
const GxJConvSettings & get_jcset() const
Definition gx_internal_plugins.h:381
gx_engine::ConvolverAdapter::getFullIRPath
std::string getFullIRPath() const
Definition gx_internal_plugins.h:378
gx_engine::ConvolverAdapter::engine
EngineControl & engine
Definition gx_internal_plugins.h:362
gx_engine::ConvolverAdapter::set
bool set(const GxJConvSettings &jcset) const
Definition gx_internal_plugins.h:380
gx_engine::ConvolverAdapter::ConvolverAdapter
ConvolverAdapter(EngineControl &engine, sigc::slot< void > sync)
gx_engine::ConvolverMonoAdapter::convolver_register
static int convolver_register(const ParamReg &reg)
gx_engine::ConvolverMonoAdapter::~ConvolverMonoAdapter
~ConvolverMonoAdapter()
gx_engine::ConvolverMonoAdapter::convolver
static void convolver(int count, float *input, float *output, PluginDef *)
gx_engine::ConvolverMonoAdapter::ConvolverMonoAdapter
ConvolverMonoAdapter(EngineControl &engine, sigc::slot< void > sync)
gx_engine::ConvolverMonoAdapter::convolver_init
static void convolver_init(unsigned int samplingFreq, PluginDef *pdef)
gx_engine::ConvolverMonoAdapter::activate
static int activate(bool start, PluginDef *pdef)
gx_engine::ConvolverMonoAdapter::jc_post_mono
jconv_post_mono::Dsp jc_post_mono
Definition gx_internal_plugins.h:420
gx_engine::ConvolverMonoAdapter::jconv_load_ui
static int jconv_load_ui(const UiBuilder &builder, int format)
gx_engine::ConvolverStereoAdapter::convolver
static void convolver(int count, float *input0, float *input1, float *output0, float *output1, PluginDef *)
gx_engine::ConvolverStereoAdapter::convolver_init
static void convolver_init(unsigned int samplingFreq, PluginDef *pdef)
gx_engine::ConvolverStereoAdapter::ConvolverStereoAdapter
ConvolverStereoAdapter(EngineControl &engine, sigc::slot< void > sync)
gx_engine::ConvolverStereoAdapter::activate
static int activate(bool start, PluginDef *pdef)
gx_engine::ConvolverStereoAdapter::jc_post
jconv_post::Dsp jc_post
Definition gx_internal_plugins.h:400
gx_engine::ConvolverStereoAdapter::~ConvolverStereoAdapter
~ConvolverStereoAdapter()
gx_engine::ConvolverStereoAdapter::convolver_register
static int convolver_register(const ParamReg &reg)
gx_engine::ConvolverStereoAdapter::jconv_load_ui
static int jconv_load_ui(const UiBuilder &builder, int format)
gx_engine::Directout
Definition gx_internal_plugins.h:796
gx_engine::Directout::get_buffer
float * get_buffer()
Definition gx_internal_plugins.h:815
gx_engine::Directout::fSamplingFreq
int fSamplingFreq
Definition gx_internal_plugins.h:800
gx_engine::Directout::compute_static
static void compute_static(int count, float *input0, float *input1, float *output0, float *output1, PluginDef *)
gx_engine::Directout::mem_alloc
void mem_alloc()
gx_engine::Directout::set_data
void set_data(bool dfill)
gx_engine::Directout::engine
EngineControl & engine
Definition gx_internal_plugins.h:803
gx_engine::Directout::init_static
static void init_static(unsigned int samplingFreq, PluginDef *)
gx_engine::Directout::Directout
Directout(EngineControl &engine, sigc::slot< void > sync)
gx_engine::Directout::outdata
float * outdata
Definition gx_internal_plugins.h:798
gx_engine::Directout::~Directout
~Directout()
gx_engine::Directout::bsize
int bsize
Definition gx_internal_plugins.h:801
gx_engine::Directout::mem_free
void mem_free()
gx_engine::Directout::change_buffersize
void change_buffersize(unsigned int size)
gx_engine::Directout::sync
sigc::slot< void > sync
Definition gx_internal_plugins.h:804
gx_engine::Directout::fdfill
bool fdfill
Definition gx_internal_plugins.h:802
gx_engine::Directout::compute
void compute(int count, float *input0, float *input1, float *output0, float *output1)
gx_engine::Directout::plugin
Plugin plugin
Definition gx_internal_plugins.h:817
gx_engine::Directout::init
void init(unsigned int samplingFreq)
gx_engine::Directout::mem_allocated
bool mem_allocated
Definition gx_internal_plugins.h:814
gx_engine::DrumSequencer::seq_size
int seq_size
Definition gx_internal_plugins.h:1107
gx_engine::DrumSequencer::step_orig
FAUSTFLOAT step_orig
Definition gx_internal_plugins.h:1110
gx_engine::DrumSequencer::compute
void compute(int count, FAUSTFLOAT *input0, FAUSTFLOAT *output0)
gx_engine::DrumSequencer::tomp1
SeqParameter * tomp1
Definition gx_internal_plugins.h:1136
gx_engine::DrumSequencer::counter
int counter
Definition gx_internal_plugins.h:1106
gx_engine::DrumSequencer::tomp2
SeqParameter * tomp2
Definition gx_internal_plugins.h:1138
gx_engine::DrumSequencer::fSlow12
FAUSTFLOAT fSlow12
Definition gx_internal_plugins.h:1115
gx_engine::DrumSequencer::outdata
float * outdata
Definition gx_internal_plugins.h:1132
gx_engine::DrumSequencer::~DrumSequencer
~DrumSequencer()
gx_engine::DrumSequencer::fSlow20
FAUSTFLOAT fSlow20
Definition gx_internal_plugins.h:1119
gx_engine::DrumSequencer::mem_alloc
void mem_alloc()
gx_engine::DrumSequencer::bsize
int bsize
Definition gx_internal_plugins.h:1108
gx_engine::DrumSequencer::tomp
SeqParameter * tomp
Definition gx_internal_plugins.h:1134
gx_engine::DrumSequencer::DrumSequencer
DrumSequencer(EngineControl &engine, sigc::slot< void > sync)
gx_engine::DrumSequencer::reset_tom1
void reset_tom1()
gx_engine::DrumSequencer::fSlow22
FAUSTFLOAT fSlow22
Definition gx_internal_plugins.h:1120
gx_engine::DrumSequencer::kickp
SeqParameter * kickp
Definition gx_internal_plugins.h:1144
gx_engine::DrumSequencer::reset_snare
void reset_snare()
gx_engine::DrumSequencer::position
FAUSTFLOAT position
Definition gx_internal_plugins.h:1099
gx_engine::DrumSequencer::fsec
FAUSTFLOAT fsec
Definition gx_internal_plugins.h:1101
gx_engine::DrumSequencer::kickset
GxSeqSettings kickset
Definition gx_internal_plugins.h:1143
gx_engine::DrumSequencer::step
FAUSTFLOAT step
Definition gx_internal_plugins.h:1109
gx_engine::DrumSequencer::min_seq_size
int min_seq_size()
gx_engine::DrumSequencer::reset_hat
void reset_hat()
gx_engine::DrumSequencer::Vecsnare
std::vector< int > Vecsnare
Definition gx_internal_plugins.h:1125
gx_engine::DrumSequencer::Vectom1
std::vector< int > Vectom1
Definition gx_internal_plugins.h:1122
gx_engine::DrumSequencer::init_static
static void init_static(unsigned int samplingFreq, PluginDef *)
gx_engine::DrumSequencer::fSlow14
FAUSTFLOAT fSlow14
Definition gx_internal_plugins.h:1116
gx_engine::DrumSequencer::change_buffersize
void change_buffersize(unsigned int size)
gx_engine::DrumSequencer::Vectom
std::vector< int > Vectom
Definition gx_internal_plugins.h:1121
gx_engine::DrumSequencer::init
void init(unsigned int samplingFreq)
gx_engine::DrumSequencer::tomset2
GxSeqSettings tomset2
Definition gx_internal_plugins.h:1137
gx_engine::DrumSequencer::plugin
Plugin plugin
Definition gx_internal_plugins.h:1167
gx_engine::DrumSequencer::fsliderhum
FAUSTFLOAT fsliderhum
Definition gx_internal_plugins.h:1103
gx_engine::DrumSequencer::drum_load_ui
static int drum_load_ui(const UiBuilder &builder, int format)
gx_engine::DrumSequencer::fSamplingFreq
int fSamplingFreq
Definition gx_internal_plugins.h:1098
gx_engine::DrumSequencer::fSlow5
FAUSTFLOAT fSlow5
Definition gx_internal_plugins.h:1113
gx_engine::DrumSequencer::hatp
SeqParameter * hatp
Definition gx_internal_plugins.h:1142
gx_engine::DrumSequencer::reset_tom
void reset_tom()
gx_engine::DrumSequencer::reset_kick
void reset_kick()
gx_engine::DrumSequencer::tomset1
GxSeqSettings tomset1
Definition gx_internal_plugins.h:1135
gx_engine::DrumSequencer::Vechat
std::vector< int > Vechat
Definition gx_internal_plugins.h:1126
gx_engine::DrumSequencer::del_instance
static void del_instance(PluginDef *p)
gx_engine::DrumSequencer::snareset
GxSeqSettings snareset
Definition gx_internal_plugins.h:1139
gx_engine::DrumSequencer::fSlow16
FAUSTFLOAT fSlow16
Definition gx_internal_plugins.h:1117
gx_engine::DrumSequencer::mem_allocated
bool mem_allocated
Definition gx_internal_plugins.h:1129
gx_engine::DrumSequencer::snarep
SeqParameter * snarep
Definition gx_internal_plugins.h:1140
gx_engine::DrumSequencer::drums
drumseq::Dsp drums
Definition gx_internal_plugins.h:1104
gx_engine::DrumSequencer::Veckick
std::vector< int > Veckick
Definition gx_internal_plugins.h:1124
gx_engine::DrumSequencer::ftact
FAUSTFLOAT ftact
Definition gx_internal_plugins.h:1100
gx_engine::DrumSequencer::hatset
GxSeqSettings hatset
Definition gx_internal_plugins.h:1141
gx_engine::DrumSequencer::tomset
GxSeqSettings tomset
Definition gx_internal_plugins.h:1133
gx_engine::DrumSequencer::fSlow1
FAUSTFLOAT fSlow1
Definition gx_internal_plugins.h:1111
gx_engine::DrumSequencer::compute_static
static void compute_static(int count, FAUSTFLOAT *input0, FAUSTFLOAT *output0, PluginDef *)
gx_engine::DrumSequencer::register_par
int register_par(const ParamReg &reg)
gx_engine::DrumSequencer::fSlow3
FAUSTFLOAT fSlow3
Definition gx_internal_plugins.h:1112
gx_engine::DrumSequencer::fSlow18
FAUSTFLOAT fSlow18
Definition gx_internal_plugins.h:1118
gx_engine::DrumSequencer::fSlow7
FAUSTFLOAT fSlow7
Definition gx_internal_plugins.h:1114
gx_engine::DrumSequencer::engine
EngineControl & engine
Definition gx_internal_plugins.h:1128
gx_engine::DrumSequencer::Vectom2
std::vector< int > Vectom2
Definition gx_internal_plugins.h:1123
gx_engine::DrumSequencer::reset_tom2
void reset_tom2()
gx_engine::DrumSequencer::sync
sigc::slot< void > sync
Definition gx_internal_plugins.h:1130
gx_engine::DrumSequencer::mem_free
void mem_free()
gx_engine::DrumSequencer::fsliderbpm
FAUSTFLOAT fsliderbpm
Definition gx_internal_plugins.h:1102
gx_engine::DrumSequencer::register_params_static
static int register_params_static(const ParamReg &reg)
gx_engine::DrumSequencer::ready
volatile bool ready
Definition gx_internal_plugins.h:1131
gx_engine::Drumout::Drumout
Drumout()
gx_engine::Drumout::output_drum
static Plugin output_drum
Definition gx_internal_plugins.h:1090
gx_engine::Drumout::set_plugin
static void set_plugin(Plugin p)
gx_engine::Drumout::set_data
static void set_data(float *mode, bool ready, float *buf)
gx_engine::Drumout::set
static float * set
Definition gx_internal_plugins.h:1082
gx_engine::Drumout::data
static float * data
Definition gx_internal_plugins.h:1084
gx_engine::Drumout::mb
static bool mb
Definition gx_internal_plugins.h:1083
gx_engine::Drumout::input_drum
static Plugin input_drum
Definition gx_internal_plugins.h:1085
gx_engine::Drumout::outputdrum_compute
static void outputdrum_compute(int count, float *input0, float *input1, float *output0, float *output1, PluginDef *)
gx_engine::Drumout::outputdrum
static PluginDef outputdrum
Definition gx_internal_plugins.h:1091
gx_engine::EngineControl
Definition gx_modulesequencer.h:245
gx_engine::FixedBaseConvolver::activate_mutex
boost::mutex activate_mutex
Definition gx_internal_plugins.h:469
gx_engine::FixedBaseConvolver::buffersize
unsigned int buffersize
Definition gx_internal_plugins.h:474
gx_engine::FixedBaseConvolver::check_update
virtual void check_update()=0
gx_engine::FixedBaseConvolver::check_update_timeout
bool check_update_timeout()
gx_engine::FixedBaseConvolver::sync
sigc::slot< void > sync
Definition gx_internal_plugins.h:471
gx_engine::FixedBaseConvolver::FixedBaseConvolver
FixedBaseConvolver(EngineControl &engine, sigc::slot< void > sync, gx_resample::BufferResampler &resamp)
gx_engine::FixedBaseConvolver::activated
bool activated
Definition gx_internal_plugins.h:472
gx_engine::FixedBaseConvolver::activate
static int activate(bool start, PluginDef *pdef)
gx_engine::FixedBaseConvolver::set_sync
void set_sync(bool val)
Definition gx_internal_plugins.h:490
gx_engine::FixedBaseConvolver::init
static void init(unsigned int samplingFreq, PluginDef *p)
gx_engine::FixedBaseConvolver::plugin
Plugin plugin
Definition gx_internal_plugins.h:486
gx_engine::FixedBaseConvolver::conv_start
int conv_start()
gx_engine::FixedBaseConvolver::bz
unsigned int bz
Definition gx_internal_plugins.h:475
gx_engine::FixedBaseConvolver::start
virtual bool start(bool force=false)=0
gx_engine::FixedBaseConvolver::change_buffersize
void change_buffersize(unsigned int)
gx_engine::FixedBaseConvolver::conv
GxSimpleConvolver conv
Definition gx_internal_plugins.h:468
gx_engine::FixedBaseConvolver::~FixedBaseConvolver
virtual ~FixedBaseConvolver()
gx_engine::FixedBaseConvolver::engine
EngineControl & engine
Definition gx_internal_plugins.h:470
gx_engine::FixedBaseConvolver::getSamplingFreq
unsigned int getSamplingFreq()
Definition gx_internal_plugins.h:478
gx_engine::FixedBaseConvolver::SamplingFreq
unsigned int SamplingFreq
Definition gx_internal_plugins.h:473
gx_engine::FixedBaseConvolver::update_conn
sigc::connection update_conn
Definition gx_internal_plugins.h:476
gx_engine::GxConvolver
Definition gx_convolver.h:127
gx_engine::GxJConvSettings
Definition gx_internal_plugins.h:279
gx_engine::GxJConvSettings::read_gainline
void read_gainline(gx_system::JsonParser &jp)
gx_engine::GxJConvSettings::setLength
void setLength(guint leng)
Definition gx_internal_plugins.h:314
gx_engine::GxJConvSettings::writeJSON
void writeJSON(gx_system::JsonWriter &w) const
gx_engine::GxJConvSettings::fDelay
guint fDelay
Definition gx_internal_plugins.h:288
gx_engine::GxJConvSettings::fIRFile
std::string fIRFile
Definition gx_internal_plugins.h:282
gx_engine::GxJConvSettings::setIRFile
void setIRFile(string name)
Definition gx_internal_plugins.h:310
gx_engine::GxJConvSettings::readJSON
void readJSON(gx_system::JsonParser &jp)
gx_engine::GxJConvSettings::fLength
guint fLength
Definition gx_internal_plugins.h:287
gx_engine::GxJConvSettings::fGain
float fGain
Definition gx_internal_plugins.h:285
gx_engine::GxJConvSettings::getGainline
const Gainline & getGainline() const
Definition gx_internal_plugins.h:307
gx_engine::GxJConvSettings::fGainCor
bool fGainCor
Definition gx_internal_plugins.h:290
gx_engine::GxJConvSettings::getFullIRPath
std::string getFullIRPath() const
gx_engine::GxJConvSettings::operator==
bool operator==(const GxJConvSettings &jcset) const
gx_engine::GxJConvSettings::fIRDir
std::string fIRDir
Definition gx_internal_plugins.h:283
gx_engine::GxJConvSettings::setDelay
void setDelay(guint del)
Definition gx_internal_plugins.h:315
gx_engine::GxJConvSettings::gainline
Gainline gainline
Definition gx_internal_plugins.h:289
gx_engine::GxJConvSettings::getOffset
guint getOffset() const
Definition gx_internal_plugins.h:303
gx_engine::GxJConvSettings::getLength
guint getLength() const
Definition gx_internal_plugins.h:304
gx_engine::GxJConvSettings::GxJConvSettings
GxJConvSettings()
gx_engine::GxJConvSettings::setFullIRPath
void setFullIRPath(string name)
gx_engine::GxJConvSettings::setOffset
void setOffset(guint offs)
Definition gx_internal_plugins.h:313
gx_engine::GxJConvSettings::setGainCor
void setGainCor(bool gain)
Definition gx_internal_plugins.h:312
gx_engine::GxJConvSettings::setGain
void setGain(float gain)
Definition gx_internal_plugins.h:311
gx_engine::GxJConvSettings::ConvolverAdapter
friend class ConvolverAdapter
Definition gx_internal_plugins.h:293
gx_engine::GxJConvSettings::getGainCor
bool getGainCor() const
Definition gx_internal_plugins.h:306
gx_engine::GxJConvSettings::getIRFile
const std::string & getIRFile() const
Definition gx_internal_plugins.h:300
gx_engine::GxJConvSettings::operator=
GxJConvSettings & operator=(GxJConvSettings const &jcset)
gx_engine::GxJConvSettings::fOffset
guint fOffset
Definition gx_internal_plugins.h:286
gx_engine::GxJConvSettings::getIRDir
const std::string & getIRDir() const
Definition gx_internal_plugins.h:308
gx_engine::GxJConvSettings::setGainline
void setGainline(const Gainline &gain)
Definition gx_internal_plugins.h:316
gx_engine::GxJConvSettings::getGain
float getGain() const
Definition gx_internal_plugins.h:302
gx_engine::GxJConvSettings::setIRDir
void setIRDir(string name)
Definition gx_internal_plugins.h:292
gx_engine::GxJConvSettings::getDelay
guint getDelay() const
Definition gx_internal_plugins.h:305
gx_engine::GxSeqSettings
Definition gx_internal_plugins.h:226
gx_engine::GxSeqSettings::writeJSON
void writeJSON(gx_system::JsonWriter &w) const
gx_engine::GxSeqSettings::operator==
bool operator==(const GxSeqSettings &seqset) const
gx_engine::GxSeqSettings::operator=
GxSeqSettings & operator=(GxSeqSettings const &seqset)
gx_engine::GxSeqSettings::seqline
std::vector< int > seqline
Definition gx_internal_plugins.h:229
gx_engine::GxSeqSettings::getseqline
const std::vector< int > & getseqline() const
Definition gx_internal_plugins.h:238
gx_engine::GxSeqSettings::read_seqline
void read_seqline(gx_system::JsonParser &jp)
gx_engine::GxSeqSettings::readJSON
void readJSON(gx_system::JsonParser &jp)
gx_engine::GxSeqSettings::GxSeqSettings
GxSeqSettings()
gx_engine::GxSeqSettings::SequencerAdapter
friend class SequencerAdapter
Definition gx_internal_plugins.h:231
gx_engine::GxSeqSettings::setseqline
void setseqline(const std::vector< int > &seq)
Definition gx_internal_plugins.h:240
gx_engine::GxSimpleConvolver
Definition gx_convolver.h:157
gx_engine::LV2Features::LV2Features
LV2Features(LV2Features const &)=delete
gx_engine::LV2Features::gx_options
static LV2_Options_Option gx_options[2]
Definition gx_internal_plugins.h:671
gx_engine::LV2Features::getInstance
static LV2Features & getInstance()
Definition gx_internal_plugins.h:689
gx_engine::LV2Features::lv2_urid_unmap
static const char * lv2_urid_unmap(LV2_URID_Unmap_Handle, const LV2_URID urid)
gx_engine::LV2Features::operator=
void operator=(LV2Features const &)=delete
gx_engine::LV2Features::lv2_uri_to_id
static uint32_t lv2_uri_to_id(LV2_URI_Map_Callback_Data handle, const char *, const char *uri)
gx_engine::LV2Features::gx_options_feature
static LV2_Feature gx_options_feature
Definition gx_internal_plugins.h:672
gx_engine::LV2Features::gx_urid_map_feature
static LV2_Feature gx_urid_map_feature
Definition gx_internal_plugins.h:675
gx_engine::LV2Features::gx_urid_map
static LV2_URID_Map gx_urid_map
Definition gx_internal_plugins.h:695
gx_engine::LV2Features::gx_uri_map_feature
static LV2_Feature gx_uri_map_feature
Definition gx_internal_plugins.h:681
gx_engine::LV2Features::gx_urid_unmap_feature
static LV2_Feature gx_urid_unmap_feature
Definition gx_internal_plugins.h:685
gx_engine::LV2Features::gx_urid_unmap
static LV2_URID_Unmap gx_urid_unmap
Definition gx_internal_plugins.h:696
gx_engine::LV2Features::lv2_urid_map
static LV2_URID lv2_urid_map(LV2_URID_Map_Handle, const char *const uri_)
gx_engine::LV2Features::gx_features
static LV2_Feature * gx_features[]
Definition gx_internal_plugins.h:694
gx_engine::LV2Features::gx_uri_map
static LV2_URI_Map_Feature gx_uri_map
Definition gx_internal_plugins.h:680
gx_engine::LV2Features::LV2Features
LV2Features()
Definition gx_internal_plugins.h:686
gx_engine::LadspaLoader::update_instance
void update_instance(PluginDef *pdef, plugdesc *pdesc)
gx_engine::LadspaLoader::begin
pluginarray::iterator begin()
Definition gx_internal_plugins.h:777
gx_engine::LadspaLoader::get_ladspa_filename
static std::string get_ladspa_filename(unsigned long uid)
Definition gx_internal_plugins.h:783
gx_engine::LadspaLoader::Lv2Dsp
friend class Lv2Dsp
Definition gx_internal_plugins.h:788
gx_engine::LadspaLoader::lv2_AudioPort
LilvNode * lv2_AudioPort
Definition gx_internal_plugins.h:762
gx_engine::LadspaLoader::end
pluginarray::iterator end()
Definition gx_internal_plugins.h:778
gx_engine::LadspaLoader::param
ParamMap & param
Definition gx_internal_plugins.h:760
gx_engine::LadspaLoader::read_module_list
void read_module_list(pluginarray &p)
gx_engine::LadspaLoader::lv2_plugins
const LilvPlugins * lv2_plugins
Definition gx_internal_plugins.h:761
gx_engine::LadspaLoader::set_plugins
void set_plugins(pluginarray &new_plugins)
gx_engine::LadspaLoader::~LadspaLoader
~LadspaLoader()
gx_engine::LadspaLoader::load
bool load(pluginarray &p)
gx_engine::LadspaLoader::get_ladspa_filename
static std::string get_ladspa_filename(std::string uid_key)
Definition gx_internal_plugins.h:785
gx_engine::LadspaLoader::LadspaLoader
LadspaLoader(const gx_system::CmdlineOptions &options, ParamMap &param)
gx_engine::LadspaLoader::lv2_ControlPort
LilvNode * lv2_ControlPort
Definition gx_internal_plugins.h:763
gx_engine::LadspaLoader::size
unsigned int size()
Definition gx_internal_plugins.h:774
gx_engine::LadspaLoader::clear_list
void clear_list()
gx_engine::LadspaLoader::get_parameter_map
ParamMap & get_parameter_map() const
Definition gx_internal_plugins.h:787
gx_engine::LadspaLoader::plugins
pluginarray plugins
Definition gx_internal_plugins.h:758
gx_engine::LadspaLoader::options
const gx_system::CmdlineOptions & options
Definition gx_internal_plugins.h:757
gx_engine::LadspaLoader::pluginarray
std::vector< plugdesc * > pluginarray
Definition gx_internal_plugins.h:755
gx_engine::LadspaLoader::world
LilvWorld * world
Definition gx_internal_plugins.h:759
gx_engine::LadspaLoader::lv2_InputPort
LilvNode * lv2_InputPort
Definition gx_internal_plugins.h:764
gx_engine::LadspaLoader::create
PluginDef * create(const plugdesc *p)
gx_engine::LadspaLoader::lv2_OutputPort
LilvNode * lv2_OutputPort
Definition gx_internal_plugins.h:765
gx_engine::LadspaLoader::read_module_config
void read_module_config(const std::string &filename, plugdesc *p)
gx_engine::LadspaLoader::create
PluginDef * create(unsigned int idx)
Definition gx_internal_plugins.h:775
gx_engine::LadspaLoader::lv2_AtomPort
LilvNode * lv2_AtomPort
Definition gx_internal_plugins.h:766
gx_engine::LadspaLoader::find
pluginarray::iterator find(plugdesc *desc)
gx_engine::LiveLooper::FileResampler
Definition gx_internal_plugins.h:830
gx_engine::LiveLooper::FileResampler::setup
int setup(int _inputRate, int _outputRate)
gx_engine::LiveLooper::FileResampler::run
int run(int count, float *input, float *output)
gx_engine::LiveLooper::FileResampler::r_file
Resampler r_file
Definition gx_internal_plugins.h:832
gx_engine::LiveLooper::FileResampler::inputRate
int inputRate
Definition gx_internal_plugins.h:833
gx_engine::LiveLooper::FileResampler::outputRate
int outputRate
Definition gx_internal_plugins.h:833
gx_engine::LiveLooper::FileResampler::max_out_count
int max_out_count(int in_count)
Definition gx_internal_plugins.h:837
gx_engine::LiveLooper::save_to_wave
void save_to_wave(std::string fname, float *tape, float fSize, int tape_size)
gx_engine::LiveLooper::rplay3
float rplay3
Definition gx_internal_plugins.h:860
gx_engine::LiveLooper::RecSize1
int RecSize1[2]
Definition gx_internal_plugins.h:886
gx_engine::LiveLooper::fConst1
float fConst1
Definition gx_internal_plugins.h:883
gx_engine::LiveLooper::gain3
float gain3
Definition gx_internal_plugins.h:922
gx_engine::LiveLooper::reset2
float reset2
Definition gx_internal_plugins.h:899
gx_engine::LiveLooper::load_file1
Glib::ustring load_file1
Definition gx_internal_plugins.h:953
gx_engine::LiveLooper::fclip4
float fclip4
Definition gx_internal_plugins.h:849
gx_engine::LiveLooper::del_instance
static void del_instance(PluginDef *p)
gx_engine::LiveLooper::iVec0
int iVec0[2]
Definition gx_internal_plugins.h:871
gx_engine::LiveLooper::tape3_size
int tape3_size
Definition gx_internal_plugins.h:912
gx_engine::LiveLooper::fRec2
float fRec2[2]
Definition gx_internal_plugins.h:889
gx_engine::LiveLooper::tape1_size
int tape1_size
Definition gx_internal_plugins.h:881
gx_engine::LiveLooper::iRec19
int iRec19[2]
Definition gx_internal_plugins.h:933
gx_engine::LiveLooper::play3
float play3
Definition gx_internal_plugins.h:920
gx_engine::LiveLooper::gain2
float gain2
Definition gx_internal_plugins.h:908
gx_engine::LiveLooper::rectime0
float rectime0
Definition gx_internal_plugins.h:887
gx_engine::LiveLooper::smp
FileResampler smp
Definition gx_internal_plugins.h:964
gx_engine::LiveLooper::fclips3
float fclips3
Definition gx_internal_plugins.h:852
gx_engine::LiveLooper::d
Directout * d
Definition gx_internal_plugins.h:965
gx_engine::LiveLooper::fRec11
float fRec11[2]
Definition gx_internal_plugins.h:916
gx_engine::LiveLooper::save3
bool save3
Definition gx_internal_plugins.h:942
gx_engine::LiveLooper::record4
float record4
Definition gx_internal_plugins.h:923
gx_engine::LiveLooper::IOTA3
int IOTA3
Definition gx_internal_plugins.h:874
gx_engine::LiveLooper::do_mono
int do_mono(int c, int f, float *oIn, float *tape, int n)
gx_engine::LiveLooper::rectime2
float rectime2
Definition gx_internal_plugins.h:915
gx_engine::LiveLooper::iVec6
int iVec6[2]
Definition gx_internal_plugins.h:924
gx_engine::LiveLooper::iRec4
int iRec4[2]
Definition gx_internal_plugins.h:891
gx_engine::LiveLooper::fspeed4
float fspeed4
Definition gx_internal_plugins.h:857
gx_engine::LiveLooper::fod4
float fod4
Definition gx_internal_plugins.h:869
gx_engine::LiveLooper::iVec2
int iVec2[2]
Definition gx_internal_plugins.h:896
gx_engine::LiveLooper::clear_state_f
void clear_state_f()
gx_engine::LiveLooper::tape2
float * tape2
Definition gx_internal_plugins.h:897
gx_engine::LiveLooper::record3
float record3
Definition gx_internal_plugins.h:909
gx_engine::LiveLooper::sync
sigc::slot< void > sync
Definition gx_internal_plugins.h:962
gx_engine::LiveLooper::RecSize3
int RecSize3[2]
Definition gx_internal_plugins.h:914
gx_engine::LiveLooper::~LiveLooper
~LiveLooper()
gx_engine::LiveLooper::playh1
float playh1
Definition gx_internal_plugins.h:893
gx_engine::LiveLooper::fspeed1
float fspeed1
Definition gx_internal_plugins.h:854
gx_engine::LiveLooper::od2
float od2
Definition gx_internal_plugins.h:863
gx_engine::LiveLooper::LiveLooper
LiveLooper(ParamMap &param_, Directout *d, sigc::slot< void > sync, const string &loop_dir_)
gx_engine::LiveLooper::play4
float play4
Definition gx_internal_plugins.h:934
gx_engine::LiveLooper::save2
bool save2
Definition gx_internal_plugins.h:941
gx_engine::LiveLooper::record1
float record1
Definition gx_internal_plugins.h:870
gx_engine::LiveLooper::preset_name
Glib::ustring preset_name
Definition gx_internal_plugins.h:952
gx_engine::LiveLooper::load_tape4
void load_tape4()
gx_engine::LiveLooper::ready
volatile int ready
Definition gx_internal_plugins.h:963
gx_engine::LiveLooper::first1
bool first1
Definition gx_internal_plugins.h:944
gx_engine::LiveLooper::load_file4
Glib::ustring load_file4
Definition gx_internal_plugins.h:956
gx_engine::LiveLooper::tape4_size
int tape4_size
Definition gx_internal_plugins.h:926
gx_engine::LiveLooper::register_par
int register_par(const ParamReg &reg)
gx_engine::LiveLooper::save1
bool save1
Definition gx_internal_plugins.h:940
gx_engine::LiveLooper::fspeed2
float fspeed2
Definition gx_internal_plugins.h:855
gx_engine::LiveLooper::outbuffer
float * outbuffer
Definition gx_internal_plugins.h:939
gx_engine::LiveLooper::iRec8
int iRec8[2]
Definition gx_internal_plugins.h:904
gx_engine::LiveLooper::fRec12
float fRec12[2]
Definition gx_internal_plugins.h:917
gx_engine::LiveLooper::iRec13
int iRec13[2]
Definition gx_internal_plugins.h:918
gx_engine::LiveLooper::init
void init(unsigned int samplingFreq)
gx_engine::LiveLooper::fConst0
float fConst0
Definition gx_internal_plugins.h:882
gx_engine::LiveLooper::gain4
float gain4
Definition gx_internal_plugins.h:936
gx_engine::LiveLooper::loop_dir
Glib::ustring loop_dir
Definition gx_internal_plugins.h:958
gx_engine::LiveLooper::gain_out
float gain_out
Definition gx_internal_plugins.h:845
gx_engine::LiveLooper::dout
float dout
Definition gx_internal_plugins.h:938
gx_engine::LiveLooper::first2
bool first2
Definition gx_internal_plugins.h:945
gx_engine::LiveLooper::gain1
float gain1
Definition gx_internal_plugins.h:894
gx_engine::LiveLooper::RP2
bool RP2
Definition gx_internal_plugins.h:949
gx_engine::LiveLooper::reset1
float reset1
Definition gx_internal_plugins.h:885
gx_engine::LiveLooper::load_from_wave
int load_from_wave(std::string fname, float **tape, int tape_size)
gx_engine::LiveLooper::tape2_size
int tape2_size
Definition gx_internal_plugins.h:898
gx_engine::LiveLooper::play2
float play2
Definition gx_internal_plugins.h:906
gx_engine::LiveLooper::mem_allocated
bool mem_allocated
Definition gx_internal_plugins.h:961
gx_engine::LiveLooper::fclips4
float fclips4
Definition gx_internal_plugins.h:853
gx_engine::LiveLooper::fclip3
float fclip3
Definition gx_internal_plugins.h:848
gx_engine::LiveLooper::iRec14
int iRec14[2]
Definition gx_internal_plugins.h:919
gx_engine::LiveLooper::fclips1
float fclips1
Definition gx_internal_plugins.h:850
gx_engine::LiveLooper::load_file2
Glib::ustring load_file2
Definition gx_internal_plugins.h:954
gx_engine::LiveLooper::save_p
bool save_p
Definition gx_internal_plugins.h:959
gx_engine::LiveLooper::activate_static
static int activate_static(bool start, PluginDef *)
gx_engine::LiveLooper::do_resample
int do_resample(int inrate, int insize, float *input, int maxsize)
gx_engine::LiveLooper::fSamplingFreq
int fSamplingFreq
Definition gx_internal_plugins.h:842
gx_engine::LiveLooper::play_all
float play_all
Definition gx_internal_plugins.h:937
gx_engine::LiveLooper::compute_static
static void compute_static(int count, float *input0, float *output0, PluginDef *)
gx_engine::LiveLooper::IOTAR2
float IOTAR2
Definition gx_internal_plugins.h:877
gx_engine::LiveLooper::record2
float record2
Definition gx_internal_plugins.h:895
gx_engine::LiveLooper::IOTAR3
float IOTAR3
Definition gx_internal_plugins.h:878
gx_engine::LiveLooper::gain
float gain
Definition gx_internal_plugins.h:843
gx_engine::LiveLooper::save_array
void save_array(std::string name)
gx_engine::LiveLooper::fRec17
float fRec17[2]
Definition gx_internal_plugins.h:931
gx_engine::LiveLooper::init_static
static void init_static(unsigned int samplingFreq, PluginDef *)
gx_engine::LiveLooper::IOTA2
int IOTA2
Definition gx_internal_plugins.h:873
gx_engine::LiveLooper::RecSize4
int RecSize4[2]
Definition gx_internal_plugins.h:928
gx_engine::LiveLooper::fRec1
float fRec1[2]
Definition gx_internal_plugins.h:888
gx_engine::LiveLooper::clear_state_f_static
static void clear_state_f_static(PluginDef *)
gx_engine::LiveLooper::play_all_tapes
void play_all_tapes()
gx_engine::LiveLooper::RP4
bool RP4
Definition gx_internal_plugins.h:951
gx_engine::LiveLooper::fRec7
float fRec7[2]
Definition gx_internal_plugins.h:903
gx_engine::LiveLooper::first3
bool first3
Definition gx_internal_plugins.h:946
gx_engine::LiveLooper::cur_name
Glib::ustring cur_name
Definition gx_internal_plugins.h:957
gx_engine::LiveLooper::fclips2
float fclips2
Definition gx_internal_plugins.h:851
gx_engine::LiveLooper::load_ui_f
int load_ui_f(const UiBuilder &b, int form)
gx_engine::LiveLooper::load_tape3
void load_tape3()
gx_engine::LiveLooper::iVec4
int iVec4[2]
Definition gx_internal_plugins.h:910
gx_engine::LiveLooper::play1
float play1
Definition gx_internal_plugins.h:892
gx_engine::LiveLooper::load_array
void load_array(std::string name)
gx_engine::LiveLooper::fod1
float fod1
Definition gx_internal_plugins.h:866
gx_engine::LiveLooper::fRec6
float fRec6[2]
Definition gx_internal_plugins.h:902
gx_engine::LiveLooper::fConst2
float fConst2
Definition gx_internal_plugins.h:884
gx_engine::LiveLooper::playh4
float playh4
Definition gx_internal_plugins.h:935
gx_engine::LiveLooper::fod2
float fod2
Definition gx_internal_plugins.h:867
gx_engine::LiveLooper::rplay4
float rplay4
Definition gx_internal_plugins.h:861
gx_engine::LiveLooper::od3
float od3
Definition gx_internal_plugins.h:864
gx_engine::LiveLooper::save4
bool save4
Definition gx_internal_plugins.h:943
gx_engine::LiveLooper::iRec3
int iRec3[2]
Definition gx_internal_plugins.h:890
gx_engine::LiveLooper::compute
void compute(int count, float *input0, float *output0)
gx_engine::LiveLooper::playh2
float playh2
Definition gx_internal_plugins.h:907
gx_engine::LiveLooper::register_params_static
static int register_params_static(const ParamReg &reg)
gx_engine::LiveLooper::RecSize2
int RecSize2[2]
Definition gx_internal_plugins.h:900
gx_engine::LiveLooper::RP3
bool RP3
Definition gx_internal_plugins.h:950
gx_engine::LiveLooper::fspeed3
float fspeed3
Definition gx_internal_plugins.h:856
gx_engine::LiveLooper::rplay2
float rplay2
Definition gx_internal_plugins.h:859
gx_engine::LiveLooper::load_tape2
void load_tape2()
gx_engine::LiveLooper::rplay1
float rplay1
Definition gx_internal_plugins.h:858
gx_engine::LiveLooper::iRec18
int iRec18[2]
Definition gx_internal_plugins.h:932
gx_engine::LiveLooper::od4
float od4
Definition gx_internal_plugins.h:865
gx_engine::LiveLooper::tape4
float * tape4
Definition gx_internal_plugins.h:925
gx_engine::LiveLooper::fRec16
float fRec16[2]
Definition gx_internal_plugins.h:930
gx_engine::LiveLooper::fod3
float fod3
Definition gx_internal_plugins.h:868
gx_engine::LiveLooper::tape3
float * tape3
Definition gx_internal_plugins.h:911
gx_engine::LiveLooper::reset4
float reset4
Definition gx_internal_plugins.h:927
gx_engine::LiveLooper::set_p_state
void set_p_state()
gx_engine::LiveLooper::plugin
Plugin plugin
Definition gx_internal_plugins.h:996
gx_engine::LiveLooper::first4
bool first4
Definition gx_internal_plugins.h:947
gx_engine::LiveLooper::mem_alloc
void mem_alloc()
gx_engine::LiveLooper::IOTAR1
float IOTAR1
Definition gx_internal_plugins.h:876
gx_engine::LiveLooper::playh3
float playh3
Definition gx_internal_plugins.h:921
gx_engine::LiveLooper::load_tape1
void load_tape1()
gx_engine::LiveLooper::rectime3
float rectime3
Definition gx_internal_plugins.h:929
gx_engine::LiveLooper::fRec0
float fRec0[2]
Definition gx_internal_plugins.h:844
gx_engine::LiveLooper::fclip2
float fclip2
Definition gx_internal_plugins.h:847
gx_engine::LiveLooper::IOTA4
int IOTA4
Definition gx_internal_plugins.h:875
gx_engine::LiveLooper::RP1
bool RP1
Definition gx_internal_plugins.h:948
gx_engine::LiveLooper::fclip1
float fclip1
Definition gx_internal_plugins.h:846
gx_engine::LiveLooper::mem_free
void mem_free()
gx_engine::LiveLooper::rectime1
float rectime1
Definition gx_internal_plugins.h:901
gx_engine::LiveLooper::IOTAR4
float IOTAR4
Definition gx_internal_plugins.h:879
gx_engine::LiveLooper::IOTA1
int IOTA1
Definition gx_internal_plugins.h:872
gx_engine::LiveLooper::activate
int activate(bool start)
gx_engine::LiveLooper::load_file3
Glib::ustring load_file3
Definition gx_internal_plugins.h:955
gx_engine::LiveLooper::load_ui_f_static
static int load_ui_f_static(const UiBuilder &b, int form)
gx_engine::LiveLooper::tape1
float * tape1
Definition gx_internal_plugins.h:880
gx_engine::LiveLooper::iRec9
int iRec9[2]
Definition gx_internal_plugins.h:905
gx_engine::LiveLooper::param
ParamMap & param
Definition gx_internal_plugins.h:960
gx_engine::LiveLooper::od1
float od1
Definition gx_internal_plugins.h:862
gx_engine::LiveLooper::reset3
float reset3
Definition gx_internal_plugins.h:913
gx_engine::MaxLevel::channelcount
static const unsigned int channelcount
Definition gx_internal_plugins.h:52
gx_engine::MaxLevel::get
static float get(unsigned int channel)
Definition gx_internal_plugins.h:60
gx_engine::MaxLevel::MaxLevel
MaxLevel()
gx_engine::MaxLevel::process
static void process(int count, float *input0, float *input1, float *output0, float *output1, PluginDef *)
gx_engine::MaxLevel::regparam
static int regparam(const ParamReg &reg)
gx_engine::MaxLevel::activate
static int activate(bool start, PluginDef *plugin)
gx_engine::MaxLevel::maxlevel
static float maxlevel[channelcount]
Definition gx_internal_plugins.h:54
gx_engine::ModuleSelector::ModuleSelector
ModuleSelector(EngineControl &seq_)
Definition gx_modulesequencer.h:33
gx_engine::ModuleSequencer
Definition gx_modulesequencer.h:308
gx_engine::MonoMute::process
static void process(int count, float *input, float *output, PluginDef *)
gx_engine::MonoMute::MonoMute
MonoMute()
gx_engine::NoiseGate
Definition gx_internal_plugins.h:113
gx_engine::NoiseGate::inputlevel_process
void inputlevel_process(int count, float *input0, float *output0)
gx_engine::NoiseGate::ngate
float ngate
Definition gx_internal_plugins.h:124
gx_engine::NoiseGate::inputlevel_compute
static void inputlevel_compute(int count, float *input0, float *output0, PluginDef *)
gx_engine::NoiseGate::inputdef
PluginDef inputdef
Definition gx_internal_plugins.h:125
gx_engine::NoiseGate::NoiseGate
NoiseGate()
gx_engine::NoiseGate::noisegate_start
int noisegate_start(bool start)
gx_engine::NoiseGate::fnglevel
float fnglevel
Definition gx_internal_plugins.h:123
gx_engine::NoiseGate::off
bool off
Definition gx_internal_plugins.h:122
gx_engine::NoiseGate::noisegate_register
int noisegate_register(const ParamReg &reg)
gx_engine::NoiseGate::inputlevel
Plugin inputlevel
Definition gx_internal_plugins.h:126
gx_engine::NoiseGate::noisegate_activate
static int noisegate_activate(bool start, PluginDef *pdef)
gx_engine::NoiseGate::noisegate_params_static
static int noisegate_params_static(const ParamReg &reg)
gx_engine::OscilloscopeAdapter::set_jack
void set_jack(gx_jack::GxJack &jack)
Definition gx_internal_plugins.h:218
gx_engine::OscilloscopeAdapter::pmap
ParamMap & pmap
Definition gx_internal_plugins.h:204
gx_engine::OscilloscopeAdapter::osc_register
static int osc_register(const ParamReg &reg)
gx_engine::OscilloscopeAdapter::OscilloscopeAdapter
OscilloscopeAdapter(ModuleSequencer &engine)
gx_engine::OscilloscopeAdapter::get_buffer
float * get_buffer() const
Definition gx_internal_plugins.h:214
gx_engine::OscilloscopeAdapter::set_mul_buffer
void set_mul_buffer(int a, unsigned int b)
Definition gx_internal_plugins.h:216
gx_engine::OscilloscopeAdapter::osc_load_ui
static int osc_load_ui(const UiBuilder &builder, int format)
gx_engine::OscilloscopeAdapter::clear_buffer
void clear_buffer()
gx_engine::OscilloscopeAdapter::change_buffersize
void change_buffersize(unsigned int)
gx_engine::OscilloscopeAdapter::fill_buffer
static void fill_buffer(int count, float *input0, float *output0, PluginDef *)
gx_engine::OscilloscopeAdapter::get_mul_buffer
int get_mul_buffer()
Definition gx_internal_plugins.h:215
gx_engine::OscilloscopeAdapter::plugin
Plugin plugin
Definition gx_internal_plugins.h:211
gx_engine::OscilloscopeAdapter::mul_buffer
int mul_buffer
Definition gx_internal_plugins.h:209
gx_engine::OscilloscopeAdapter::get_size
unsigned int get_size() const
Definition gx_internal_plugins.h:213
gx_engine::OscilloscopeAdapter::info
OscilloscopeInfo info
Definition gx_internal_plugins.h:202
gx_engine::OscilloscopeInfo
Definition gx_internal_plugins.h:149
gx_engine::OscilloscopeInfo::load
int load
Definition gx_internal_plugins.h:157
gx_engine::OscilloscopeInfo::frames
int frames
Definition gx_internal_plugins.h:158
gx_engine::OscilloscopeInfo::signal_size_change
sigc::signal< void(unsigned int, float *)> signal_size_change()
Definition gx_internal_plugins.h:171
gx_engine::OscilloscopeInfo::writeJSON
void writeJSON(gx_system::JsonWriter &w) const
gx_engine::OscilloscopeInfo::get_buffer_size
unsigned int get_buffer_size() const
Definition gx_internal_plugins.h:170
gx_engine::OscilloscopeInfo::update
void update()
gx_engine::OscilloscopeInfo::is_rt
bool is_rt
Definition gx_internal_plugins.h:159
gx_engine::OscilloscopeInfo::size_change
sigc::signal< void(unsigned int, float *)> size_change
Definition gx_internal_plugins.h:152
gx_engine::OscilloscopeInfo::bsize
jack_nframes_t bsize
Definition gx_internal_plugins.h:160
gx_engine::OscilloscopeInfo::jack
gx_jack::GxJack * jack
Definition gx_internal_plugins.h:151
gx_engine::OscilloscopeInfo::get_buffer
float * get_buffer() const
Definition gx_internal_plugins.h:169
gx_engine::OscilloscopeInfo::readJSON
void readJSON(gx_system::JsonParser &jp)
gx_engine::OscilloscopeInfo::OscilloscopeInfo
OscilloscopeInfo()
Definition gx_internal_plugins.h:163
gx_engine::OscilloscopeInfo::buffer
float * buffer
Definition gx_internal_plugins.h:153
gx_engine::OscilloscopeInfo::OscilloscopeAdapter
friend class OscilloscopeAdapter
Definition gx_internal_plugins.h:155
gx_engine::OscilloscopeInfo::buffer_size
unsigned int buffer_size
Definition gx_internal_plugins.h:154
gx_engine::OutPutGate::outputgate_compute
static void outputgate_compute(int count, float *input, float *output, PluginDef *)
gx_engine::OutPutGate::outputdef
PluginDef outputdef
Definition gx_internal_plugins.h:140
gx_engine::OutPutGate::noisegate
const NoiseGate * noisegate
Definition gx_internal_plugins.h:139
gx_engine::OutPutGate::OutPutGate
OutPutGate(const NoiseGate *noisegate)
gx_engine::OutPutGate::outputlevel
Plugin outputlevel
Definition gx_internal_plugins.h:141
gx_engine::OutPutGate::outputgate_process
void outputgate_process(int count, float *input, float *output)
gx_engine::ParamMap
Definition gx_parameter.h:535
gx_engine::Parameter::Parameter
Parameter(const string &id, const string &name, value_type vtp, ctrl_type ctp, bool preset, bool ctrl)
Definition gx_parameter.h:137
gx_engine::ParameterV< GxJConvSettings >::serializeJSON
virtual void serializeJSON(gx_system::JsonWriter &jw)
gx_engine::ParameterV< GxJConvSettings >::~ParameterV
~ParameterV()
gx_engine::ParameterV< GxJConvSettings >::ParameterV
ParameterV(const string &id, ConvolverAdapter &conv, GxJConvSettings *v)
gx_engine::ParameterV< GxJConvSettings >::set
bool set(const GxJConvSettings &val) const
gx_engine::ParameterV< GxJConvSettings >::readJSON_value
virtual void readJSON_value(gx_system::JsonParser &jp)
gx_engine::ParameterV< GxJConvSettings >::get_value
const GxJConvSettings & get_value() const
Definition gx_internal_plugins.h:342
gx_engine::ParameterV< GxJConvSettings >::insert_param
static ParameterV< GxJConvSettings > * insert_param(ParamMap &pmap, const string &id, ConvolverAdapter &conv, GxJConvSettings *v)
gx_engine::ParameterV< GxJConvSettings >::std_value
GxJConvSettings std_value
Definition gx_internal_plugins.h:330
gx_engine::ParameterV< GxJConvSettings >::changed
sigc::signal< void, const GxJConvSettings * > changed
Definition gx_internal_plugins.h:332
gx_engine::ParameterV< GxJConvSettings >::value
GxJConvSettings * value
Definition gx_internal_plugins.h:329
gx_engine::ParameterV< GxJConvSettings >::on_off_value
virtual bool on_off_value()
gx_engine::ParameterV< GxJConvSettings >::writeJSON
virtual void writeJSON(gx_system::JsonWriter &jw) const
gx_engine::ParameterV< GxJConvSettings >::signal_changed
sigc::signal< void, const GxJConvSettings * > & signal_changed()
Definition gx_internal_plugins.h:338
gx_engine::ParameterV< GxJConvSettings >::json_value
GxJConvSettings json_value
Definition gx_internal_plugins.h:328
gx_engine::ParameterV< GxJConvSettings >::value_storage
GxJConvSettings value_storage
Definition gx_internal_plugins.h:331
gx_engine::ParameterV< GxJConvSettings >::ParameterV
ParameterV(gx_system::JsonParser &jp)
gx_engine::ParameterV< GxJConvSettings >::compareJSON_value
virtual bool compareJSON_value()
gx_engine::ParameterV< GxJConvSettings >::stdJSON_value
virtual void stdJSON_value()
gx_engine::ParameterV< GxJConvSettings >::setJSON_value
virtual void setJSON_value()
gx_engine::ParameterV< GxSeqSettings >::set
bool set(const GxSeqSettings &val) const
gx_engine::ParameterV< GxSeqSettings >::value
GxSeqSettings * value
Definition gx_internal_plugins.h:251
gx_engine::ParameterV< GxSeqSettings >::~ParameterV
~ParameterV()
gx_engine::ParameterV< GxSeqSettings >::writeJSON
virtual void writeJSON(gx_system::JsonWriter &jw) const
gx_engine::ParameterV< GxSeqSettings >::setJSON_value
virtual void setJSON_value()
gx_engine::ParameterV< GxSeqSettings >::signal_changed
sigc::signal< void, const GxSeqSettings * > & signal_changed()
Definition gx_internal_plugins.h:260
gx_engine::ParameterV< GxSeqSettings >::readJSON_value
virtual void readJSON_value(gx_system::JsonParser &jp)
gx_engine::ParameterV< GxSeqSettings >::value_storage
GxSeqSettings value_storage
Definition gx_internal_plugins.h:253
gx_engine::ParameterV< GxSeqSettings >::get_value
const GxSeqSettings & get_value() const
Definition gx_internal_plugins.h:264
gx_engine::ParameterV< GxSeqSettings >::serializeJSON
virtual void serializeJSON(gx_system::JsonWriter &jw)
gx_engine::ParameterV< GxSeqSettings >::on_off_value
virtual bool on_off_value()
gx_engine::ParameterV< GxSeqSettings >::changed
sigc::signal< void, const GxSeqSettings * > changed
Definition gx_internal_plugins.h:254
gx_engine::ParameterV< GxSeqSettings >::compareJSON_value
virtual bool compareJSON_value()
gx_engine::ParameterV< GxSeqSettings >::json_value
GxSeqSettings json_value
Definition gx_internal_plugins.h:250
gx_engine::ParameterV< GxSeqSettings >::ParameterV
ParameterV(gx_system::JsonParser &jp)
gx_engine::ParameterV< GxSeqSettings >::std_value
GxSeqSettings std_value
Definition gx_internal_plugins.h:252
gx_engine::ParameterV< GxSeqSettings >::stdJSON_value
virtual void stdJSON_value()
gx_engine::ParameterV< GxSeqSettings >::insert_param
static ParameterV< GxSeqSettings > * insert_param(ParamMap &pmap, const string &id, GxSeqSettings *v)
gx_engine::ParameterV< GxSeqSettings >::ParameterV
ParameterV(const string &id, GxSeqSettings *v)
gx_engine::ParameterV< OscilloscopeInfo >::ParameterV
ParameterV(const string &id, OscilloscopeInfo *v)
gx_engine::ParameterV< OscilloscopeInfo >::ParameterV
ParameterV(gx_system::JsonParser &jp)
gx_engine::ParameterV< OscilloscopeInfo >::signal_changed
sigc::signal< void, const OscilloscopeInfo & > & signal_changed()
Definition gx_internal_plugins.h:186
gx_engine::ParameterV< OscilloscopeInfo >::value_storage
OscilloscopeInfo value_storage
Definition gx_internal_plugins.h:177
gx_engine::ParameterV< OscilloscopeInfo >::compareJSON_value
virtual bool compareJSON_value() override
gx_engine::ParameterV< OscilloscopeInfo >::setJSON_value
virtual void setJSON_value() override
gx_engine::ParameterV< OscilloscopeInfo >::serializeJSON
virtual void serializeJSON(gx_system::JsonWriter &jw) override
gx_engine::ParameterV< OscilloscopeInfo >::value
OscilloscopeInfo * value
Definition gx_internal_plugins.h:178
gx_engine::ParameterV< OscilloscopeInfo >::get_value
OscilloscopeInfo & get_value() const
Definition gx_internal_plugins.h:189
gx_engine::ParameterV< OscilloscopeInfo >::writeJSON
virtual void writeJSON(gx_system::JsonWriter &jw) const override
gx_engine::ParameterV< OscilloscopeInfo >::stdJSON_value
virtual void stdJSON_value() override
gx_engine::ParameterV< OscilloscopeInfo >::insert_param
static ParameterV< OscilloscopeInfo > * insert_param(ParamMap &pmap, const string &id, OscilloscopeInfo *v)
gx_engine::ParameterV< OscilloscopeInfo >::changed
sigc::signal< void, const OscilloscopeInfo & > changed
Definition gx_internal_plugins.h:179
gx_engine::ParameterV< OscilloscopeInfo >::readJSON_value
virtual void readJSON_value(gx_system::JsonParser &jp) override
gx_engine::ParameterV< OscilloscopeInfo >::~ParameterV
~ParameterV()
gx_engine::ParameterV< OscilloscopeInfo >::on_off_value
virtual bool on_off_value() override
gx_engine::ParameterV< OscilloscopeInfo >::trigger_changed
void trigger_changed() override
gx_engine::ParameterV
Definition gx_parameter.h:238
gx_engine::PitchTracker
Definition gx_pitch_tracker.h:33
gx_engine::Plugin
Definition gx_pluginloader.h:45
gx_engine::PreampConvolver::do_update
bool do_update()
gx_engine::PreampConvolver::start
virtual bool start(bool force=false) override
gx_engine::PreampConvolver::smp
gx_resample::FixedRateResampler smp
Definition gx_internal_plugins.h:582
gx_engine::PreampConvolver::register_pre
static int register_pre(const ParamReg &reg)
gx_engine::PreampConvolver::~PreampConvolver
~PreampConvolver()
gx_engine::PreampConvolver::update_preamp
void update_preamp()
Definition gx_internal_plugins.h:589
gx_engine::PreampConvolver::current_pre
int current_pre
Definition gx_internal_plugins.h:575
gx_engine::PreampConvolver::bass
float bass
Definition gx_internal_plugins.h:578
gx_engine::PreampConvolver::pre_names
value_pair * pre_names
Definition gx_internal_plugins.h:580
gx_engine::PreampConvolver::treble
float treble
Definition gx_internal_plugins.h:579
gx_engine::PreampConvolver::run_pre_conf
static void run_pre_conf(int count, float *input, float *output, PluginDef *)
gx_engine::PreampConvolver::impf
preamp_impulse_former::Dsp impf
Definition gx_internal_plugins.h:581
gx_engine::PreampConvolver::check_update
virtual void check_update() override
gx_engine::PreampConvolver::preamp_changed
bool preamp_changed()
Definition gx_internal_plugins.h:588
gx_engine::PreampConvolver::level
float level
Definition gx_internal_plugins.h:576
gx_engine::PreampConvolver::PreampConvolver
PreampConvolver(EngineControl &engine, sigc::slot< void > sync, gx_resample::BufferResampler &resamp)
gx_engine::PreampConvolver::preamp
int preamp
Definition gx_internal_plugins.h:577
gx_engine::PreampStereoConvolver::smps
gx_resample::FixedRateResampler smps
Definition gx_internal_plugins.h:615
gx_engine::PreampStereoConvolver::~PreampStereoConvolver
~PreampStereoConvolver()
gx_engine::PreampStereoConvolver::update_preamp
void update_preamp()
Definition gx_internal_plugins.h:622
gx_engine::PreampStereoConvolver::treble
float treble
Definition gx_internal_plugins.h:611
gx_engine::PreampStereoConvolver::preamp_changed
bool preamp_changed()
Definition gx_internal_plugins.h:621
gx_engine::PreampStereoConvolver::start
virtual bool start(bool force=false) override
gx_engine::PreampStereoConvolver::register_pre
static int register_pre(const ParamReg &reg)
gx_engine::PreampStereoConvolver::do_update
bool do_update()
gx_engine::PreampStereoConvolver::check_update
virtual void check_update() override
gx_engine::PreampStereoConvolver::pre_names
value_pair * pre_names
Definition gx_internal_plugins.h:612
gx_engine::PreampStereoConvolver::current_pre
int current_pre
Definition gx_internal_plugins.h:607
gx_engine::PreampStereoConvolver::impf
preamp_impulse_former_st::Dsp impf
Definition gx_internal_plugins.h:613
gx_engine::PreampStereoConvolver::preamp
int preamp
Definition gx_internal_plugins.h:609
gx_engine::PreampStereoConvolver::PreampStereoConvolver
PreampStereoConvolver(EngineControl &engine, sigc::slot< void > sync, gx_resample::BufferResampler &resamp)
gx_engine::PreampStereoConvolver::run_pre_conf
static void run_pre_conf(int count, float *input, float *input1, float *output, float *output1, PluginDef *)
gx_engine::PreampStereoConvolver::level
float level
Definition gx_internal_plugins.h:608
gx_engine::PreampStereoConvolver::bass
float bass
Definition gx_internal_plugins.h:610
gx_engine::PreampStereoConvolver::smp
gx_resample::FixedRateResampler smp
Definition gx_internal_plugins.h:614
gx_engine::SCapture::savesize
int savesize
Definition gx_internal_plugins.h:1021
gx_engine::SCapture::recfile
SNDFILE * recfile
Definition gx_internal_plugins.h:1009
gx_engine::SCapture::activate_static
static int activate_static(bool start, PluginDef *)
gx_engine::SCapture::stop_thread
void stop_thread()
gx_engine::SCapture::m_pthr
pthread_t m_pthr
Definition gx_internal_plugins.h:1027
gx_engine::SCapture::fslider0
float fslider0
Definition gx_internal_plugins.h:1015
gx_engine::SCapture::mem_alloc
void mem_alloc()
gx_engine::SCapture::m_trig
sem_t m_trig
Definition gx_internal_plugins.h:1026
gx_engine::SCapture::~SCapture
~SCapture()
gx_engine::SCapture::close_stream
void close_stream(SNDFILE **sf)
gx_engine::SCapture::save_to_wave
void save_to_wave(SNDFILE *sf, float *tape, int lSize)
gx_engine::SCapture::is_wav
bool is_wav
Definition gx_internal_plugins.h:1030
gx_engine::SCapture::fRecb0
float fRecb0[2]
Definition gx_internal_plugins.h:1033
gx_engine::SCapture::compute_static_st
static void compute_static_st(int count, float *input0, float *input1, float *output0, float *output1, PluginDef *)
gx_engine::SCapture::fSamplingFreq
int fSamplingFreq
Definition gx_internal_plugins.h:1011
gx_engine::SCapture::keep_stream
volatile bool keep_stream
Definition gx_internal_plugins.h:1028
gx_engine::SCapture::filesize
int filesize
Definition gx_internal_plugins.h:1022
gx_engine::SCapture::plugin
Plugin plugin
Definition gx_internal_plugins.h:1065
gx_engine::SCapture::activate
int activate(bool start)
gx_engine::SCapture::fConst0
float fConst0
Definition gx_internal_plugins.h:1032
gx_engine::SCapture::fcheckbox0
float fcheckbox0
Definition gx_internal_plugins.h:1013
gx_engine::SCapture::iA
int iA
Definition gx_internal_plugins.h:1020
gx_engine::SCapture::iRecb1
int iRecb1[2]
Definition gx_internal_plugins.h:1034
gx_engine::SCapture::channel
int channel
Definition gx_internal_plugins.h:1012
gx_engine::SCapture::get_ffilename
std::string get_ffilename()
gx_engine::SCapture::compute
void compute(int count, float *input0, float *output0)
gx_engine::SCapture::IOTA
int IOTA
Definition gx_internal_plugins.h:1019
gx_engine::SCapture::open_stream
SNDFILE * open_stream(std::string fname)
gx_engine::SCapture::init_static
static void init_static(unsigned int samplingFreq, PluginDef *)
gx_engine::SCapture::mem_free
void mem_free()
gx_engine::SCapture::fcheckbox1
float fcheckbox1
Definition gx_internal_plugins.h:1014
gx_engine::SCapture::run_thread
static void * run_thread(void *p)
gx_engine::SCapture::init
void init(unsigned int samplingFreq)
gx_engine::SCapture::fformat
float fformat
Definition gx_internal_plugins.h:1018
gx_engine::SCapture::mem_allocated
bool mem_allocated
Definition gx_internal_plugins.h:1029
gx_engine::SCapture::tape
float * tape
Definition gx_internal_plugins.h:1025
gx_engine::SCapture::err
bool err
Definition gx_internal_plugins.h:1031
gx_engine::SCapture::start_thread
void start_thread()
gx_engine::SCapture::fRec1
float * fRec1
Definition gx_internal_plugins.h:1024
gx_engine::SCapture::fbargraph0
float fbargraph0
Definition gx_internal_plugins.h:1016
gx_engine::SCapture::clear_state_f_static
static void clear_state_f_static(PluginDef *)
gx_engine::SCapture::load_ui_f
int load_ui_f(const UiBuilder &b, int form)
gx_engine::SCapture::SCapture
SCapture(EngineControl &engine, int channel_)
gx_engine::SCapture::glade_def
static const char * glade_def
Definition gx_internal_plugins.h:1056
gx_engine::SCapture::engine
EngineControl & engine
Definition gx_internal_plugins.h:1010
gx_engine::SCapture::compute_static
static void compute_static(int count, float *input0, float *output0, PluginDef *)
gx_engine::SCapture::load_ui_f_static
static int load_ui_f_static(const UiBuilder &b, int form)
gx_engine::SCapture::compute_st
void compute_st(int count, float *input0, float *input1, float *output0, float *output1)
gx_engine::SCapture::clear_state_f
void clear_state_f()
gx_engine::SCapture::register_par
int register_par(const ParamReg &reg)
gx_engine::SCapture::fRec0
float * fRec0
Definition gx_internal_plugins.h:1023
gx_engine::SCapture::fRecb2
float fRecb2[2]
Definition gx_internal_plugins.h:1035
gx_engine::SCapture::del_instance
static void del_instance(PluginDef *p)
gx_engine::SCapture::fRecC0
float fRecC0[2]
Definition gx_internal_plugins.h:1017
gx_engine::SCapture::disc_stream
void disc_stream()
gx_engine::SCapture::register_params_static
static int register_params_static(const ParamReg &reg)
gx_engine::SCapture::glade_def_st
static const char * glade_def_st
Definition gx_internal_plugins.h:1057
gx_engine::StereoMute::StereoMute
StereoMute()
gx_engine::StereoMute::process
static void process(int count, float *input0, float *input1, float *output0, float *output1, PluginDef *)
gx_engine::TunerAdapter::regparam
static int regparam(const ParamReg &reg)
gx_engine::TunerAdapter::get_freq
float get_freq()
Definition gx_internal_plugins.h:104
gx_engine::TunerAdapter::feed_tuner
static void feed_tuner(int count, float *input, float *output, PluginDef *)
gx_engine::TunerAdapter::plugin
Plugin plugin
Definition gx_internal_plugins.h:94
gx_engine::TunerAdapter::set_module
void set_module()
gx_engine::TunerAdapter::set_fast_note_detection
void set_fast_note_detection(bool on)
Definition gx_internal_plugins.h:102
gx_engine::TunerAdapter::lhc
low_high_cut::Dsp lhc
Definition gx_internal_plugins.h:86
gx_engine::TunerAdapter::set_and_check
void set_and_check(int use, bool on)
gx_engine::TunerAdapter::activate
static int activate(bool start, PluginDef *plugin)
gx_engine::TunerAdapter::TunerAdapter
TunerAdapter(ModuleSequencer &engine)
gx_engine::TunerAdapter::used_for_switching
void used_for_switching(bool on)
Definition gx_internal_plugins.h:96
gx_engine::TunerAdapter::set_dep_module
void set_dep_module(Plugin *dep)
Definition gx_internal_plugins.h:100
gx_engine::TunerAdapter::state
int state
Definition gx_internal_plugins.h:88
gx_engine::TunerAdapter::engine
ModuleSequencer & engine
Definition gx_internal_plugins.h:89
gx_engine::TunerAdapter::pitch_tracker
PitchTracker pitch_tracker
Definition gx_internal_plugins.h:87
gx_engine::TunerAdapter::used_for_display
bool used_for_display()
Definition gx_internal_plugins.h:98
gx_engine::TunerAdapter::dep_plugin
Plugin * dep_plugin
Definition gx_internal_plugins.h:92
gx_engine::TunerAdapter::used_by_midi
void used_by_midi(bool on)
Definition gx_internal_plugins.h:99
gx_engine::TunerAdapter::midi_use
@ midi_use
Definition gx_internal_plugins.h:90
gx_engine::TunerAdapter::switcher_use
@ switcher_use
Definition gx_internal_plugins.h:90
gx_engine::TunerAdapter::tuner_use
@ tuner_use
Definition gx_internal_plugins.h:90
gx_engine::TunerAdapter::signal_freq_changed
sigc::signal< void > & signal_freq_changed()
Definition gx_internal_plugins.h:103
gx_engine::TunerAdapter::used_for_display
void used_for_display(bool on)
Definition gx_internal_plugins.h:97
gx_engine::TunerAdapter::init
static void init(unsigned int samplingFreq, PluginDef *plugin)
gx_engine::TunerAdapter::get_note
float get_note()
Definition gx_internal_plugins.h:105
gx_engine::plugdesc
Definition gx_internal_plugins.h:729
gx_engine::plugdesc::readJSON
void readJSON(gx_system::JsonParser &jp)
gx_engine::plugdesc::Label
Glib::ustring Label
Definition gx_internal_plugins.h:734
gx_engine::plugdesc::master_label
Glib::ustring master_label
Definition gx_internal_plugins.h:741
gx_engine::plugdesc::id_str
std::string id_str
Definition gx_internal_plugins.h:743
gx_engine::plugdesc::UniqueID
unsigned long UniqueID
Definition gx_internal_plugins.h:733
gx_engine::plugdesc::index
unsigned int index
Definition gx_internal_plugins.h:732
gx_engine::plugdesc::plugdesc
plugdesc()
Definition gx_internal_plugins.h:745
gx_engine::plugdesc::stereo_to_mono
int stereo_to_mono
Definition gx_internal_plugins.h:739
gx_engine::plugdesc::shortname
Glib::ustring shortname
Definition gx_internal_plugins.h:735
gx_engine::plugdesc::names
std::vector< paradesc * > names
Definition gx_internal_plugins.h:742
gx_engine::plugdesc::master_idx
int master_idx
Definition gx_internal_plugins.h:740
gx_engine::plugdesc::writeJSON
void writeJSON(gx_system::JsonWriter &jw)
gx_engine::plugdesc::category
Glib::ustring category
Definition gx_internal_plugins.h:736
gx_engine::plugdesc::quirks
int quirks
Definition gx_internal_plugins.h:737
gx_engine::plugdesc::path
std::string path
Definition gx_internal_plugins.h:731
gx_engine::plugdesc::~plugdesc
~plugdesc()
gx_engine::plugdesc::LadspaLoader
friend class LadspaLoader
Definition gx_internal_plugins.h:747
gx_engine::plugdesc::add_wet_dry
int add_wet_dry
Definition gx_internal_plugins.h:738
gx_engine::smbPitchShift::qpd
long qpd
Definition gx_internal_plugins.h:1239
gx_engine::smbPitchShift::gSynMagn
float gSynMagn[MAX_FRAME_LENGTH]
Definition gx_internal_plugins.h:1221
gx_engine::smbPitchShift::semitones
float semitones
Definition gx_internal_plugins.h:1222
gx_engine::smbPitchShift::fftFrameSize4
double fftFrameSize4
Definition gx_internal_plugins.h:1237
gx_engine::smbPitchShift::k
long k
Definition gx_internal_plugins.h:1239
gx_engine::smbPitchShift::PitchShift
void PitchShift(int count, float *indata, float *outdata)
gx_engine::smbPitchShift::numSampsToResamp
int numSampsToResamp
Definition gx_internal_plugins.h:1228
gx_engine::smbPitchShift::mem_alloc
void mem_alloc()
gx_engine::smbPitchShift::hanning
float * hanning
Definition gx_internal_plugins.h:1209
gx_engine::smbPitchShift::hanningd
float * hanningd
Definition gx_internal_plugins.h:1210
gx_engine::smbPitchShift::i
long i
Definition gx_internal_plugins.h:1239
gx_engine::smbPitchShift::gInFIFO
float gInFIFO[MAX_FRAME_LENGTH]
Definition gx_internal_plugins.h:1205
gx_engine::smbPitchShift::ftPlanForward
fftwf_plan ftPlanForward
Definition gx_internal_plugins.h:1242
gx_engine::smbPitchShift::tmp
double tmp
Definition gx_internal_plugins.h:1234
gx_engine::smbPitchShift::imag
double imag
Definition gx_internal_plugins.h:1234
gx_engine::smbPitchShift::index
long index
Definition gx_internal_plugins.h:1239
gx_engine::smbPitchShift::freqPerBin1
double freqPerBin1
Definition gx_internal_plugins.h:1235
gx_engine::smbPitchShift::resamp
gx_resample::SimpleResampler resamp
Definition gx_internal_plugins.h:1200
gx_engine::smbPitchShift::mem_allocated
bool mem_allocated
Definition gx_internal_plugins.h:1202
gx_engine::smbPitchShift::osamp2
double osamp2
Definition gx_internal_plugins.h:1238
gx_engine::smbPitchShift::osamp
int osamp
Definition gx_internal_plugins.h:1228
gx_engine::smbPitchShift::gAnaMagn
float gAnaMagn[MAX_FRAME_LENGTH]
Definition gx_internal_plugins.h:1219
gx_engine::smbPitchShift::gLastPhase
float gLastPhase[MAX_FRAME_LENGTH/2+1]
Definition gx_internal_plugins.h:1215
gx_engine::smbPitchShift::indata2
float * indata2
Definition gx_internal_plugins.h:1214
gx_engine::smbPitchShift::latency
int latency
Definition gx_internal_plugins.h:1229
gx_engine::smbPitchShift::numSampsToProcess
int numSampsToProcess
Definition gx_internal_plugins.h:1228
gx_engine::smbPitchShift::mpi1
float mpi1
Definition gx_internal_plugins.h:1226
gx_engine::smbPitchShift::ii
int ii
Definition gx_internal_plugins.h:1232
gx_engine::smbPitchShift::dry
float dry
Definition gx_internal_plugins.h:1225
gx_engine::smbPitchShift::l
float l
Definition gx_internal_plugins.h:1223
gx_engine::smbPitchShift::activate
int activate(bool start)
gx_engine::smbPitchShift::wet
float wet
Definition gx_internal_plugins.h:1224
gx_engine::smbPitchShift::~smbPitchShift
~smbPitchShift()
gx_engine::smbPitchShift::clear_state
void clear_state()
gx_engine::smbPitchShift::fftFrameSize3
double fftFrameSize3
Definition gx_internal_plugins.h:1236
gx_engine::smbPitchShift::gSynFreq
float gSynFreq[MAX_FRAME_LENGTH]
Definition gx_internal_plugins.h:1220
gx_engine::smbPitchShift::gRover
long gRover
Definition gx_internal_plugins.h:1233
gx_engine::smbPitchShift::ftPlanInverse
fftwf_plan ftPlanInverse
Definition gx_internal_plugins.h:1242
gx_engine::smbPitchShift::freqPerBin2
double freqPerBin2
Definition gx_internal_plugins.h:1235
gx_engine::smbPitchShift::load_ui_f
int load_ui_f(const UiBuilder &b, int form)
gx_engine::smbPitchShift::fftw_out
fftwf_complex fftw_out[MAX_FRAME_LENGTH]
Definition gx_internal_plugins.h:1241
gx_engine::smbPitchShift::gAnaFreq
float gAnaFreq[MAX_FRAME_LENGTH]
Definition gx_internal_plugins.h:1218
gx_engine::smbPitchShift::compute_static
static void compute_static(int count, float *input0, float *output0, PluginDef *p)
gx_engine::smbPitchShift::stepSize
long stepSize
Definition gx_internal_plugins.h:1239
gx_engine::smbPitchShift::activate_static
static int activate_static(bool start, PluginDef *)
gx_engine::smbPitchShift::smbPitchShift
smbPitchShift(EngineControl &engine, sigc::slot< void > sync)
gx_engine::smbPitchShift::resampin
float * resampin
Definition gx_internal_plugins.h:1211
gx_engine::smbPitchShift::resampout
float * resampout
Definition gx_internal_plugins.h:1213
gx_engine::smbPitchShift::mpi
float mpi
Definition gx_internal_plugins.h:1226
gx_engine::smbPitchShift::fftFrameSize
int fftFrameSize
Definition gx_internal_plugins.h:1228
gx_engine::smbPitchShift::d
float d
Definition gx_internal_plugins.h:1223
gx_engine::smbPitchShift::freqPerBin
double freqPerBin
Definition gx_internal_plugins.h:1235
gx_engine::smbPitchShift::expect
float * expect
Definition gx_internal_plugins.h:1208
gx_engine::smbPitchShift::octave
int octave
Definition gx_internal_plugins.h:1228
gx_engine::smbPitchShift::expct
double expct
Definition gx_internal_plugins.h:1235
gx_engine::smbPitchShift::aio
int aio
Definition gx_internal_plugins.h:1231
gx_engine::smbPitchShift::gOutputAccum
float gOutputAccum[2 *MAX_FRAME_LENGTH]
Definition gx_internal_plugins.h:1217
gx_engine::smbPitchShift::real
double real
Definition gx_internal_plugins.h:1234
gx_engine::smbPitchShift::init
static void init(unsigned int sampleRate, PluginDef *plugin)
gx_engine::smbPitchShift::sync
sigc::slot< void > sync
Definition gx_internal_plugins.h:1203
gx_engine::smbPitchShift::registerparam
static int registerparam(const ParamReg &reg)
gx_engine::smbPitchShift::phase
double phase
Definition gx_internal_plugins.h:1234
gx_engine::smbPitchShift::change_latency
void change_latency()
gx_engine::smbPitchShift::load_ui_f_static
static int load_ui_f_static(const UiBuilder &b, int form)
gx_engine::smbPitchShift::resampin2
float * resampin2
Definition gx_internal_plugins.h:1212
gx_engine::smbPitchShift::plugin
Plugin plugin
Definition gx_internal_plugins.h:1263
gx_engine::smbPitchShift::fftw_in
fftwf_complex fftw_in[MAX_FRAME_LENGTH]
Definition gx_internal_plugins.h:1241
gx_engine::smbPitchShift::del_instance
static void del_instance(PluginDef *p)
gx_engine::smbPitchShift::ready
volatile bool ready
Definition gx_internal_plugins.h:1204
gx_engine::smbPitchShift::gSumPhase
float gSumPhase[MAX_FRAME_LENGTH/2+1]
Definition gx_internal_plugins.h:1216
gx_engine::smbPitchShift::register_par
int register_par(const ParamReg &reg)
gx_engine::smbPitchShift::change_buffersize
void change_buffersize(unsigned int size)
gx_engine::smbPitchShift::setParameters
bool setParameters(int sampleRate)
gx_engine::smbPitchShift::inFifoLatency
long inFifoLatency
Definition gx_internal_plugins.h:1239
gx_engine::smbPitchShift::a
float a
Definition gx_internal_plugins.h:1223
gx_engine::smbPitchShift::engine
EngineControl & engine
Definition gx_internal_plugins.h:1201
gx_engine::smbPitchShift::ai
int ai
Definition gx_internal_plugins.h:1230
gx_engine::smbPitchShift::gOutFIFO
float gOutFIFO[MAX_FRAME_LENGTH]
Definition gx_internal_plugins.h:1206
gx_engine::smbPitchShift::fftFrameSize2
long fftFrameSize2
Definition gx_internal_plugins.h:1239
gx_engine::smbPitchShift::mem_free
void mem_free()
gx_engine::smbPitchShift::sampleRate
int sampleRate
Definition gx_internal_plugins.h:1228
gx_engine::smbPitchShift::fpb
float * fpb
Definition gx_internal_plugins.h:1207
gx_engine::smbPitchShift::c
float c
Definition gx_internal_plugins.h:1223
gx_engine::smbPitchShift::tone
float tone
Definition gx_internal_plugins.h:1227
gx_engine::smbPitchShift::magn
double magn
Definition gx_internal_plugins.h:1234
gx_engine::smbPitchShift::osamp1
double osamp1
Definition gx_internal_plugins.h:1238
gx_engine::smbPitchShift::b
float b
Definition gx_internal_plugins.h:1223
gx_jack::GxJack
Definition gx_jack.h:168
gx_resample::BufferResampler
Definition gx_resampler.h:49
gx_resample::FixedRateResampler
Definition gx_resampler.h:65
gx_resample::SimpleResampler
Definition gx_resampler.h:38
gx_system::CmdlineOptions
Definition gx_system.h:395
gx_system::JsonParser
Definition gx_json.h:112
gx_system::JsonWriter
Definition gx_json.h:55
FAUSTFLOAT
#define FAUSTFLOAT
Definition gx_faust_support.h:23
MAX_FRAME_LENGTH
#define MAX_FRAME_LENGTH
Definition gx_internal_plugins.h:1196
gx_neural_plugins.h
gx_engine
Definition gx_convolver.h:37
gx_engine::OscParameter
ParameterV< OscilloscopeInfo > OscParameter
Definition gx_internal_plugins.h:198
gx_engine::quirkflag
quirkflag
Definition gx_internal_plugins.h:727
gx_engine::no_cleanup
@ no_cleanup
Definition gx_internal_plugins.h:727
gx_engine::need_activate
@ need_activate
Definition gx_internal_plugins.h:727
gx_engine::is_lv2
@ is_lv2
Definition gx_internal_plugins.h:727
gx_engine::SeqParameter
ParameterV< GxSeqSettings > SeqParameter
Definition gx_internal_plugins.h:273
gx_engine::JConvParameter
ParameterV< GxJConvSettings > JConvParameter
Definition gx_internal_plugins.h:351
gx_engine::widget_type
widget_type
Definition gx_internal_plugins.h:707
gx_engine::tp_enabled
@ tp_enabled
Definition gx_internal_plugins.h:707
gx_engine::tp_toggle
@ tp_toggle
Definition gx_internal_plugins.h:707
gx_engine::tp_display
@ tp_display
Definition gx_internal_plugins.h:707
gx_engine::tp_scale
@ tp_scale
Definition gx_internal_plugins.h:707
gx_engine::tp_display_toggle
@ tp_display_toggle
Definition gx_internal_plugins.h:707
gx_engine::tp_scale_log
@ tp_scale_log
Definition gx_internal_plugins.h:707
gx_engine::tp_enum
@ tp_enum
Definition gx_internal_plugins.h:707
gx_engine::tp_atom
@ tp_atom
Definition gx_internal_plugins.h:707
gx_engine::tp_none
@ tp_none
Definition gx_internal_plugins.h:707
gx_engine::tp_int
@ tp_int
Definition gx_internal_plugins.h:707
gx_jack
Definition gx_internal_plugins.h:27
gx_system::to_string
std::string to_string(const T &t)
Definition gx_system.h:572
ParamReg
Parameter registration function pointers.
Definition gx_plugin.h:141
PluginDef
Definition gx_plugin.h:195
PluginDef::name
const char * name
Definition gx_plugin.h:200
UiBuilder
Definition gx_plugin.h:63
gx_engine::paradesc::up
float up
Definition gx_internal_plugins.h:714
gx_engine::paradesc::values
value_pair * values
Definition gx_internal_plugins.h:719
gx_engine::paradesc::has_caption
bool has_caption
Definition gx_internal_plugins.h:718
gx_engine::paradesc::tp
widget_type tp
Definition gx_internal_plugins.h:716
gx_engine::paradesc::name
std::string name
Definition gx_internal_plugins.h:711
gx_engine::paradesc::step
float step
Definition gx_internal_plugins.h:715
gx_engine::paradesc::writeJSON
void writeJSON(gx_system::JsonWriter &jw)
gx_engine::paradesc::newrow
bool newrow
Definition gx_internal_plugins.h:717
gx_engine::paradesc::readJSON
void readJSON(gx_system::JsonParser &jp)
gx_engine::paradesc::dflt
float dflt
Definition gx_internal_plugins.h:712
gx_engine::paradesc::paradesc
paradesc()
Definition gx_internal_plugins.h:720
gx_engine::paradesc::~paradesc
~paradesc()
gx_engine::paradesc::index
int index
Definition gx_internal_plugins.h:710
gx_engine::paradesc::low
float low
Definition gx_internal_plugins.h:713
gx_engine::paradesc::set_valuelist
void set_valuelist(const std::vector< std::string > &v)
value_pair
Definition gx_plugin.h:117