hashtags/lmms
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 1 Wiki Activity

Merge branch 'calf-updates'

Browse Source 
* calf-updates:
  LADSPA/CALF: removed unused file
  One table_edit_iface per table; start implementing a bridge class. (cherry picked from commit 2019ae2d8f9636b7d5cdb0c1fdd5f0d6f2b47e3d)
  Move the table_edit_iface out of plugin_metadata_iface, where it should have never been in first place. (cherry picked from commit 6907dc9670eae2313707b142c552a8d9e8b477b5)
  Fix organ crash in calfjackhost. (cherry picked from commit b2853103199b3f5f3a5d22271c5d89122514dd53)
  Remove the forgotten leftover references to the old extensions. (cherry picked from commit deb8b77bdb1e1648a38589b3be3d4d66175b4934)
  Replace string port/message context using persist extension. (cherry picked from commit b8e69ceb2ff7aca549efd939d04447e2f08ad5a8)
  Comment out the barfage when passing configure variables via message_run. (cherry picked from commit 1e767ff88578011c2f65466d5516953271e2cafd)
  Add a crude incomplete implementation of persist extension support. (cherry picked from commit 3ec11c04799fc08fd408c4ef2350df65f88ccfde)
  Add LV2 persist extension by paniq. (cherry picked from commit 1965282a28c6940164ffff7ebd106b27cafd7f2a)
  More refactoring of the VUs. The goal: to be able to add peak meters without major hassle. (cherry picked from commit 00ee132cc2ebe3b664c7d5760260d76dda37bf26)
  Fix handling of very short notes in Monosynth. (cherry picked from commit 5965d9922a0753e2dce4f743a23b9512be01a7ac)
(cherry picked from commit 01c91b6ce3)
This commit is contained in:
Tobias Doerffel
2010-09-28 23:40:23 +02:00
parent 79d6cff46f
commit f1f5040ddc
17 changed files with 334 additions and 224 deletions
Download Patch File Download Diff File Expand all files Collapse all files

67
plugins/ladspa_effect/calf/src/calf/giface.h
View File

@@ -47,7 +47,6 @@ enum parameter_flags
PF_BOOL = 0x0002, ///< bool value (usually >=0.5f is treated as TRUE, which is inconsistent with LV2 etc. which treats anything >0 as TRUE)
PF_ENUM = 0x0003, ///< enum value (min, min+1, ..., max, only guaranteed to work when min = 0)
PF_ENUM_MULTI = 0x0004, ///< SET / multiple-choice
PF_STRING = 0x0005, ///< see: http://lv2plug.in/docs/index.php?title=String_port
PF_SCALEMASK = 0xF0, ///< bit mask for scale
PF_SCALE_DEFAULT = 0x00, ///< no scale given
@@ -82,7 +81,6 @@ enum parameter_flags
PF_PROP_OUTPUT = 0x080000, ///< output port
PF_PROP_OPTIONAL = 0x100000, ///< connection optional
PF_PROP_GRAPH = 0x200000, ///< add graph
PF_PROP_MSGCONTEXT= 0x400000, ///< message context
PF_UNITMASK = 0xFF000000, ///< bit mask for units \todo reduce to use only 5 bits
PF_UNIT_DB = 0x01000000, ///< decibels
@@ -227,22 +225,22 @@ struct table_column_info
struct table_edit_iface
{
/// retrieve the table layout for specific parameter
virtual const table_column_info *get_table_columns(int param) const = 0;
virtual const table_column_info *get_table_columns() const = 0;
/// return the current number of rows
virtual uint32_t get_table_rows(int param) const = 0;
virtual uint32_t get_table_rows() const = 0;
/// retrieve data item from the plugin
virtual std::string get_cell(int param, int row, int column) const;
virtual std::string get_cell(int row, int column) const;
/// set data item to the plugin
virtual void set_cell(int param, int row, int column, const std::string &src, std::string &error) const { error.clear(); }
virtual void set_cell(int row, int column, const std::string &src, std::string &error) { error.clear(); }
/// return a line graph interface for a specific parameter/column (unused for now)
virtual const line_graph_iface *get_graph_iface(int param, int column) const { return NULL; }
virtual const line_graph_iface *get_graph_iface(int column) const { return NULL; }
/// return an editor name for a specific grid cell (unused for now - I don't even know how editors be implemented)
virtual const char *get_cell_editor(int param, int column) const { return NULL; }
virtual const char *get_cell_editor(int column) const { return NULL; }
virtual ~table_edit_iface() {}
};
@@ -317,8 +315,6 @@ struct plugin_metadata_iface
virtual bool requires_midi() const =0;
/// @return port offset of first control (parameter) port (= number of audio inputs + number of audio outputs in all existing plugins as for 1 Aug 2008)
virtual int get_param_port_offset() const = 0;
/// @return table_edit_iface if any
virtual const table_edit_iface *get_table_edit_iface() const = 0;
/// @return NULL-terminated list of menu commands
virtual plugin_command_info *get_commands() const { return NULL; }
/// @return description structure for given parameter
@@ -331,12 +327,10 @@ struct plugin_metadata_iface
virtual bool is_cv(int param_no) const = 0;
/// is the given parameter non-interpolated?
virtual bool is_noisy(int param_no) const = 0;
/// does the plugin require message context? (or DSSI configure) may be slow
virtual bool requires_message_context() const = 0;
/// does the plugin require string port extension? (or DSSI configure) may be slow
virtual bool requires_string_ports() const = 0;
/// add all message context parameter numbers to the ports vector
virtual void get_message_context_parameters(std::vector<int> &ports) const = 0;
virtual bool requires_configure() const = 0;
/// obtain array of names of configure variables (or NULL is none needed)
virtual const char *const *get_configure_vars() const { return NULL; }
/// Do-nothing destructor to silence compiler warning
virtual ~plugin_metadata_iface() {}
@@ -371,6 +365,8 @@ struct plugin_ctl_iface
virtual const plugin_metadata_iface *get_metadata_iface() const = 0;
/// @return line_graph_iface if any
virtual const line_graph_iface *get_line_graph_iface() const = 0;
/// @return table_edit_iface if any
virtual table_edit_iface *get_table_edit_iface(const char *key) = 0;
/// Do-nothing destructor to silence compiler warning
virtual ~plugin_ctl_iface() {}
};
@@ -427,7 +423,7 @@ struct audio_module_iface
virtual void set_sample_rate(uint32_t sr) = 0;
/// Execute menu command with given number
virtual void execute(int cmd_no) = 0;
/// DSSI configure call
/// DSSI configure call, value = NULL = reset to default
virtual char *configure(const char *key, const char *value) = 0;
/// Send all understood configure vars (none by default)
virtual void send_configures(send_configure_iface *sci) = 0;
@@ -451,6 +447,8 @@ struct audio_module_iface
virtual uint32_t message_run(const void *valid_ports, void *output_ports) = 0;
/// @return line_graph_iface if any
virtual const line_graph_iface *get_line_graph_iface() const = 0;
/// @return table_edit_iface if any for given parameter
virtual table_edit_iface *get_table_edit_iface(const char *key) = 0;
virtual ~audio_module_iface() {}
};
@@ -550,11 +548,10 @@ public:
}
/// @return line_graph_iface if any
virtual const line_graph_iface *get_line_graph_iface() const { return dynamic_cast<const line_graph_iface *>(this); }
virtual table_edit_iface *get_table_edit_iface(const char *key) { const char *key_us = get_table_edit_iface_key(); return (key_us && !strcmp(key, key_us)) ? dynamic_cast<table_edit_iface *>(this) : NULL; }
virtual const char *get_table_edit_iface_key() const { return NULL; }
};
extern bool check_for_message_context_ports(const parameter_properties *parameters, int count);
extern bool check_for_string_ports(const parameter_properties *parameters, int count);
#if USE_EXEC_GUI || USE_DSSI
enum line_graph_item
@@ -616,7 +613,6 @@ public:
bool get_midi() const { return Metadata::support_midi; }
bool requires_midi() const { return Metadata::require_midi; }
bool is_rt_capable() const { return Metadata::rt_capable; }
const table_edit_iface *get_table_edit_iface() const { return dynamic_cast<const table_edit_iface *>(this); }
int get_param_port_offset() const { return Metadata::in_count + Metadata::out_count; }
const char *get_gui_xml() const { static const char *data_ptr = calf_plugins::load_gui_xml(get_id()); return data_ptr; }
plugin_command_info *get_commands() const { return NULL; }
@@ -625,14 +621,7 @@ public:
bool is_cv(int param_no) const { return true; }
bool is_noisy(int param_no) const { return false; }
const ladspa_plugin_info &get_plugin_info() const { return plugin_info; }
bool requires_message_context() const { return check_for_message_context_ports(param_props, Metadata::param_count); }
bool requires_string_ports() const { return check_for_string_ports(param_props, Metadata::param_count); }
void get_message_context_parameters(std::vector<int> &ports) const {
for (int i = 0; i < get_param_count(); ++i) {
if (get_param_props(i)->flags & PF_PROP_MSGCONTEXT)
ports.push_back(i);
}
}
bool requires_configure() const { return false; }
};
#define CALF_PORT_NAMES(name) template<> const char *::plugin_metadata<name##_metadata>::port_names[]
@@ -689,6 +678,28 @@ struct preset_access_iface
virtual ~preset_access_iface() {}
};
#if USE_EXEC_GUI
class table_via_configure: public table_edit_iface
{
protected:
typedef std::pair<int, int> coord;
std::vector<table_column_info> columns;
std::map<coord, std::string> values;
int rows;
public:
table_via_configure();
void configure(const char *key, const char *value);
virtual const table_column_info *get_table_columns() const;
virtual uint32_t get_table_rows() const;
virtual std::string get_cell(int row, int column) const;
virtual void set_cell(int row, int column, const std::string &src, std::string &error);
virtual const line_graph_iface *get_graph_iface(int column) const;
virtual const char *get_cell_editor(int column) const;
virtual ~table_via_configure();
};
#endif
};
#endif

3
plugins/ladspa_effect/calf/src/calf/ladspa_wrap.h
View File

@@ -48,6 +48,7 @@ struct ladspa_instance: public plugin_ctl_iface
ladspa_instance(audio_module_iface *_module, ladspa_plugin_metadata_set *_ladspa, int sample_rate);
virtual const line_graph_iface *get_line_graph_iface() const { return module->get_line_graph_iface(); }
virtual table_edit_iface *get_table_edit_iface(const char *key) { return module->get_table_edit_iface(key); }
virtual float get_param_value(int param_no);
virtual void set_param_value(int param_no, float value);
virtual bool activate_preset(int bank, int program);
@@ -88,7 +89,7 @@ struct ladspa_plugin_metadata_set
std::vector<DSSI_Program_Descriptor> *preset_descs;
#endif
int input_count, output_count, param_count, real_param_count;
int input_count, output_count, param_count;
const plugin_metadata_iface *metadata;
ladspa_plugin_metadata_set();

102
plugins/ladspa_effect/calf/src/calf/lv2wrap.h
View File

@@ -27,11 +27,9 @@
#include <vector>
#include <lv2.h>
#include <calf/giface.h>
#include <calf/lv2-midiport.h>
#include <calf/lv2_contexts.h>
#include <calf/lv2_event.h>
#include <calf/lv2_persist.h>
#include <calf/lv2_progress.h>
#include <calf/lv2_string_port.h>
#include <calf/lv2_uri_map.h>
#include <string.h>
@@ -43,32 +41,29 @@ struct lv2_instance: public plugin_ctl_iface, public progress_report_iface
audio_module_iface *module;
bool set_srate;
int srate_to_set;
LV2_MIDI *midi_data;
LV2_Event_Buffer *event_data;
LV2_URI_Map_Feature *uri_map;
LV2_Event_Feature *event_feature;
uint32_t midi_event_type;
std::vector<int> message_params;
LV2_Progress *progress_report_feature;
float **ins, **outs, **params;
int out_count;
int real_param_count;
lv2_instance(audio_module_iface *_module)
{
module = _module;
module->get_port_arrays(ins, outs, params);
metadata = module->get_metadata_iface();
metadata->get_message_context_parameters(message_params);
out_count = metadata->get_output_count();
real_param_count = metadata->get_param_count();
uri_map = NULL;
midi_data = NULL;
event_data = NULL;
progress_report_feature = NULL;
midi_event_type = 0xFFFFFFFF;
srate_to_set = 44100;
set_srate = true;
// printf("message params %d\n", (int)message_params.size());
}
/// This, and not Module::post_instantiate, is actually called by lv2_wrapper class
void post_instantiate()
@@ -91,21 +86,23 @@ struct lv2_instance: public plugin_ctl_iface, public progress_report_iface
void send_configures(send_configure_iface *sci) {
module->send_configures(sci);
}
uint32_t impl_message_run(const void *valid_inputs, void *output_ports) {
uint8_t *vi = (uint8_t *)valid_inputs;
int ofs = metadata->get_param_port_offset();
for (unsigned int i = 0; i < message_params.size(); i++)
void impl_restore(LV2_Persist_Retrieve_Function retrieve, void *callback_data)
{
const char *const *vars = module->get_metadata_iface()->get_configure_vars();
if (!vars)
return;
for (unsigned int i = 0; vars[i]; i++)
{
int pn = message_params[i];
const parameter_properties &pp = *metadata->get_param_props(pn);
int ppn = pn + ofs;
if ((pp.flags & PF_TYPEMASK) == PF_STRING && (vi[ppn >> 3] & (1 << (ppn & 7)))
&& (((LV2_String_Data *)params[pn])->flags & LV2_STRING_DATA_CHANGED_FLAG)) {
printf("Calling configure on %s\n", pp.short_name);
configure(pp.short_name, ((LV2_String_Data *)params[pn])->data);
size_t len = 0;
const void *ptr = (*retrieve)(callback_data, vars[i], &len);
if (ptr)
{
printf("Calling configure on %s\n", vars[i]);
configure(vars[i], std::string((const char *)ptr, len).c_str());
}
else
configure(vars[i], NULL);
}
return module->message_run(valid_inputs, output_ports);
}
char *configure(const char *key, const char *value) {
// disambiguation - the plugin_ctl_iface version is just a stub, so don't use it
@@ -150,19 +147,20 @@ struct lv2_instance: public plugin_ctl_iface, public progress_report_iface
virtual float get_param_value(int param_no)
{
// XXXKF hack
if (param_no >= metadata->get_param_count())
if (param_no >= real_param_count)
return 0;
return (*params)[param_no];
}
virtual void set_param_value(int param_no, float value)
{
// XXXKF hack
if (param_no >= metadata->get_param_count())
if (param_no >= real_param_count)
return;
*params[param_no] = value;
}
virtual const plugin_metadata_iface *get_metadata_iface() const { return metadata; }
virtual const line_graph_iface *get_line_graph_iface() const { return module->get_line_graph_iface(); }
virtual table_edit_iface *get_table_edit_iface(const char *key) { return module->get_table_edit_iface(key); }
virtual int send_status_updates(send_updates_iface *sui, int last_serial) { return module->send_status_updates(sui, last_serial); }
};
@@ -176,7 +174,7 @@ struct lv2_wrapper
typedef lv2_instance instance;
static LV2_Descriptor descriptor;
static LV2_Calf_Descriptor calf_descriptor;
static LV2MessageContext message_context;
static LV2_Persist persist;
std::string uri;
lv2_wrapper()
@@ -191,12 +189,13 @@ struct lv2_wrapper
descriptor.deactivate = cb_deactivate;
descriptor.cleanup = cb_cleanup;
descriptor.extension_data = cb_ext_data;
persist.save = cb_persist_save;
persist.restore = cb_persist_restore;
calf_descriptor.get_pci = cb_get_pci;
message_context.message_connect_port = cb_connect;
message_context.message_run = cb_message_run;
}
static void cb_connect(LV2_Handle Instance, uint32_t port, void *DataLocation) {
static void cb_connect(LV2_Handle Instance, uint32_t port, void *DataLocation)
{
instance *const mod = (instance *)Instance;
const plugin_metadata_iface *md = mod->metadata;
unsigned long ins = md->get_input_count();
@@ -215,12 +214,14 @@ struct lv2_wrapper
}
}
static void cb_activate(LV2_Handle Instance) {
static void cb_activate(LV2_Handle Instance)
{
instance *const mod = (instance *)Instance;
mod->set_srate = true;
}
static void cb_deactivate(LV2_Handle Instance) {
static void cb_deactivate(LV2_Handle Instance)
{
instance *const mod = (instance *)Instance;
mod->module->deactivate();
}
@@ -259,11 +260,8 @@ struct lv2_wrapper
return static_cast<plugin_ctl_iface *>(Instance);
}
static uint32_t cb_message_run(LV2_Handle Instance, const void *valid_inputs, void *outputs_written) {
instance *mod = (instance *)Instance;
return mod->impl_message_run(valid_inputs, outputs_written);
}
static void cb_run(LV2_Handle Instance, uint32_t SampleCount) {
static void cb_run(LV2_Handle Instance, uint32_t SampleCount)
{
instance *const inst = (instance *)Instance;
audio_module_iface *mod = inst->module;
if (inst->set_srate) {
@@ -279,20 +277,46 @@ struct lv2_wrapper
}
inst->module->process_slice(offset, SampleCount);
}
static void cb_cleanup(LV2_Handle Instance) {
static void cb_cleanup(LV2_Handle Instance)
{
instance *const mod = (instance *)Instance;
delete mod;
}
static const void *cb_ext_data(const char *URI) {
static const void *cb_ext_data(const char *URI)
{
if (!strcmp(URI, "http://foltman.com/ns/calf-plugin-instance"))
return &calf_descriptor;
if (!strcmp(URI, LV2_CONTEXT_MESSAGE))
return &message_context;
if (!strcmp(URI, LV2_PERSIST_URI))
return &persist;
return NULL;
}
static void cb_persist_save(LV2_Handle Instance, LV2_Persist_Store_Function store, void *callback_data)
{
instance *const inst = (instance *)Instance;
struct store_state: public send_configure_iface
{
LV2_Persist_Store_Function store;
void *callback_data;
virtual void send_configure(const char *key, const char *value)
{
(*store)(callback_data, key, value, strlen(value));
}
};
store_state s;
s.store = store;
s.callback_data = callback_data;
inst->send_configures(&s);
}
static void cb_persist_restore(LV2_Handle Instance, LV2_Persist_Retrieve_Function retrieve, void *callback_data)
{
instance *const inst = (instance *)Instance;
inst->impl_restore(retrieve, callback_data);
}
static lv2_wrapper &get() {
static lv2_wrapper instance;
return instance;
static lv2_wrapper *instance = new lv2_wrapper;
return *instance;
}
};

44
plugins/ladspa_effect/calf/src/calf/metadata.h
View File

@@ -25,6 +25,9 @@
#include "giface.h"
#define MONO_VU_METER_PARAMS param_meter_in, param_meter_out, param_clip_in, param_clip_out
#define STEREO_VU_METER_PARAMS param_meter_inL, param_meter_inR, param_meter_outL, param_meter_outR, param_clip_inL, param_clip_inR, param_clip_outL, param_clip_outR
namespace calf_plugins {
struct flanger_metadata: public plugin_metadata<flanger_metadata>
@@ -147,7 +150,7 @@ struct monosynth_metadata: public plugin_metadata<monosynth_metadata>
struct compressor_metadata: public plugin_metadata<compressor_metadata>
{
enum { in_count = 2, out_count = 2, ins_optional = 0, outs_optional = 0, support_midi = false, require_midi = false, rt_capable = true };
enum { param_bypass, param_level_in, param_meter_in, param_meter_out, param_clip_in, param_clip_out,
enum { param_bypass, param_level_in, MONO_VU_METER_PARAMS,
param_threshold, param_ratio, param_attack, param_release, param_makeup, param_knee, param_detection, param_stereo_link, param_compression,
param_count };
PLUGIN_NAME_ID_LABEL("compressor", "compressor", "Compressor")
@@ -157,7 +160,7 @@ struct compressor_metadata: public plugin_metadata<compressor_metadata>
struct sidechaincompressor_metadata: public plugin_metadata<sidechaincompressor_metadata>
{
enum { in_count = 2, out_count = 2, ins_optional = 0, outs_optional = 0, support_midi = false, require_midi = false, rt_capable = true };
enum { param_bypass, param_level_in, param_meter_in, param_meter_out, param_clip_in, param_clip_out,
enum { param_bypass, param_level_in, MONO_VU_METER_PARAMS,
param_threshold, param_ratio, param_attack, param_release, param_makeup, param_knee, param_detection, param_stereo_link, param_compression,
param_sc_mode, param_f1_freq, param_f2_freq, param_f1_level, param_f2_level,
param_sc_listen, param_f1_active, param_f2_active, param_count };
@@ -168,8 +171,8 @@ struct sidechaincompressor_metadata: public plugin_metadata<sidechaincompressor_
struct multibandcompressor_metadata: public plugin_metadata<multibandcompressor_metadata>
{
enum { in_count = 2, out_count = 2, ins_optional = 0, outs_optional = 0, support_midi = false, require_midi = false, rt_capable = true };
enum { param_bypass, param_level_in, param_level_out, param_meter_inL, param_meter_inR,
param_meter_outL, param_meter_outR, param_clip_inL, param_clip_inR, param_clip_outL, param_clip_outR,
enum { param_bypass, param_level_in, param_level_out,
STEREO_VU_METER_PARAMS,
param_freq0, param_freq1, param_freq2,
param_sep0, param_sep1, param_sep2,
param_q0, param_q1, param_q2,
@@ -202,7 +205,7 @@ struct deesser_metadata: public plugin_metadata<deesser_metadata>
struct gate_metadata: public plugin_metadata<gate_metadata>
{
enum { in_count = 2, out_count = 2, ins_optional = 0, outs_optional = 0, support_midi = false, require_midi = false, rt_capable = true };
enum { param_bypass, param_level_in, param_meter_in, param_meter_out, param_clip_in, param_clip_out,
enum { param_bypass, param_level_in, MONO_VU_METER_PARAMS,
param_range, param_threshold, param_ratio, param_attack, param_release, param_makeup, param_knee, param_detection, param_stereo_link, param_gating,
param_count };
PLUGIN_NAME_ID_LABEL("gate", "gate", "Gate")
@@ -212,7 +215,7 @@ struct gate_metadata: public plugin_metadata<gate_metadata>
struct sidechaingate_metadata: public plugin_metadata<sidechaingate_metadata>
{
enum { in_count = 2, out_count = 2, ins_optional = 0, outs_optional = 0, support_midi = false, require_midi = false, rt_capable = true };
enum { param_bypass, param_level_in, param_meter_in, param_meter_out, param_clip_in, param_clip_out,
enum { param_bypass, param_level_in, MONO_VU_METER_PARAMS,
param_range, param_threshold, param_ratio, param_attack, param_release, param_makeup, param_knee, param_detection, param_stereo_link, param_gating,
param_sc_mode, param_f1_freq, param_f2_freq, param_f1_level, param_f2_level,
param_sc_listen, param_f1_active, param_f2_active, param_count };
@@ -223,8 +226,7 @@ struct sidechaingate_metadata: public plugin_metadata<sidechaingate_metadata>
struct equalizer5band_metadata: public plugin_metadata<equalizer5band_metadata>
{
enum { in_count = 2, out_count = 2, ins_optional = 0, outs_optional = 0, support_midi = false, require_midi = false, rt_capable = true };
enum { param_bypass, param_level_in, param_level_out, param_meter_inL, param_meter_inR,
param_meter_outL, param_meter_outR, param_clip_inL, param_clip_outL, param_clip_inR, param_clip_outR,
enum { param_bypass, param_level_in, param_level_out, STEREO_VU_METER_PARAMS,
param_ls_active, param_ls_level, param_ls_freq,
param_hs_active, param_hs_level, param_hs_freq,
param_p1_active, param_p1_level, param_p1_freq, param_p1_q,
@@ -241,8 +243,8 @@ struct equalizer5band_metadata: public plugin_metadata<equalizer5band_metadata>
struct equalizer8band_metadata: public plugin_metadata<equalizer8band_metadata>
{
enum { in_count = 2, out_count = 2, ins_optional = 0, outs_optional = 0, support_midi = false, require_midi = false, rt_capable = true };
enum { param_bypass, param_level_in, param_level_out, param_meter_inL, param_meter_inR,
param_meter_outL, param_meter_outR, param_clip_inL, param_clip_inR, param_clip_outL, param_clip_outR,
enum { param_bypass, param_level_in, param_level_out,
STEREO_VU_METER_PARAMS,
param_hp_active, param_hp_freq, param_hp_mode,
param_lp_active, param_lp_freq, param_lp_mode,
param_ls_active, param_ls_level, param_ls_freq,
@@ -259,8 +261,8 @@ struct equalizer8band_metadata: public plugin_metadata<equalizer8band_metadata>
struct equalizer12band_metadata: public plugin_metadata<equalizer12band_metadata>
{
enum { in_count = 2, out_count = 2, ins_optional = 0, outs_optional = 0, support_midi = false, require_midi = false, rt_capable = true };
enum { param_bypass, param_level_in, param_level_out, param_meter_inL, param_meter_inR,
param_meter_outL, param_meter_outR, param_clip_inL, param_clip_inR, param_clip_outL, param_clip_outR,
enum { param_bypass, param_level_in, param_level_out,
STEREO_VU_METER_PARAMS,
param_hp_active, param_hp_freq, param_hp_mode,
param_lp_active, param_lp_freq, param_lp_mode,
param_ls_active, param_ls_level, param_ls_freq,
@@ -282,8 +284,7 @@ struct equalizer12band_metadata: public plugin_metadata<equalizer12band_metadata
struct pulsator_metadata: public plugin_metadata<pulsator_metadata>
{
enum { in_count = 2, out_count = 2, ins_optional = 0, outs_optional = 0, support_midi = false, require_midi = false, rt_capable = true };
enum { param_bypass, param_level_in, param_level_out, param_meter_inL, param_meter_inR,
param_meter_outL, param_meter_outR, param_clip_inL, param_clip_inR, param_clip_outL, param_clip_outR,
enum { param_bypass, param_level_in, param_level_out, STEREO_VU_METER_PARAMS,
param_mode, param_freq, param_amount, param_offset, param_mono, param_reset, param_count };
PLUGIN_NAME_ID_LABEL("pulsator", "pulsator", "Pulsator")
};
@@ -292,8 +293,7 @@ struct pulsator_metadata: public plugin_metadata<pulsator_metadata>
struct saturator_metadata: public plugin_metadata<saturator_metadata>
{
enum { in_count = 2, out_count = 2, ins_optional = 1, outs_optional = 1, support_midi = false, require_midi = false, rt_capable = true };
enum { param_bypass, param_level_in, param_level_out, param_mix, param_meter_in,
param_meter_out, param_clip_in, param_clip_out, param_drive, param_blend, param_meter_drive,
enum { param_bypass, param_level_in, param_level_out, param_mix, MONO_VU_METER_PARAMS, param_drive, param_blend, param_meter_drive,
param_lp_pre_freq, param_hp_pre_freq, param_lp_post_freq, param_hp_post_freq,
param_p_freq, param_p_level, param_p_q, param_count };
PLUGIN_NAME_ID_LABEL("saturator", "saturator", "Saturator")
@@ -302,8 +302,7 @@ struct saturator_metadata: public plugin_metadata<saturator_metadata>
struct exciter_metadata: public plugin_metadata<exciter_metadata>
{
enum { in_count = 2, out_count = 2, ins_optional = 1, outs_optional = 1, support_midi = false, require_midi = false, rt_capable = true };
enum { param_bypass, param_level_in, param_level_out, param_amount, param_meter_in,
param_meter_out, param_clip_in, param_clip_out, param_drive, param_blend, param_meter_drive,
enum { param_bypass, param_level_in, param_level_out, param_amount, MONO_VU_METER_PARAMS, param_drive, param_blend, param_meter_drive,
param_freq, param_listen, param_count };
PLUGIN_NAME_ID_LABEL("exciter", "exciter", "Exciter")
};
@@ -311,8 +310,7 @@ struct exciter_metadata: public plugin_metadata<exciter_metadata>
struct bassenhancer_metadata: public plugin_metadata<bassenhancer_metadata>
{
enum { in_count = 2, out_count = 2, ins_optional = 1, outs_optional = 1, support_midi = false, require_midi = false, rt_capable = true };
enum { param_bypass, param_level_in, param_level_out, param_amount, param_meter_in,
param_meter_out, param_clip_in, param_clip_out, param_drive, param_blend, param_meter_drive,
enum { param_bypass, param_level_in, param_level_out, param_amount, MONO_VU_METER_PARAMS, param_drive, param_blend, param_meter_drive,
param_freq, param_listen, param_count };
PLUGIN_NAME_ID_LABEL("bassenhancer", "bassenhancer", "Bass Enhancer")
};
@@ -405,7 +403,10 @@ struct organ_metadata: public organ_enums, public plugin_metadata<organ_metadata
{
enum { in_count = 0, out_count = 2, ins_optional = 0, outs_optional = 0, support_midi = true, require_midi = true, rt_capable = true };
PLUGIN_NAME_ID_LABEL("organ", "organ", "Organ")
public:
plugin_command_info *get_commands();
const char *const *get_configure_vars() const;
};
/// FluidSynth - metadata
@@ -414,6 +415,9 @@ struct fluidsynth_metadata: public plugin_metadata<fluidsynth_metadata>
enum { par_master, par_interpolation, par_reverb, par_chorus, par_soundfont, par_preset_key_set, param_count };
enum { in_count = 0, out_count = 2, ins_optional = 0, outs_optional = 0, support_midi = true, require_midi = true, rt_capable = false };
PLUGIN_NAME_ID_LABEL("fluidsynth", "fluidsynth", "Fluidsynth")
public:
const char *const *get_configure_vars() const;
};
/// Wavetable - metadata

8
plugins/ladspa_effect/calf/src/calf/modmatrix.h
View File

@@ -84,10 +84,10 @@ protected:
mod_matrix(dsp::modulation_entry *_matrix, unsigned int _rows, const char **_src_names, const char **_dest_names);
public:
virtual const table_column_info *get_table_columns(int param) const;
virtual uint32_t get_table_rows(int param) const;
virtual std::string get_cell(int param, int row, int column) const;
virtual void set_cell(int param, int row, int column, const std::string &src, std::string &error) const;
virtual const table_column_info *get_table_columns() const;
virtual uint32_t get_table_rows() const;
virtual std::string get_cell(int row, int column) const;
virtual void set_cell(int row, int column, const std::string &src, std::string &error);
/// Process modulation matrix, calculate outputs from inputs
inline void calculate_modmatrix(float *moddest, int moddest_count, float *modsrc)

4
plugins/ladspa_effect/calf/src/calf/modules_eq.h
View File

@@ -28,6 +28,7 @@
#include "audio_fx.h"
#include "giface.h"
#include "metadata.h"
#include "plugin_tools.h"
namespace calf_plugins {
@@ -51,8 +52,7 @@ private:
float hs_level_old, hs_freq_old;
float p_level_old[PeakBands], p_freq_old[PeakBands], p_q_old[PeakBands];
mutable float old_params_for_graph[graph_param_count];
uint32_t clip_inL, clip_outL, clip_inR, clip_outR;
float meter_inL, meter_outL, meter_inR, meter_outR;
dual_in_out_metering<BaseClass> meters;
CalfEqMode hp_mode, lp_mode;
dsp::biquad_d2<float> hp[3][2], lp[3][2];
dsp::biquad_d2<float> lsL, lsR, hsL, hsR;

4
plugins/ladspa_effect/calf/src/calf/modules_synths.h
View File

@@ -88,6 +88,8 @@ public:
int32_t last_stretch1;
/// Next note to play on the next calculate_step
int queue_note_on;
/// Whether the queued note has been already released
bool queue_note_on_and_off;
/// Velocity of the next note to play
float queue_vel;
/// Integer value for modwheel (0-16383, read from CC1 - MSBs and CC33 - LSBs)
@@ -122,6 +124,8 @@ public:
static void precalculate_waves(progress_report_iface *reporter);
void set_sample_rate(uint32_t sr);
void delayed_note_on();
/// Release a note (physically), called from note-off handler or when note-off has been scheduled after note-on (very short queued note)
void end_note();
/// Handle MIDI Note On message (does not immediately trigger a note, as it must start on
/// boundary of step_size samples).
void note_on(int note, int vel);

57
plugins/ladspa_effect/calf/src/calf/plugin_tools.h
View File

@@ -28,12 +28,12 @@
namespace calf_plugins {
/// Base class for universal stereo level metering
struct stereo_in_out_metering_base
template<class Meter>
struct in_out_metering_base
{
dsp::vumeter vumeter_in, vumeter_out;
stereo_in_out_metering_base()
typedef Meter meter;
meter vumeter_in, vumeter_out;
in_out_metering_base()
{
reset();
}
@@ -44,9 +44,9 @@ struct stereo_in_out_metering_base
}
};
/// Universal stereo level metering for a specific plugin
/// Universal single stereo level metering for a specific plugin
template<class Metadata>
class stereo_in_out_metering: public stereo_in_out_metering_base
class stereo_in_out_metering: public in_out_metering_base<dsp::vumeter>
{
public:
inline void process(float *const *params, const float *const *inputs, const float *const *outputs, unsigned int offset, unsigned int nsamples)
@@ -79,6 +79,49 @@ public:
}
};
/// Universal dual level metering for a specific plugin
template<class Metadata>
class dual_in_out_metering: public in_out_metering_base<dsp::dual_vumeter>
{
public:
inline void process(float *const *params, const float *const *inputs, const float *const *outputs, unsigned int offset, unsigned int nsamples)
{
if (params[Metadata::param_meter_inL] || params[Metadata::param_clip_inL] || params[Metadata::param_meter_inR] || params[Metadata::param_clip_inR]) {
if (inputs)
vumeter_in.update_stereo(inputs[0] ? inputs[0] + offset : NULL, inputs[1] ? inputs[1] + offset : NULL, nsamples);
else
vumeter_in.update_zeros(nsamples);
if (params[Metadata::param_meter_inL])
*params[Metadata::param_meter_inL] = vumeter_in.left.level;
if (params[Metadata::param_meter_inR])
*params[Metadata::param_meter_inR] = vumeter_in.right.level;
if (params[Metadata::param_clip_inL])
*params[Metadata::param_clip_inL] = vumeter_in.left.clip > 0 ? 1.f : 0.f;
if (params[Metadata::param_clip_inR])
*params[Metadata::param_clip_inR] = vumeter_in.right.clip > 0 ? 1.f : 0.f;
}
if (params[Metadata::param_meter_outL] || params[Metadata::param_clip_outL] || params[Metadata::param_meter_outR] || params[Metadata::param_clip_outR]) {
if (outputs)
vumeter_out.update_stereo(outputs[0] ? outputs[0] + offset : NULL, outputs[1] ? outputs[1] + offset : NULL, nsamples);
else
vumeter_out.update_zeros(nsamples);
if (params[Metadata::param_meter_outL])
*params[Metadata::param_meter_outL] = vumeter_out.left.level;
if (params[Metadata::param_meter_outR])
*params[Metadata::param_meter_outR] = vumeter_out.right.level;
if (params[Metadata::param_clip_outL])
*params[Metadata::param_clip_outL] = vumeter_out.left.clip > 0 ? 1.f : 0.f;
if (params[Metadata::param_clip_outR])
*params[Metadata::param_clip_outR] = vumeter_out.right.clip > 0 ? 1.f : 0.f;
}
}
void bypassed(float *const *params, unsigned int nsamples)
{
reset();
process(params, NULL, NULL, 0, nsamples);
}
};
};
#endif

21
plugins/ladspa_effect/calf/src/calf/vumeter.h
View File

@@ -90,6 +90,27 @@ struct vumeter
}
};
struct dual_vumeter
{
vumeter left, right;
inline void update_stereo(const float *src1, const float *src2, unsigned int len)
{
left.update_stereo(src1, NULL, len);
right.update_stereo(NULL, src2, len);
}
inline void update_zeros(unsigned int len)
{
left.update_zeros(len);
right.update_zeros(len);
}
inline void reset()
{
left.reset();
right.reset();
}
};
};
#endif

89
plugins/ladspa_effect/calf/src/giface.cpp
View File

@@ -150,8 +150,6 @@ std::string parameter_properties::to_string(float value) const
}
switch(flags & PF_TYPEMASK)
{
case PF_STRING:
return "N/A";
case PF_INT:
case PF_BOOL:
case PF_ENUM:
@@ -190,15 +188,16 @@ std::string parameter_properties::to_string(float value) const
void calf_plugins::plugin_ctl_iface::clear_preset() {
int param_count = get_metadata_iface()->get_param_count();
for (int i=0; i < param_count; i++)
for (int i = 0; i < param_count; i++)
{
const parameter_properties &pp = *get_metadata_iface()->get_param_props(i);
if ((pp.flags & PF_TYPEMASK) == PF_STRING)
{
configure(pp.short_name, pp.choices ? pp.choices[0] : "");
}
else
set_param_value(i, pp.def_value);
set_param_value(i, pp.def_value);
}
const char *const *vars = get_metadata_iface()->get_configure_vars();
if (vars)
{
for (int i = 0; vars[i]; i++)
configure(vars[i], NULL);
}
}
@@ -215,28 +214,6 @@ const char *calf_plugins::load_gui_xml(const std::string &plugin_id)
}
}
bool calf_plugins::check_for_message_context_ports(const parameter_properties *parameters, int count)
{
for (int i = count - 1; i >= 0; i--)
{
if (parameters[i].flags & PF_PROP_MSGCONTEXT)
return true;
}
return false;
}
bool calf_plugins::check_for_string_ports(const parameter_properties *parameters, int count)
{
for (int i = count - 1; i >= 0; i--)
{
if ((parameters[i].flags & PF_TYPEMASK) == PF_STRING)
return true;
if ((parameters[i].flags & PF_TYPEMASK) < PF_STRING)
return false;
}
return false;
}
bool calf_plugins::get_freq_gridline(int subindex, float &pos, bool &vertical, std::string &legend, cairo_iface *context, bool use_frequencies)
{
if (subindex < 0 )
@@ -344,7 +321,7 @@ const plugin_metadata_iface *calf_plugins::plugin_registry::get_by_id(const char
}
///////////////////////////////////////////////////////////////////////////////////////
std::string table_edit_iface::get_cell(int param, int row, int column) const
std::string table_edit_iface::get_cell(int row, int column) const
{
return calf_utils::i2s(row)+":"+calf_utils::i2s(column);
}
@@ -453,4 +430,52 @@ calf_plugins::dssi_feedback_sender::~dssi_feedback_sender()
delete client;
}
table_via_configure::table_via_configure()
{
rows = 0;
}
const table_column_info *table_via_configure::get_table_columns() const
{
return &columns[0];
}
uint32_t table_via_configure::get_table_rows() const
{
return rows;
}
string table_via_configure::get_cell(int row, int column) const
{
if (row >= rows)
return string();
coord c = make_pair(row, column);
std::map<coord, std::string>::const_iterator i = values.find(c);
if (i == values.end())
return std::string();
else
return i->second;
}
void table_via_configure::set_cell(int row, int column, const std::string &src, std::string &error)
{
coord c = make_pair(row, column);
values[c] = src;
error = "";
}
const line_graph_iface *table_via_configure::get_graph_iface(int column) const
{
return NULL;
}
const char *table_via_configure::get_cell_editor(int column) const
{
return NULL;
}
table_via_configure::~table_via_configure()
{
}
#endif

16
plugins/ladspa_effect/calf/src/metadata.cpp
View File

@@ -950,10 +950,14 @@ CALF_PORT_PROPS(organ) = {
{ 1, 0.1, 10, 0, PF_FLOAT | PF_SCALE_GAIN | PF_CTL_KNOB | PF_UNIT_COEF | PF_PROP_NOBOUNDS, NULL, "bass_gain", "Bass Gain" },
{ 12000, 20, 20000, 0, PF_FLOAT | PF_SCALE_LOG | PF_CTL_KNOB | PF_UNIT_HZ, NULL, "treble_freq", "Treble Freq" },
{ 1, 0.1, 10, 0, PF_FLOAT | PF_SCALE_GAIN | PF_CTL_KNOB | PF_UNIT_COEF | PF_PROP_NOBOUNDS, NULL, "treble_gain", "Treble Gain" },
{ 0, 0, 0, 0, PF_STRING | PF_PROP_MSGCONTEXT, &organ_init_map_curve, "map_curve", "Key mapping curve" },
};
const char *const *organ_metadata::get_configure_vars() const
{
static const char *names[] = {"map_curve", NULL};
return names;
}
////////////////////////////////////////////////////////////////////////////
const char *fluidsynth_init_soundfont = "";
@@ -972,10 +976,14 @@ CALF_PORT_PROPS(fluidsynth) = {
{ 2, 0, 3, 0, PF_ENUM | PF_CTL_COMBO, fluidsynth_interpolation_names, "interpolation", "Interpolation" },
{ 1, 0, 1, 0, PF_BOOL | PF_CTL_TOGGLE, NULL, "reverb", "Reverb" },
{ 1, 0, 1, 0, PF_BOOL | PF_CTL_TOGGLE, NULL, "chorus", "Chorus" },
{ 0, 0, 0, 0, PF_STRING | PF_PROP_MSGCONTEXT, &fluidsynth_init_soundfont, "soundfont", "Soundfont" },
{ 0, 0, 0, 0, PF_STRING | PF_PROP_MSGCONTEXT, &fluidsynth_init_presetkeyset, "preset_key_set", "Set Preset" },
};
const char *const *fluidsynth_metadata::get_configure_vars() const
{
static const char *names[] = {"soundfont", "preset_key_set", NULL};
return names;
}
////////////////////////////////////////////////////////////////////////////
const char *wavetable_names[] = {

8
plugins/ladspa_effect/calf/src/modmatrix.cpp
View File

@@ -60,17 +60,17 @@ mod_matrix::mod_matrix(modulation_entry *_matrix, unsigned int _rows, const char
matrix[i].reset();
}
const table_column_info *mod_matrix::get_table_columns(int param) const
const table_column_info *mod_matrix::get_table_columns() const
{
return table_columns;
}
uint32_t mod_matrix::get_table_rows(int param) const
uint32_t mod_matrix::get_table_rows() const
{
return matrix_rows;
}
std::string mod_matrix::get_cell(int param, int row, int column) const
std::string mod_matrix::get_cell(int row, int column) const
{
assert(row >= 0 && row < (int)matrix_rows);
modulation_entry &slot = matrix[row];
@@ -91,7 +91,7 @@ std::string mod_matrix::get_cell(int param, int row, int column) const
}
}
void mod_matrix::set_cell(int param, int row, int column, const std::string &src, std::string &error) const
void mod_matrix::set_cell(int row, int column, const std::string &src, std::string &error)
{
assert(row >= 0 && row < (int)matrix_rows);
modulation_entry &slot = matrix[row];

2
plugins/ladspa_effect/calf/src/modules_dist.cpp
View File

@@ -26,8 +26,6 @@
using namespace dsp;
using namespace calf_plugins;
#define SET_IF_CONNECTED(name) if (params[AM::param_##name] != NULL) *params[AM::param_##name] = name;
/// Saturator Band by Markus Schmidt
///
/// This module is based on Krzysztof's filters and Tom Szilagyi's distortion routine.

59
plugins/ladspa_effect/calf/src/modules_eq.cpp
View File

@@ -26,8 +26,6 @@
using namespace dsp;
using namespace calf_plugins;
#define SET_IF_CONNECTED(name) if (params[AM::param_##name] != NULL) *params[AM::param_##name] = name;
/// Equalizer 12 Band by Markus Schmidt
///
/// This module is based on Krzysztof's filters. It provides a couple
@@ -40,8 +38,6 @@ equalizerNband_audio_module<BaseClass, has_lphp>::equalizerNband_audio_module()
is_active = false;
srate = 0;
last_generation = 0;
clip_inL = clip_inR = clip_outL = clip_outR = 0.f;
meter_inL = meter_inR = meter_outL = meter_outR = 0.f;
}
template<class BaseClass, bool has_lphp>
@@ -50,6 +46,7 @@ void equalizerNband_audio_module<BaseClass, has_lphp>::activate()
is_active = true;
// set all filters
params_changed();
meters.reset();
}
template<class BaseClass, bool has_lphp>
@@ -170,6 +167,8 @@ template<class BaseClass, bool has_lphp>
uint32_t equalizerNband_audio_module<BaseClass, has_lphp>::process(uint32_t offset, uint32_t numsamples, uint32_t inputs_mask, uint32_t outputs_mask)
{
bool bypass = *params[AM::param_bypass] > 0.f;
uint32_t orig_offset = offset;
uint32_t orig_numsamples = numsamples;
numsamples += offset;
if(bypass) {
// everything bypassed
@@ -179,19 +178,8 @@ uint32_t equalizerNband_audio_module<BaseClass, has_lphp>::process(uint32_t offs
++offset;
}
// displays, too
clip_inL = clip_inR = clip_outL = clip_outR = 0.f;
meter_inL = meter_inR = meter_outL = meter_outR = 0.f;
meters.bypassed(params, orig_numsamples);
} else {
clip_inL -= std::min(clip_inL, numsamples);
clip_inR -= std::min(clip_inR, numsamples);
clip_outL -= std::min(clip_outL, numsamples);
clip_outR -= std::min(clip_outR, numsamples);
meter_inL = 0.f;
meter_inR = 0.f;
meter_outL = 0.f;
meter_outR = 0.f;
// process
while(offset < numsamples) {
// cycle through samples
@@ -230,37 +218,11 @@ uint32_t equalizerNband_audio_module<BaseClass, has_lphp>::process(uint32_t offs
// send to output
outs[0][offset] = outL;
outs[1][offset] = outR;
// clip LED's
if(inL > 1.f) {
clip_inL = srate >> 3;
}
if(inR > 1.f) {
clip_inR = srate >> 3;
}
if(outL > 1.f) {
clip_outL = srate >> 3;
}
if(outR > 1.f) {
clip_outR = srate >> 3;
}
// set up in / out meters
if(inL > meter_inL) {
meter_inL = inL;
}
if(inR > meter_inR) {
meter_inR = inR;
}
if(outL > meter_outL) {
meter_outL = outL;
}
if(outR > meter_outR) {
meter_outR = outR;
}
// next sample
++offset;
} // cycle trough samples
meters.process(params, ins, outs, orig_offset, orig_numsamples);
// clean up
for(int i = 0; i < 3; ++i) {
hp[i][0].sanitize();
@@ -275,15 +237,6 @@ uint32_t equalizerNband_audio_module<BaseClass, has_lphp>::process(uint32_t offs
pR[i].sanitize();
}
}
// draw meters
SET_IF_CONNECTED(clip_inL)
SET_IF_CONNECTED(clip_inR)
SET_IF_CONNECTED(clip_outL)
SET_IF_CONNECTED(clip_outR)
SET_IF_CONNECTED(meter_inL)
SET_IF_CONNECTED(meter_inR)
SET_IF_CONNECTED(meter_outL)
SET_IF_CONNECTED(meter_outR)
// whatever has to be returned x)
return outputs_mask;
}

55
plugins/ladspa_effect/calf/src/monosynth.cpp
View File

@@ -76,6 +76,7 @@ void monosynth_audio_module::activate() {
stack.clear();
last_pwshift1 = last_pwshift2 = 0;
last_stretch1 = 65536;
queue_note_on_and_off = false;
}
waveform_family<MONOSYNTH_WAVE_BITS> *monosynth_audio_module::waves;
@@ -433,6 +434,12 @@ void monosynth_audio_module::delayed_note_on()
queue_note_on = -1;
float modsrc[modsrc_count] = { 1, velocity, inertia_pressure.get_last(), modwheel_value, envelope1.value, envelope2.value, 0.5+0.5*lfo1.last, 0.5+0.5*lfo2.last};
calculate_modmatrix(moddest, moddest_count, modsrc);
if (queue_note_on_and_off)
{
end_note();
queue_note_on_and_off = false;
}
}
void monosynth_audio_module::set_sample_rate(uint32_t sr) {
@@ -629,6 +636,7 @@ void monosynth_audio_module::apply_fadeout()
void monosynth_audio_module::note_on(int note, int vel)
{
queue_note_on = note;
queue_note_on_and_off = false;
last_key = note;
queue_vel = vel / 127.f;
stack.push(note);
@@ -637,29 +645,40 @@ void monosynth_audio_module::note_on(int note, int vel)
void monosynth_audio_module::note_off(int note, int vel)
{
stack.pop(note);
if (note == queue_note_on)
{
queue_note_on_and_off = true;
return;
}
// If releasing the currently played note, try to get another one from note stack.
if (note == last_key) {
if (stack.count())
{
last_key = note = stack.nth(stack.count() - 1);
start_freq = freq;
target_freq = freq = dsp::note_to_hz(note);
porta_time = 0;
set_frequency();
if (!(legato & 1)) {
envelope1.note_on();
envelope2.note_on();
stopping = false;
running = true;
}
return;
}
gate = false;
envelope1.note_off();
envelope2.note_off();
end_note();
}
}
void monosynth_audio_module::end_note()
{
if (stack.count())
{
int note;
last_key = note = stack.nth(stack.count() - 1);
start_freq = freq;
target_freq = freq = dsp::note_to_hz(note);
porta_time = 0;
set_frequency();
if (!(legato & 1)) {
envelope1.note_on();
envelope2.note_on();
stopping = false;
running = true;
}
return;
}
gate = false;
envelope1.note_off();
envelope2.note_off();
}
void monosynth_audio_module::channel_pressure(int value)
{
inertia_pressure.set_inertia(value * (1.0 / 127.0));

2
plugins/ladspa_effect/calf/src/organ.cpp
View File

@@ -950,6 +950,8 @@ char *organ_audio_module::configure(const char *key, const char *value)
{
if (!strcmp(key, "map_curve"))
{
if (!value)
value = "2\n0 1\n1 1\n";
var_map_curve = value;
stringstream ss(value);
int i = 0;

17
plugins/ladspa_effect/calf/src/plugin.cpp
View File

@@ -58,7 +58,7 @@ ladspa_instance::ladspa_instance(audio_module_iface *_module, ladspa_plugin_meta
float ladspa_instance::get_param_value(int param_no)
{
// XXXKF hack
if (param_no >= ladspa->real_param_count)
if (param_no >= ladspa->param_count)
return 0;
return *params[param_no];
}
@@ -66,7 +66,7 @@ float ladspa_instance::get_param_value(int param_no)
void ladspa_instance::set_param_value(int param_no, float value)
{
// XXXKF hack
if (param_no >= ladspa->real_param_count)
if (param_no >= ladspa->param_count)
return;
*params[param_no] = value;
}
@@ -231,7 +231,7 @@ static void cb_connect(LADSPA_Handle Instance, unsigned long port, LADSPA_Data *
int first_out = mod->ladspa->input_count;
int first_param = first_out + mod->ladspa->output_count;
int ladspa_port_count = first_param + mod->ladspa->real_param_count;
int ladspa_port_count = first_param + mod->ladspa->param_count;
if ((int)port < first_out)
mod->ins[port] = DataLocation;
@@ -292,7 +292,7 @@ static void cb_select_program(LADSPA_Handle Instance, unsigned long Bank, unsign
unsigned int no = (Bank << 7) + Program - 1;
// printf("no = %d presets = %p:%d\n", no, presets, presets->size());
if (no == -1U) {
int rpc = ladspa->real_param_count;
int rpc = ladspa->param_count;
for (int i =0 ; i < rpc; i++)
*mod->params[i] = mod->metadata->get_param_props(i)->def_value;
return;
@@ -328,9 +328,6 @@ void ladspa_plugin_metadata_set::prepare(const plugin_metadata_iface *md, LADSPA
input_count = md->get_input_count();
output_count = md->get_output_count();
param_count = md->get_param_count(); // XXXKF ladspa_instance<Module>::real_param_count();
real_param_count = 0;
while(real_param_count < md->get_param_count() && (metadata->get_param_props(real_param_count)->flags & PF_TYPEMASK) < PF_STRING)
real_param_count++;
const ladspa_plugin_info &plugin_info = md->get_plugin_info();
descriptor.UniqueID = plugin_info.unique_id;
@@ -339,7 +336,7 @@ void ladspa_plugin_metadata_set::prepare(const plugin_metadata_iface *md, LADSPA
descriptor.Maker = plugin_info.maker;
descriptor.Copyright = plugin_info.copyright;
descriptor.Properties = md->is_rt_capable() ? LADSPA_PROPERTY_HARD_RT_CAPABLE : 0;
descriptor.PortCount = input_count + output_count + real_param_count;
descriptor.PortCount = input_count + output_count + param_count;
descriptor.PortNames = new char *[descriptor.PortCount];
descriptor.PortDescriptors = new LADSPA_PortDescriptor[descriptor.PortCount];
descriptor.PortRangeHints = new LADSPA_PortRangeHint[descriptor.PortCount];
@@ -352,7 +349,7 @@ void ladspa_plugin_metadata_set::prepare(const plugin_metadata_iface *md, LADSPA
prh.HintDescriptor = 0;
((const char **)descriptor.PortNames)[i] = md->get_port_names()[i];
}
for (; i < input_count + output_count + real_param_count; i++)
for (; i < input_count + output_count + param_count; i++)
{
LADSPA_PortRangeHint &prh = ((LADSPA_PortRangeHint *)descriptor.PortRangeHints)[i];
const parameter_properties &pp = *md->get_param_props(i - input_count - output_count);
@@ -484,7 +481,7 @@ ladspa_plugin_metadata_set::~ladspa_plugin_metadata_set()
// instantiate descriptor templates
template<class Module> LV2_Descriptor calf_plugins::lv2_wrapper<Module>::descriptor;
template<class Module> LV2_Calf_Descriptor calf_plugins::lv2_wrapper<Module>::calf_descriptor;
template<class Module> LV2MessageContext calf_plugins::lv2_wrapper<Module>::message_context;
template<class Module> LV2_Persist calf_plugins::lv2_wrapper<Module>::persist;
extern "C" {