src/calf/ladspa_wrap.h

   1 /* Calf DSP Library
   2  * API wrappers for LADSPA/DSSI
   3  *
   4  * Copyright (C) 2007-2008 Krzysztof Foltman
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General
  17  * Public License along with this program; if not, write to the
  18  * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
  19  * Boston, MA 02111-1307, USA.
  20  */
  21 #ifndef __CALF_LADSPA_WRAP_H
  22 #define __CALF_LADSPA_WRAP_H
  23
  24 #if USE_LADSPA
  25
  26 #include <ladspa.h>
  27 #if USE_DSSI
  28 #include <dssi.h>
  29 #endif
  30 #include "giface.h"
  31
  32 namespace calf_plugins {
  33
  34 template<class Module>
  35 inline int calc_real_param_count()
  36 {
  37     for (int i=0; i < Module::param_count; i++)
  38     {
  39         if ((Module::param_props[i].flags & PF_TYPEMASK) >= PF_STRING)
  40             return i;
  41     }
  42     return Module::param_count;
  43 }
  44
  45 /// A template implementing plugin_ctl_iface for a given plugin
  46 template<class Module>
  47 struct ladspa_instance: public Module, public plugin_ctl_iface
  48 {
  49     bool activate_flag;
  50 #if USE_DSSI
  51     dssi_feedback_sender *feedback_sender;
  52 #endif
  53
  54     static int real_param_count()
  55     {
  56         static int _real_param_count = calc_real_param_count<Module>();
  57         return _real_param_count;
  58     }
  59     ladspa_instance()
  60     {
  61         for (int i=0; i < Module::in_count; i++)
  62             Module::ins[i] = NULL;
  63         for (int i=0; i < Module::out_count; i++)
  64             Module::outs[i] = NULL;
  65         int rpc = real_param_count();
  66         for (int i=0; i < rpc; i++)
  67             Module::params[i] = NULL;
  68         activate_flag = true;
  69 #if USE_DSSI
  70         feedback_sender = NULL;
  71 #endif
  72     }
  73     virtual parameter_properties *get_param_props(int param_no)
  74     {
  75         return &Module::param_props[param_no];
  76     }
  77     virtual float get_param_value(int param_no)
  78     {
  79         // XXXKF hack
  80         if (param_no >= real_param_count())
  81             return 0;
  82         return *Module::params[param_no];
  83     }
  84     virtual void set_param_value(int param_no, float value)
  85     {
  86         // XXXKF hack
  87         if (param_no >= real_param_count())
  88             return;
  89         *Module::params[param_no] = value;
  90     }
  91     virtual int get_param_count()
  92     {
  93         return real_param_count();
  94     }
  95     virtual int get_param_port_offset()
  96     {
  97         return Module::in_count + Module::out_count;
  98     }
  99     virtual const char *get_gui_xml() {
 100         return Module::get_gui_xml();
 101     }
 102     virtual line_graph_iface *get_line_graph_iface()
 103     {
 104         return dynamic_cast<line_graph_iface *>(this);
 105     }
 106     virtual bool activate_preset(int bank, int program) {
 107         return false;
 108     }
 109     virtual const char *get_name()
 110     {
 111         return Module::get_name();
 112     }
 113     virtual const char *get_id()
 114     {
 115         return Module::get_id();
 116     }
 117     virtual const char *get_label()
 118     {
 119         return Module::get_label();
 120     }
 121     virtual char *configure(const char *key, const char *value)
 122     {
 123 #if USE_DSSI
 124         if (!strcmp(key, "OSC:FEEDBACK_URI"))
 125         {
 126             line_graph_iface *lgi = dynamic_cast<line_graph_iface *>(this);
 127             if (!lgi)
 128                 return NULL;
 129             if (*value)
 130             {
 131                 if (feedback_sender) {
 132                     delete feedback_sender;
 133                     feedback_sender = NULL;
 134                 }
 135                 feedback_sender = new dssi_feedback_sender(value, lgi, get_param_props(0), get_param_count());
 136             }
 137             else
 138             {
 139                 if (feedback_sender) {
 140                     delete feedback_sender;
 141                     feedback_sender = NULL;
 142                 }
 143             }
 144             return NULL;
 145         }
 146         else
 147         if (!strcmp(key, "OSC:UPDATE"))
 148         {
 149             if (feedback_sender)
 150                 feedback_sender->update();
 151             return NULL;
 152         }
 153         else
 154 #endif
 155         if (!strcmp(key, "ExecCommand"))
 156         {
 157             if (*value)
 158             {
 159                 execute(atoi(value));
 160             }
 161             return NULL;
 162         }
 163         return Module::configure(key, value);
 164     }
 165     virtual int get_input_count() { return Module::in_count; }
 166     virtual int get_output_count() { return Module::out_count; }
 167     virtual bool get_midi() { return Module::support_midi; }
 168     virtual float get_level(unsigned int port) { return 0.f; }
 169     virtual void execute(int cmd_no) {
 170         Module::execute(cmd_no);
 171     }
 172     virtual void send_configures(send_configure_iface *sci) {
 173         Module::send_configures(sci);
 174     }
 175 };
 176
 177 /// A wrapper class for plugin class object (there is only one ladspa_wrapper for many instances of the same plugin)
 178 template<class Module>
 179 struct ladspa_wrapper
 180 {
 181     typedef ladspa_instance<Module> instance;
 182
 183     /// LADSPA descriptor
 184     static LADSPA_Descriptor descriptor;
 185     /// LADSPA descriptor for DSSI (uses a different name for the plugin, otherwise same as descriptor)
 186     static LADSPA_Descriptor descriptor_for_dssi;
 187 #if USE_DSSI
 188     /// Extended DSSI descriptor (points to descriptor_for_dssi for things like name/label/port info etc.)
 189     static DSSI_Descriptor dssi_descriptor;
 190     static DSSI_Program_Descriptor dssi_default_program;
 191
 192     static std::vector<plugin_preset> *presets;
 193     static std::vector<DSSI_Program_Descriptor> *preset_descs;
 194 #endif
 195
 196     ladspa_wrapper()
 197     {
 198         int ins = Module::in_count;
 199         int outs = Module::out_count;
 200         int params = ladspa_instance<Module>::real_param_count();
 201         ladspa_plugin_info &plugin_info = Module::plugin_info;
 202         descriptor.UniqueID = plugin_info.unique_id;
 203         descriptor.Label = plugin_info.label;
 204         descriptor.Name = strdup((std::string(plugin_info.name) + " LADSPA").c_str());
 205         descriptor.Maker = plugin_info.maker;
 206         descriptor.Copyright = plugin_info.copyright;
 207         descriptor.Properties = Module::rt_capable ? LADSPA_PROPERTY_HARD_RT_CAPABLE : 0;
 208         descriptor.PortCount = ins + outs + params;
 209         descriptor.PortNames = new char *[descriptor.PortCount];
 210         descriptor.PortDescriptors = new LADSPA_PortDescriptor[descriptor.PortCount];
 211         descriptor.PortRangeHints = new LADSPA_PortRangeHint[descriptor.PortCount];
 212         int i;
 213         for (i = 0; i < ins + outs; i++)
 214         {
 215             LADSPA_PortRangeHint &prh = ((LADSPA_PortRangeHint *)descriptor.PortRangeHints)[i];
 216             ((int *)descriptor.PortDescriptors)[i] = i < ins ? LADSPA_PORT_INPUT | LADSPA_PORT_AUDIO
 217                                                   : i < ins + outs ? LADSPA_PORT_OUTPUT | LADSPA_PORT_AUDIO
 218                                                                    : LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
 219             prh.HintDescriptor = 0;
 220             ((const char **)descriptor.PortNames)[i] = Module::port_names[i];
 221         }
 222         for (; i < ins + outs + params; i++)
 223         {
 224             LADSPA_PortRangeHint &prh = ((LADSPA_PortRangeHint *)descriptor.PortRangeHints)[i];
 225             parameter_properties &pp = Module::param_props[i - ins - outs];
 226             ((int *)descriptor.PortDescriptors)[i] =
 227                 LADSPA_PORT_CONTROL | (pp.flags & PF_PROP_OUTPUT ? LADSPA_PORT_OUTPUT : LADSPA_PORT_INPUT);
 228             prh.HintDescriptor = LADSPA_HINT_BOUNDED_ABOVE | LADSPA_HINT_BOUNDED_BELOW;
 229             ((const char **)descriptor.PortNames)[i] = pp.name;
 230             prh.LowerBound = pp.min;
 231             prh.UpperBound = pp.max;
 232             switch(pp.flags & PF_TYPEMASK) {
 233                 case PF_BOOL:
 234                     prh.HintDescriptor |= LADSPA_HINT_TOGGLED;
 235                     prh.HintDescriptor &= ~(LADSPA_HINT_BOUNDED_ABOVE | LADSPA_HINT_BOUNDED_BELOW);
 236                     break;
 237                 case PF_INT:
 238                 case PF_ENUM:
 239                     prh.HintDescriptor |= LADSPA_HINT_INTEGER;
 240                     break;
 241                 default: {
 242                     int defpt = (int)(100 * (pp.def_value - pp.min) / (pp.max - pp.min));
 243                     if ((pp.flags & PF_SCALEMASK) == PF_SCALE_LOG)
 244                         defpt = (int)(100 * log(pp.def_value / pp.min) / log(pp.max / pp.min));
 245                     if (defpt < 12)
 246                         prh.HintDescriptor |= LADSPA_HINT_DEFAULT_MINIMUM;
 247                     else if (defpt < 37)
 248                         prh.HintDescriptor |= LADSPA_HINT_DEFAULT_LOW;
 249                     else if (defpt < 63)
 250                         prh.HintDescriptor |= LADSPA_HINT_DEFAULT_MIDDLE;
 251                     else if (defpt < 88)
 252                         prh.HintDescriptor |= LADSPA_HINT_DEFAULT_HIGH;
 253                     else
 254                         prh.HintDescriptor |= LADSPA_HINT_DEFAULT_MAXIMUM;
 255                 }
 256             }
 257             if (pp.def_value == 0 || pp.def_value == 1 || pp.def_value == 100 || pp.def_value == 440 ) {
 258                 prh.HintDescriptor &= ~LADSPA_HINT_DEFAULT_MASK;
 259                 if (pp.def_value == 1)
 260                     prh.HintDescriptor |= LADSPA_HINT_DEFAULT_1;
 261                 else if (pp.def_value == 100)
 262                     prh.HintDescriptor |= LADSPA_HINT_DEFAULT_100;
 263                 else if (pp.def_value == 440)
 264                     prh.HintDescriptor |= LADSPA_HINT_DEFAULT_440;
 265                 else
 266                     prh.HintDescriptor |= LADSPA_HINT_DEFAULT_0;
 267             }
 268             switch(pp.flags & PF_SCALEMASK) {
 269                 case PF_SCALE_LOG:
 270                     prh.HintDescriptor |= LADSPA_HINT_LOGARITHMIC;
 271                     break;
 272             }
 273         }
 274         descriptor.ImplementationData = this;
 275         descriptor.instantiate = cb_instantiate;
 276         descriptor.connect_port = cb_connect;
 277         descriptor.activate = cb_activate;
 278         descriptor.run = cb_run;
 279         descriptor.run_adding = NULL;
 280         descriptor.set_run_adding_gain = NULL;
 281         descriptor.deactivate = cb_deactivate;
 282         descriptor.cleanup = cb_cleanup;
 283 #if USE_DSSI
 284         memcpy(&descriptor_for_dssi, &descriptor, sizeof(descriptor));
 285         descriptor_for_dssi.Name = strdup((std::string(plugin_info.name) + " DSSI").c_str());
 286         memset(&dssi_descriptor, 0, sizeof(dssi_descriptor));
 287         dssi_descriptor.DSSI_API_Version = 1;
 288         dssi_descriptor.LADSPA_Plugin = &descriptor_for_dssi;
 289         dssi_descriptor.configure = cb_configure;
 290         dssi_descriptor.get_program = cb_get_program;
 291         dssi_descriptor.select_program = cb_select_program;
 292         dssi_descriptor.run_synth = cb_run_synth;
 293
 294         presets = new std::vector<plugin_preset>;
 295         preset_descs = new std::vector<DSSI_Program_Descriptor>;
 296
 297         preset_list plist_tmp, plist;
 298         plist.load_defaults(true);
 299         plist_tmp.load_defaults(false);
 300         plist.presets.insert(plist.presets.end(), plist_tmp.presets.begin(), plist_tmp.presets.end());
 301
 302         // XXXKF this assumes that plugin name in preset is case-insensitive equal to plugin label
 303         // if I forget about this, I'll be in a deep trouble
 304         dssi_default_program.Bank = 0;
 305         dssi_default_program.Program = 0;
 306         dssi_default_program.Name = "default";
 307
 308         int pos = 1;
 309         for (unsigned int i = 0; i < plist.presets.size(); i++)
 310         {
 311             plugin_preset &pp = plist.presets[i];
 312             if (strcasecmp(pp.plugin.c_str(), descriptor.Label))
 313                 continue;
 314             DSSI_Program_Descriptor pd;
 315             pd.Bank = pos >> 7;
 316             pd.Program = pos++;
 317             pd.Name = pp.name.c_str();
 318             preset_descs->push_back(pd);
 319             presets->push_back(pp);
 320         }
 321         // printf("presets = %p:%d name = %s\n", presets, presets->size(), descriptor.Label);
 322
 323 #endif
 324     }
 325
 326     ~ladspa_wrapper()
 327     {
 328         delete []descriptor.PortNames;
 329         delete []descriptor.PortDescriptors;
 330         delete []descriptor.PortRangeHints;
 331 #if USE_DSSI
 332         presets->clear();
 333         preset_descs->clear();
 334         delete presets;
 335         delete preset_descs;
 336 #endif
 337     }
 338
 339     /// LADSPA instantiation function (create a plugin instance)
 340     static LADSPA_Handle cb_instantiate(const struct _LADSPA_Descriptor * Descriptor, unsigned long sample_rate)
 341     {
 342         instance *mod = new instance();
 343         mod->srate = sample_rate;
 344         mod->post_instantiate();
 345         return mod;
 346     }
 347
 348 #if USE_DSSI
 349     /// DSSI get program descriptor function; for 0, it returns the default program (from parameter properties table), for others, it uses global or user preset
 350     static const DSSI_Program_Descriptor *cb_get_program(LADSPA_Handle Instance, unsigned long index) {
 351         if (index > presets->size())
 352             return NULL;
 353         if (index)
 354             return &(*preset_descs)[index - 1];
 355         return &dssi_default_program;
 356     }
 357
 358     /// DSSI select program function; for 0, it sets the defaults, for others, it sets global or user preset
 359     static void cb_select_program(LADSPA_Handle Instance, unsigned long Bank, unsigned long Program) {
 360         instance *mod = (instance *)Instance;
 361         unsigned int no = (Bank << 7) + Program - 1;
 362         // printf("no = %d presets = %p:%d\n", no, presets, presets->size());
 363         if (no == -1U) {
 364             int rpc = ladspa_instance<Module>::real_param_count();
 365             for (int i =0 ; i < rpc; i++)
 366                 *mod->params[i] = Module::param_props[i].def_value;
 367             return;
 368         }
 369         if (no >= presets->size())
 370             return;
 371         plugin_preset &p = (*presets)[no];
 372         // printf("activating preset %s\n", p.name.c_str());
 373         p.activate(mod);
 374     }
 375
 376 #endif
 377
 378     /// LADSPA port connection function
 379     static void cb_connect(LADSPA_Handle Instance, unsigned long port, LADSPA_Data *DataLocation) {
 380         unsigned long ins = Module::in_count;
 381         unsigned long outs = Module::out_count;
 382         unsigned long params = ladspa_instance<Module>::real_param_count();
 383         instance *const mod = (instance *)Instance;
 384         if (port < ins)
 385             mod->ins[port] = DataLocation;
 386         else if (port < ins + outs)
 387             mod->outs[port - ins] = DataLocation;
 388         else if (port < ins + outs + params) {
 389             int i = port - ins - outs;
 390             mod->params[i] = DataLocation;
 391             *mod->params[i] = Module::param_props[i].def_value;
 392         }
 393     }
 394
 395     /// LADSPA activate function (note that at this moment the ports are not set)
 396     static void cb_activate(LADSPA_Handle Instance) {
 397         instance *const mod = (instance *)Instance;
 398         mod->activate_flag = true;
 399     }
 400
 401     /// utility function: zero port values if mask is 0
 402     static inline void zero_by_mask(Module *module, uint32_t mask, uint32_t offset, uint32_t nsamples)
 403     {
 404         for (int i=0; i<Module::out_count; i++) {
 405             if ((mask & (1 << i)) == 0) {
 406                 dsp::zero(module->outs[i] + offset, nsamples);
 407             }
 408         }
 409     }
 410
 411     /// LADSPA run function - does set sample rate / activate logic when it's run first time after activation
 412     static void cb_run(LADSPA_Handle Instance, unsigned long SampleCount) {
 413         instance *const mod = (instance *)Instance;
 414         if (mod->activate_flag)
 415         {
 416             mod->set_sample_rate(mod->srate);
 417             mod->activate();
 418             mod->activate_flag = false;
 419         }
 420         mod->params_changed();
 421         process_slice(mod, 0, SampleCount);
 422     }
 423
 424     /// utility function: call process, and if it returned zeros in output masks, zero out the relevant output port buffers
 425     static inline void process_slice(Module *mod, uint32_t offset, uint32_t end)
 426     {
 427         while(offset < end)
 428         {
 429             uint32_t newend = std::min(offset + MAX_SAMPLE_RUN, end);
 430             uint32_t out_mask = mod->process(offset, newend - offset, -1, -1);
 431             zero_by_mask(mod, out_mask, offset, newend - offset);
 432             offset = newend;
 433         }
 434     }
 435
 436 #if USE_DSSI
 437     /// DSSI "run synth" function, same as run() except it allows for event delivery
 438     static void cb_run_synth(LADSPA_Handle Instance, unsigned long SampleCount,
 439             snd_seq_event_t *Events, unsigned long EventCount) {
 440         instance *const mod = (instance *)Instance;
 441         if (mod->activate_flag)
 442         {
 443             mod->set_sample_rate(mod->srate);
 444             mod->activate();
 445             mod->activate_flag = false;
 446         }
 447         mod->params_changed();
 448
 449         uint32_t offset = 0;
 450         for (uint32_t e = 0; e < EventCount; e++)
 451         {
 452             uint32_t timestamp = Events[e].time.tick;
 453             if (timestamp != offset)
 454                 process_slice(mod, offset, timestamp);
 455             process_dssi_event(mod, Events[e]);
 456             offset = timestamp;
 457         }
 458         if (offset != SampleCount)
 459             process_slice(mod, offset, SampleCount);
 460     }
 461
 462     /// DSSI configure function (named properties)
 463     static char *cb_configure(LADSPA_Handle Instance,
 464                        const char *Key,
 465                        const char *Value)
 466     {
 467         instance *const mod = (instance *)Instance;
 468         return mod->configure(Key, Value);
 469     }
 470
 471     /// Utility function: handle MIDI event (only handles a subset in this version)
 472     static void process_dssi_event(Module *module, snd_seq_event_t &event)
 473     {
 474         switch(event.type) {
 475             case SND_SEQ_EVENT_NOTEON:
 476                 module->note_on(event.data.note.note, event.data.note.velocity);
 477                 break;
 478             case SND_SEQ_EVENT_NOTEOFF:
 479                 module->note_off(event.data.note.note, event.data.note.velocity);
 480                 break;
 481             case SND_SEQ_EVENT_PGMCHANGE:
 482                 module->program_change(event.data.control.value);
 483                 break;
 484             case SND_SEQ_EVENT_CONTROLLER:
 485                 module->control_change(event.data.control.param, event.data.control.value);
 486                 break;
 487             case SND_SEQ_EVENT_PITCHBEND:
 488                 module->pitch_bend(event.data.control.value);
 489                 break;
 490         }
 491     }
 492 #endif
 493
 494     /// LADSPA deactivate function
 495     static void cb_deactivate(LADSPA_Handle Instance) {
 496         instance *const mod = (instance *)Instance;
 497         mod->deactivate();
 498     }
 499
 500     /// LADSPA cleanup (delete instance) function
 501     static void cb_cleanup(LADSPA_Handle Instance) {
 502         instance *const mod = (instance *)Instance;
 503         delete mod;
 504     }
 505
 506     /// Get a wrapper singleton - used to prevent initialization order problems which were present in older versions
 507     static ladspa_wrapper &get() {
 508         static ladspa_wrapper instance;
 509         return instance;
 510     }
 511 };
 512
 513 };
 514
 515 #endif
 516
 517 #endif