giface.h

Go to the documentation of this file.

/* Calf DSP Library
 * Common plugin interface definitions (shared between LADSPA/LV2/DSSI/standalone).
 *
 * Copyright (C) 2007-2010 Krzysztof Foltman
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General
 * Public License along with this program; if not, write to the
 * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02111-1307, USA.
 */
#ifndef CALF_GIFACE_H
#define CALF_GIFACE_H
 
#include <config.h>
#include "primitives.h"
#include <complex>
#include <exception>
#include <string>
#include <vector>
 
namespace osctl {
    struct osc_client;
}
 
namespace calf_plugins {
 
enum {
    MAX_SAMPLE_RUN = 256
};
 
struct automation_range;

enum parameter_flags
{
  PF_TYPEMASK = 0x000F, 
  PF_FLOAT = 0x0000, 
  PF_INT = 0x0001,   
  PF_BOOL = 0x0002,  
  PF_ENUM = 0x0003,  
  PF_ENUM_MULTI = 0x0004, 
 
  PF_SCALEMASK = 0xF0, 
  PF_SCALE_DEFAULT = 0x00, 
  PF_SCALE_LINEAR = 0x10, 
  PF_SCALE_LOG = 0x20, 
  PF_SCALE_GAIN = 0x30, 
  PF_SCALE_PERC = 0x40, 
  PF_SCALE_QUAD = 0x50, 
  PF_SCALE_LOG_INF = 0x60, 
 
  PF_CTLMASK =        0x000F00, 
  PF_CTL_DEFAULT =    0x000000, 
  PF_CTL_KNOB =       0x000100, 
  PF_CTL_FADER =      0x000200, 
  PF_CTL_TOGGLE =     0x000300, 
  PF_CTL_COMBO =      0x000400, 
  PF_CTL_RADIO =      0x000500, 
  PF_CTL_BUTTON =     0x000600, 
  PF_CTL_METER  =     0x000700, 
  PF_CTL_LED    =     0x000800, 
  PF_CTL_LABEL  =     0x000900, 
 
  PF_CTLOPTIONS     = 0x00F000, 
  PF_CTLO_HORIZ     = 0x001000, 
  PF_CTLO_VERT      = 0x002000, 
  PF_CTLO_LABEL     = 0x004000, 
  PF_CTLO_REVERSE   = 0x008000, 
 
  PF_PROP_MASK     =  0x3F0000, 
  PF_PROP_NOBOUNDS =  0x010000, 
  PF_PROP_EXPENSIVE = 0x020000, 
  PF_PROP_OUTPUT_GAIN=0x040000, 
  PF_PROP_OPTIONAL  = 0x080000, 
  PF_PROP_GRAPH     = 0x100000, 
  PF_PROP_OUTPUT    = 0x200000, 
 
  PF_UNITMASK     = 0x0F000000,  
  PF_UNIT_DB      = 0x01000000,  
  PF_UNIT_DBFS      = 0x0E000000,  
  PF_UNIT_COEF    = 0x02000000,  
  PF_UNIT_HZ      = 0x03000000,  
  PF_UNIT_SEC     = 0x04000000,  
  PF_UNIT_MSEC    = 0x05000000,  
  PF_UNIT_CENTS   = 0x06000000,  
  PF_UNIT_SEMITONES = 0x07000000,
  PF_UNIT_BPM     = 0x08000000,  
  PF_UNIT_DEG     = 0x09000000,  
  PF_UNIT_NOTE    = 0x0A000000,  
  PF_UNIT_RPM     = 0x0B000000,  
  PF_UNIT_SAMPLES = 0x0C000000,  
 
  PF_SYNC_BPM     = 0x10000000, 
 
  PF_DIGITMASK    = 0xE0000000,
  PF_DIGIT_0      = 0x20000000,
  PF_DIGIT_1      = 0x40000000,
  PF_DIGIT_2      = 0x60000000,
  PF_DIGIT_3      = 0x80000000,
  PF_DIGIT_ALL    = 0xA0000000,
};

#define FAKE_INFINITY (65536.0 * 65536.0)
#define IS_FAKE_INFINITY(value) (fabs(value-FAKE_INFINITY) < 1.0)

struct plugin_command_info
{
    const char *label;           
    const char *name;            
    const char *description;     
};

struct parameter_properties
{
    float def_value;
    float min;
    float max;
    float step;
    uint32_t flags;
    const char **choices;
    const char *short_name;
    const char *name;
    float from_01(double value01) const;
    double to_01(float value) const;
    std::string to_string(float value) const;
    float string_to_value(const char* string) const;
    int get_char_count() const;
    float get_increment() const;
};
 
struct cairo_iface
{
    int size_x, size_y, pad_x, pad_y;
    virtual void set_source_rgba(float r, float g, float b, float a = 1.f) = 0;
    virtual void set_line_width(float width) = 0;
    virtual void set_dash(const double *dash, int length) = 0;
    virtual void draw_label(const char *label, float x, float y, int pos, float margin, float align) = 0;
    virtual ~cairo_iface() {}
};
 
struct progress_report_iface
{
    virtual void report_progress(float percentage, const std::string &message) = 0;
    virtual ~progress_report_iface() {}
};

enum layers_flags {
    LG_NONE            = 0x000000,
    LG_CACHE_GRID      = 0x000001,
    LG_REALTIME_GRID   = 0x000002,
    LG_CACHE_GRAPH     = 0x000004,
    LG_REALTIME_GRAPH  = 0x000008,
    LG_CACHE_DOT       = 0x000010,
    LG_REALTIME_DOT    = 0x000020,
    LG_CACHE_MOVING    = 0x000040,
    LG_REALTIME_MOVING = 0x000080
};

enum moving_directions {
    LG_MOVING_LEFT     = 0x000000,
    LG_MOVING_RIGHT    = 0x000001,
    LG_MOVING_UP       = 0x000002,
    LG_MOVING_DOWN     = 0x000004
};

struct line_graph_iface
{
    virtual bool get_graph(int index, int subindex, int phase, float *data, int points, cairo_iface *context, int *mode = 0) const { return false; }

    virtual bool get_moving(int index, int subindex, int &direction, float *data, int x, int y, int &offset, uint32_t &color) const { return false; }

    virtual bool get_dot(int index, int subindex, int phase, float &x, float &y, int &size, cairo_iface *context) const { return false; }

    virtual bool get_gridline(int index, int subindex, int phase, float &pos, bool &vertical, std::string &legend, cairo_iface *context) const { return false; }

    virtual bool get_layers(int index, int generation, unsigned int &layers) const { return false; }

    virtual std::string get_crosshair_label( int x, int y, int sx, int sy, float q, int dB, int name, int note, int cents) const { std::string s = ""; return s; }

    virtual ~line_graph_iface() {}
};

struct phase_graph_iface
{
    virtual bool get_phase_graph(int index, float ** _buffer, int *_length, int * _mode, bool * _use_fade, float * _fade, int * _accuracy, bool * _display) const { return false; };
    virtual ~phase_graph_iface() {}
};
 
enum table_column_type
{
    TCT_UNKNOWN, 
    TCT_FLOAT, 
    TCT_ENUM, 
    TCT_STRING, 
    TCT_OBJECT, 
    TCT_LABEL, 
};

struct table_column_info
{
    const char *name; 
    table_column_type type; 
    float min; 
    float max; 
    float def_value; 
    const char **values; 
};

struct table_metadata_iface
{
    virtual const table_column_info *get_table_columns() const = 0;

    virtual uint32_t get_table_rows() const = 0;
 
    virtual ~table_metadata_iface() {}
};

struct send_configure_iface
{
    virtual void send_configure(const char *key, const char *value) = 0;
 
    virtual ~send_configure_iface() {}
};

struct send_updates_iface
{
    virtual void send_status(const char *key, const char *value) = 0;
 
    virtual ~send_updates_iface() {}
};
 
struct plugin_command_info;

struct ladspa_plugin_info
{
    uint32_t unique_id;
    const char *label;
    const char *name;
    const char *maker;
    const char *copyright;
    const char *plugin_type;
};

struct plugin_metadata_iface
{
    enum { simulate_stereo_input = true, has_live_updates = true };
    virtual const char *get_name() const = 0;
    virtual const char *get_id() const = 0;
    virtual const char *get_label() const = 0;
    virtual int get_param_count() const = 0;
    virtual char *get_gui_xml(const char *prefix) const = 0;
    virtual int get_input_count() const =0;
    virtual int get_output_count() const =0;
    virtual int get_inputs_optional() const =0;
    virtual int get_outputs_optional() const =0;
    virtual bool is_rt_capable() const =0;
    virtual bool get_midi() const =0;
    virtual bool requires_midi() const =0;
    virtual bool requires_instance_access() const =0;
    virtual int get_param_port_offset() const  = 0;
    virtual plugin_command_info *get_commands() const { return NULL; }
    virtual const parameter_properties *get_param_props(int param_no) const = 0;
    virtual const char **get_port_names() const = 0;
    virtual const ladspa_plugin_info &get_plugin_info() const = 0;
    virtual bool is_cv(int param_no) const = 0;
    virtual bool is_noisy(int param_no) const = 0;
    virtual void get_configure_vars(std::vector<std::string> &names) const { names.clear(); }
    virtual const table_metadata_iface *get_table_metadata_iface(const char *key) const { return NULL; }
    virtual bool get_simulate_stereo_input() const = 0;
    virtual bool sends_live_updates() const = 0;

    virtual ~plugin_metadata_iface() {}
};

struct plugin_ctl_iface
{
    virtual float get_param_value(int param_no) = 0;
    virtual void set_param_value(int param_no, float value) = 0;
    virtual bool activate_preset(int bank, int program) = 0;
    virtual float get_level(unsigned int port)=0;
    virtual void execute(int cmd_no)=0;
    virtual char *configure(const char *key, const char *value) = 0;
    virtual void send_configures(send_configure_iface *)=0;
    virtual void clear_preset();
    virtual bool blobcall(const char *command, const std::string &request, std::string &result) { result = "Call not supported"; return false; }
    virtual int send_status_updates(send_updates_iface *sui, int last_serial) = 0;
    virtual const plugin_metadata_iface *get_metadata_iface() const = 0;
    virtual const line_graph_iface *get_line_graph_iface() const = 0;
    virtual const phase_graph_iface *get_phase_graph_iface() const = 0;
    virtual int get_write_serial(int param_no) { return 0; }

    virtual void add_automation(uint32_t source, const automation_range &dest) {}
    virtual void delete_automation(uint32_t source, int param_no) {}
    virtual void get_automation(int param_no, std::multimap<uint32_t, automation_range> &dests) {}
    virtual uint32_t get_last_automation_source() { return 0xFFFFFFFF; }
    virtual void send_automation_configures(send_configure_iface *) {}
    virtual ~plugin_ctl_iface() {}
};
 
struct plugin_list_info_iface;

class plugin_registry
{
public:
    typedef std::vector<const plugin_metadata_iface *> plugin_vector;
private:
    plugin_vector plugins;
    plugin_registry();
public:
    static plugin_registry &instance();

    const plugin_vector &get_all() { return plugins; }
    const plugin_metadata_iface *get_by_uri(const char *URI);
    const plugin_metadata_iface *get_by_id(const char *id, bool case_sensitive = false);
};

extern char *load_gui_xml(const std::string &plugin_id);

struct audio_module_iface
{
    virtual void note_on(int channel, int note, int velocity) = 0;
    virtual void note_off(int channel, int note, int velocity) = 0;
    virtual void program_change(int channel, int program) = 0;
    virtual void control_change(int channel, int controller, int value) = 0;
    virtual void pitch_bend(int channel, int value) = 0;
    virtual void channel_pressure(int channel, int value) = 0;
    virtual void params_changed() = 0;
    virtual void activate() = 0;
    virtual void deactivate() = 0;
    virtual void set_sample_rate(uint32_t sr) = 0;
    virtual void execute(int cmd_no) = 0;
    virtual char *configure(const char *key, const char *value) = 0;
    virtual void send_configures(send_configure_iface *sci) = 0;
    virtual int send_status_updates(send_updates_iface *sui, int last_serial) = 0;
    virtual void params_reset() = 0;
    virtual void post_instantiate(uint32_t sample_rate) = 0;
    virtual void get_port_arrays(float **&ins_ptrs, float **&outs_ptrs, float **&params_ptrs) = 0;
    virtual const plugin_metadata_iface *get_metadata_iface() const = 0;
    virtual void set_progress_report_iface(progress_report_iface *iface) = 0;
    virtual uint32_t process_slice(uint32_t offset, uint32_t end) = 0;
    virtual uint32_t process(uint32_t offset, uint32_t numsamples, uint32_t inputs_mask, uint32_t outputs_mask) = 0;
    virtual uint32_t message_run(const void *valid_ports, void *output_ports) = 0;
    virtual const line_graph_iface *get_line_graph_iface() const = 0;
    virtual const phase_graph_iface *get_phase_graph_iface() const = 0;
    virtual ~audio_module_iface() {}
};

template<class Metadata>
class audio_module: public Metadata, public audio_module_iface
{
public:
    typedef Metadata metadata_type;
    using Metadata::in_count;
    using Metadata::out_count;
    using Metadata::param_count;
    float *ins[(Metadata::in_count != 0)  ? Metadata::in_count : 1];
    float *outs[(Metadata::out_count != 0) ? Metadata::out_count : 1];
    float *params[Metadata::param_count];
    bool questionable_data_reported_in;
    bool questionable_data_reported_out;
 
    progress_report_iface *progress_report;
 
    audio_module() {
        progress_report = NULL;
        memset(ins, 0, sizeof(ins));
        memset(outs, 0, sizeof(outs));
        memset(params, 0, sizeof(params));
        questionable_data_reported_in = false;
        questionable_data_reported_out = false;
    }

    void note_on(int channel, int note, int velocity) {}
    void note_off(int channel, int note, int velocity) {}
    void program_change(int channel, int program) {}
    void control_change(int channel, int controller, int value) {}
    void pitch_bend(int channel, int value) {}
    void channel_pressure(int channel, int value) {}
    void params_changed() {}
    void activate() {}
    void deactivate() {}
    void set_sample_rate(uint32_t sr) { }
    void execute(int cmd_no) {}
    virtual char *configure(const char *key, const char *value) { return NULL; }
    void send_configures(send_configure_iface *sci) {}
    int send_status_updates(send_updates_iface *sui, int last_serial) { return last_serial; }
    void params_reset() {}
    void post_instantiate(uint32_t) {}
    uint32_t message_run(const void *valid_ports, void *output_ports) {
        fprintf(stderr, "ERROR: message run not implemented\n");
        return 0;
    }

    virtual void get_port_arrays(float **&ins_ptrs, float **&outs_ptrs, float **&params_ptrs)
    {
        ins_ptrs = ins;
        outs_ptrs = outs;
        params_ptrs = params;
    }

    virtual const plugin_metadata_iface *get_metadata_iface() const { return this; }
    virtual void set_progress_report_iface(progress_report_iface *iface) { progress_report = iface; }

    inline void zero_by_mask(uint32_t mask, uint32_t offset, uint32_t nsamples)
    {
        for (int i=0; i<Metadata::out_count; i++) {
            if ((mask & (1 << i)) == 0) {
                dsp::zero(outs[i] + offset, nsamples);
            }
        }
    }

    uint32_t process_slice(uint32_t offset, uint32_t end)
    {
        bool had_errors = false;
        for (int i=0; i<Metadata::in_count; ++i) {
            float *indata = ins[i];
            if (indata) {
                float errval = 0;
                for (uint32_t j = offset; j < end; j++)
                {
                    if (!std::isfinite(indata[j]) || fabs(indata[j]) > 4294967296.0) {
                        errval = indata[j];
                        had_errors = true;
                    }
                }
                if (had_errors && !questionable_data_reported_in) {
                    fprintf(stderr, "Warning: Plugin %s got questionable value %f on its input %d\n", Metadata::get_name(), errval, i);
                    questionable_data_reported_in = true;
                }
            }
        }
        uint32_t total_out_mask = 0;
        while(offset < end)
        {
            uint32_t newend = std::min(offset + MAX_SAMPLE_RUN, end);
            uint32_t out_mask = !had_errors ? process(offset, newend - offset, -1, -1) : 0;
            total_out_mask |= out_mask;
            zero_by_mask(out_mask, offset, newend - offset);
            offset = newend;
        }
        for (int i=0; i<Metadata::out_count; ++i) {
            if (total_out_mask & (1 << i))
            {
                had_errors = false;
                float *outdata = outs[i];
                float errval = 0;
                for (uint32_t j = offset; j < end; j++)
                {
                    if (!std::isfinite(outdata[j]) || fabs(outdata[j]) > 4294967296.0) {
                        errval = outdata[j];
                        had_errors = true;
                    }
                }
                if (had_errors && !questionable_data_reported_out) {
                    fprintf(stderr, "Warning: Plugin %s generated questionable value %f on its output %d - this is most likely a bug in the plugin!\n", Metadata::get_name(), errval, i);
                    questionable_data_reported_out = true;
                }
                if (had_errors)
                    dsp::zero(outs[i] + offset, end - offset);
            }
        }
        return total_out_mask;
    }

    virtual const line_graph_iface *get_line_graph_iface() const { return dynamic_cast<const line_graph_iface *>(this); }
    virtual const phase_graph_iface *get_phase_graph_iface() const { return dynamic_cast<const phase_graph_iface *>(this); }
};
 
#if USE_EXEC_GUI || USE_DSSI
 
enum line_graph_item
{
    LGI_END = 0,
    LGI_GRAPH,
    LGI_SUBGRAPH,
    LGI_LEGEND,
    LGI_DOT,
    LGI_END_ITEM,
    LGI_SET_RGBA,
    LGI_SET_WIDTH,
};

struct dssi_feedback_sender
{
    osctl::osc_client *client;
    bool is_client_shared;
    bool quit;
    std::vector<int> indices;
    const calf_plugins::line_graph_iface *graph;

    const calf_plugins::phase_graph_iface *phase;

    dssi_feedback_sender(const char *URI, const line_graph_iface *_graph);
    dssi_feedback_sender(osctl::osc_client *_client, const line_graph_iface *_graph);
    void add_graphs(const calf_plugins::parameter_properties *props, int num_params);
    void update();
    ~dssi_feedback_sender();
};
#endif

template<class Metadata>
class plugin_metadata: public plugin_metadata_iface
{
public:
    static const char *port_names[];
    static parameter_properties param_props[];
    static ladspa_plugin_info plugin_info;
    typedef plugin_metadata<Metadata> metadata_class;
 
    // These below are stock implementations based on enums and static members in Metadata classes
    // they may be overridden to provide more interesting functionality
 
    const char *get_name() const { return Metadata::impl_get_name(); }
    const char *get_id() const { return Metadata::impl_get_id(); }
    const char *get_label() const { return Metadata::impl_get_label(); }
    int get_input_count() const { return Metadata::in_count; }
    int get_output_count() const { return Metadata::out_count; }
    int get_inputs_optional() const { return Metadata::ins_optional; }
    int get_outputs_optional() const { return Metadata::outs_optional; }
    int get_param_count() const { return Metadata::param_count; }
    bool get_midi() const { return Metadata::support_midi; }
    bool requires_midi() const { return Metadata::require_midi; }
    bool requires_instance_access() const { return Metadata::require_instance_access; }
    bool is_rt_capable() const { return Metadata::rt_capable; }
    int get_param_port_offset()  const { return Metadata::in_count + Metadata::out_count; }
    char *get_gui_xml(const char *prefix) const { char xmlf[64]; sprintf(xmlf, "%s/%s", prefix, get_id()); char *data_ptr = calf_plugins::load_gui_xml(xmlf); return data_ptr; }
    plugin_command_info *get_commands() const { return NULL; }
    const parameter_properties *get_param_props(int param_no) const { return &param_props[param_no]; }
    const char **get_port_names() const { return port_names; }
    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 get_simulate_stereo_input() const { return Metadata::simulate_stereo_input; }
    bool sends_live_updates() const { return Metadata::has_live_updates; }
};
 
#define CALF_PORT_NAMES(name) template<> const char *calf_plugins::plugin_metadata<name##_metadata>::port_names[]
#define CALF_PORT_PROPS(name) template<> parameter_properties calf_plugins::plugin_metadata<name##_metadata>::param_props[name##_metadata::param_count + 1]
#define CALF_PLUGIN_INFO(name) template<> calf_plugins::ladspa_plugin_info calf_plugins::plugin_metadata<name##_metadata>::plugin_info
#define PLUGIN_NAME_ID_LABEL(name, id, label) \
    static const char *impl_get_name() { return name; } \
    static const char *impl_get_id() { return id; } \
    static const char *impl_get_label() { return label; } \
 
extern const char *calf_copyright_info;
 
bool get_freq_gridline(int subindex, float &pos, bool &vertical, std::string &legend, cairo_iface *context, bool use_frequencies = true, float res = 256, float ofs = 0.4);

static inline float dB_grid(float amp, float res = 256, float ofs = 0.4)
{
    return log(amp) * (1.0 / log(res)) + ofs;
}
 
template<class Fx>
static bool get_graph(Fx &fx, int subindex, float *data, int points, float res = 256, float ofs = 0.4)
{
    for (int i = 0; i < points; i++)
    {
        //typedef std::complex<double> cfloat;
        double freq = 20.0 * pow (20000.0 / 20.0, i * 1.0 / points);
        data[i] = dB_grid(fx.freq_gain(subindex, freq), res, ofs);
    }
    return true;
}

static inline float dB_grid_inv(float pos, float res = 256, float ofs = 0.4)
{
    return pow(res, pos - ofs);
}

class frequency_response_line_graph: public line_graph_iface
{
public:
    mutable bool redraw_graph;
    virtual bool get_gridline(int index, int subindex, int phase, float &pos, bool &vertical, std::string &legend, cairo_iface *context) const;
    virtual bool get_graph(int index, int subindex, int phase, float *data, int points, cairo_iface *context, int *mode) const;
    virtual bool get_layers(int index, int generation, unsigned int &layers) const;
    virtual float freq_gain(int index, double freq) const { return 0; };
    virtual std::string get_crosshair_label( int x, int y, int sx, int sy, float q, int dB, int name, int note, int cents) const;
};
std::string frequency_crosshair_label(int x, int y, int sx, int sy, float q, int dB, int name, int note, int cents, double res = 256, double ofs = 0.4);
 

void set_channel_color(cairo_iface *context, int channel, float alpha = 0.6);
void set_channel_dash(cairo_iface *context, int channel);
void draw_cairo_label(cairo_iface *context, const char *label, float x, float y, int pos, float margin, float align);
 
struct preset_access_iface
{
    virtual void store_preset() = 0;
    virtual void activate_preset(int preset, bool builtin) = 0;
    virtual ~preset_access_iface() {}
};

class mod_matrix_metadata: public table_metadata_iface
{
public:
    enum mapping_mode {
        map_positive, 
        map_bipolar, 
        map_negative, 
        map_squared, 
        map_squared_bipolar, 
        map_antisquared, 
        map_antisquared_bipolar, 
        map_parabola, 
        map_type_count
    };
    const char **mod_src_names, **mod_dest_names;
 
    mod_matrix_metadata(unsigned int _rows, const char **_src_names, const char **_dest_names);
    virtual const table_column_info *get_table_columns() const;
    virtual uint32_t get_table_rows() const;
    void get_configure_vars(std::vector<std::string> &names) const;
 
protected:
    table_column_info table_columns[6];
 
    unsigned int matrix_rows;
};

extern bool parse_table_key(const char *key, const char *prefix, bool &is_rows, int &row, int &column);
 
#if USE_EXEC_GUI
class table_via_configure
{
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 ~table_via_configure();
};
#endif
 
struct automation_range
{
    float min_value;
    float max_value;
    int param_no;
 
    automation_range(float l, float u, int param)
    : min_value(l)
    , max_value(u)
    , param_no(param)
    {}
    void send_configure(const plugin_metadata_iface *metadata, uint32_t from_controller, send_configure_iface *sci);
    static automation_range *new_from_configure(const plugin_metadata_iface *metadata, const char *key, const char *value, uint32_t &from_controller);
};
 
struct automation_map: public std::multimap<uint32_t, automation_range>
{
};
 
inline float subindex_to_freq(int subindex)
{
  float freq = 100;
  if (subindex < 9)
    freq = 10 * (subindex + 1);
  else if (subindex < 18)
    freq = 100 * (subindex - 9 + 1);
  else if (subindex < 27)
    freq = 1000 * (subindex - 18 + 1);
  else
    freq = 10000 * (subindex - 27 + 1);
 
  return freq;
}
 
};
 
#define FORWARD_DECLARE_METADATA(plugin) \
    template<> const char *calf_plugins::plugin_metadata<calf_plugins::plugin##_metadata>::port_names[]; \
    template<> calf_plugins::parameter_properties calf_plugins::plugin_metadata<calf_plugins::plugin##_metadata>::param_props[]; \
    template<> calf_plugins::ladspa_plugin_info calf_plugins::plugin_metadata<calf_plugins::plugin##_metadata>::plugin_info;
 
 
#endif