src/carla/carla_backend.cpp

   1 /* JACK Backend code for Carla */
   2
   3 #include "carla_backend.h"
   4 #include "audio_plugin.h"
   5 #include "misc.h"
   6
   7 #include <stdlib.h>
   8 #include <stdio.h>
   9 #include <string.h>
  10
  11 #include <QtGui/QApplication>
  12 #include <QtCore/QMutex>
  13
  14 // Global variables
  15 CallbackFunc Callback = nullptr;
  16 const char* last_error = nullptr;
  17 const char* carla_client_name = nullptr;
  18
  19 QMutex carla_proc_lock_var;
  20 QMutex carla_midi_lock_var;
  21 CarlaCheckThread check_thread;
  22
  23 // Global variables (shared)
  24 const char* unique_names[MAX_PLUGINS]  = { nullptr };
  25 AudioPlugin* AudioPlugins[MAX_PLUGINS] = { nullptr };
  26 ExternalMidiNote ExternalMidiNotes[MAX_MIDI_EVENTS];
  27
  28 volatile double ains_peak[MAX_PLUGINS*2]  = { 0.0 };
  29 volatile double aouts_peak[MAX_PLUGINS*2] = { 0.0 };
  30
  31 // Global JACK client
  32 jack_client_t* carla_jack_client = nullptr;
  33 jack_nframes_t carla_buffer_size = 512;
  34 jack_nframes_t carla_sample_rate = 48000;
  35
  36 // Global OSC stuff
  37 lo_server_thread global_osc_server_thread = nullptr;
  38 const char* global_osc_server_path = nullptr;
  39 OscData global_osc_data = { nullptr, nullptr, nullptr };
  40
  41 // Global options
  42 carla_options_t carla_options = {
  43   /* _initiated */           false,
  44   /* global_jack_client   */ false,
  45   /* bridge_path_lv2_gtk2 */ nullptr,
  46   /* bridge_path_lv2_qt4  */ nullptr,
  47   /* bridge_path_lv2_x11  */ nullptr,
  48   /* bridge_path_vst_qt4  */ nullptr,
  49   /* bridge_path_winvst   */ nullptr
  50 };
  51
  52 // jack.cpp
  53 int carla_jack_process_callback(jack_nframes_t nframes, void* arg);
  54 int carla_jack_bufsize_callback(jack_nframes_t new_buffer_size, void* arg);
  55 int carla_jack_srate_callback(jack_nframes_t new_sample_rate, void* arg);
  56 void carla_jack_shutdown_callback(void* arg);
  57
  58 // plugin specific
  59 short add_plugin_ladspa(const char* filename, const char* label, void* extra_stuff);
  60 short add_plugin_dssi(const char* filename, const char* label, void* extra_stuff);
  61 short add_plugin_lv2(const char* filename, const char* label, void* extra_stuff);
  62 short add_plugin_vst(const char* filename, const char* label);
  63 short add_plugin_winvst(const char* filename, const char* label, void* extra_stuff);
  64 short add_plugin_sf2(const char* filename, const char* label);
  65
  66 // -------------------------------------------------------------------------------------------------------------------
  67 // Exported symbols (API)
  68 bool carla_init(const char* client_name)
  69 {
  70     qDebug("carla_init(%s)", client_name);
  71
  72     carla_options._initiated = true;
  73
  74     bool started = false;
  75     carla_jack_client = jack_client_open(client_name, JackNullOption, 0x0);
  76
  77     if (carla_jack_client)
  78     {
  79         carla_buffer_size = jack_get_buffer_size(carla_jack_client);
  80         carla_sample_rate = jack_get_sample_rate(carla_jack_client);
  81
  82         if (carla_options.global_jack_client)
  83             jack_set_process_callback(carla_jack_client, carla_jack_process_callback, nullptr);
  84
  85         jack_set_buffer_size_callback(carla_jack_client, carla_jack_bufsize_callback, nullptr);
  86         jack_set_sample_rate_callback(carla_jack_client, carla_jack_srate_callback, nullptr);
  87         jack_on_shutdown(carla_jack_client, carla_jack_shutdown_callback, nullptr);
  88
  89         if (jack_activate(carla_jack_client))
  90         {
  91             set_last_error("Failed to activate the JACK client");
  92             carla_jack_client = nullptr;
  93         }
  94         else
  95             started = true;
  96     }
  97     else
  98     {
  99         set_last_error("Failed to create new JACK client");
 100         carla_jack_client = nullptr;
 101     }
 102
 103     if (started)
 104     {
 105         client_name = jack_get_client_name(carla_jack_client);
 106
 107         // Fix name for OSC usage
 108         char* fixed_name = strdup(client_name);
 109         for (size_t i=0; i < strlen(fixed_name); i++)
 110         {
 111             if (!std::isalpha(fixed_name[i]) && !std::isdigit(fixed_name[i]))
 112                 fixed_name[i] = '_';
 113         }
 114
 115         carla_client_name = strdup(fixed_name);
 116         free((void*)fixed_name);
 117
 118         for (unsigned short i=0; i<MAX_MIDI_EVENTS; i++)
 119             ExternalMidiNotes[i].valid = false;
 120
 121         osc_init();
 122
 123         check_thread.start();
 124
 125         set_last_error("no error");
 126     }
 127
 128     return started;
 129 }
 130
 131 bool carla_close()
 132 {
 133     qDebug("carla_close()");
 134
 135     bool closed = false;
 136
 137     if (jack_deactivate(carla_jack_client))
 138         set_last_error("Failed to deactivate the JACK client");
 139     else
 140     {
 141         if (jack_client_close(carla_jack_client))
 142             set_last_error("Failed to close the JACK client");
 143         else
 144             closed = true;
 145     }
 146
 147     carla_jack_client = nullptr;
 148
 149     for (unsigned short i=0; i<MAX_PLUGINS; i++)
 150     {
 151         AudioPlugin* plugin = AudioPlugins[i];
 152         if (plugin && plugin->id >= 0)
 153             remove_plugin(i);
 154     }
 155
 156     check_thread.quit();
 157
 158     if (!check_thread.wait(1000000)) // 1 sec
 159         qWarning("Failed to properly stop global check thread");
 160
 161     osc_send_exit(&global_osc_data);
 162     osc_close();
 163
 164     if (carla_client_name)
 165         free((void*)carla_client_name);
 166
 167     if (last_error)
 168         free((void*)last_error);
 169
 170     if (carla_options._initiated)
 171     {
 172         if (carla_options.bridge_path_lv2_gtk2)
 173             free((void*)carla_options.bridge_path_lv2_gtk2);
 174
 175         if (carla_options.bridge_path_lv2_qt4)
 176             free((void*)carla_options.bridge_path_lv2_qt4);
 177
 178         if (carla_options.bridge_path_lv2_x11)
 179             free((void*)carla_options.bridge_path_lv2_x11);
 180
 181         if (carla_options.bridge_path_vst_qt4)
 182             free((void*)carla_options.bridge_path_vst_qt4);
 183
 184         if (carla_options.bridge_path_winvst)
 185             free((void*)carla_options.bridge_path_winvst);
 186     }
 187
 188     // cleanup static data
 189     get_plugin_info(0);
 190     get_parameter_info(0, 0);
 191     get_scalepoint_info(0, 0, 0);
 192     get_chunk_data(0);
 193     get_real_plugin_name(0);
 194
 195     return closed;
 196 }
 197
 198 bool carla_is_engine_running()
 199 {
 200     return bool(carla_jack_client);
 201 }
 202
 203 short add_plugin(PluginType ptype, const char* filename, const char* label, void* extra_stuff)
 204 {
 205     qDebug("add_plugin(%s, %s, %i, %p)", filename, label, ptype, extra_stuff);
 206
 207     switch (ptype)
 208     {
 209     case PLUGIN_LADSPA:
 210         return add_plugin_ladspa(filename, label, extra_stuff);
 211     case PLUGIN_DSSI:
 212         return add_plugin_dssi(filename, label, extra_stuff);
 213     case PLUGIN_LV2:
 214         return add_plugin_lv2(filename, label, extra_stuff);
 215     case PLUGIN_VST:
 216         return add_plugin_vst(filename, label);
 217     case PLUGIN_WINVST:
 218         return add_plugin_winvst(filename, label, extra_stuff);
 219     case PLUGIN_SF2:
 220         return add_plugin_sf2(filename, label);
 221     default:
 222         set_last_error("Unknown plugin type");
 223         return -1;
 224     }
 225 }
 226
 227 bool remove_plugin(unsigned short plugin_id)
 228 {
 229     qDebug("remove_plugin(%i)", plugin_id);
 230
 231     for (unsigned short i=0; i<MAX_PLUGINS; i++)
 232     {
 233         AudioPlugin* plugin = AudioPlugins[i];
 234         if (plugin && plugin->id == plugin_id)
 235         {
 236             osc_send_remove_plugin(&global_osc_data, plugin->id);
 237
 238             carla_proc_lock();
 239             plugin->id = -1;
 240             carla_proc_unlock();
 241
 242             plugin->delete_me();
 243
 244             AudioPlugins[i] = nullptr;
 245             unique_names[i] = nullptr;
 246
 247             return true;
 248         }
 249     }
 250
 251     set_last_error("Could not find plugin to remove");
 252     return false;
 253 }
 254
 255 PluginInfo* get_plugin_info(unsigned short plugin_id)
 256 {
 257     qDebug("get_plugin_info(%i)", plugin_id);
 258
 259     static PluginInfo info = { false, PLUGIN_NONE, PLUGIN_CATEGORY_NONE, 0, nullptr, nullptr, nullptr, nullptr, nullptr, 0 };
 260
 261     if (info.valid)
 262     {
 263         free((void*)info.label);
 264         free((void*)info.maker);
 265         free((void*)info.copyright);
 266     }
 267
 268     info.valid = false;
 269
 270     for (unsigned short i=0; i<MAX_PLUGINS; i++)
 271     {
 272         AudioPlugin* plugin = AudioPlugins[i];
 273         if (plugin && plugin->id == plugin_id)
 274         {
 275             char buf_str[STR_MAX] = { 0 };
 276
 277             info.valid     = true;
 278             info.type      = plugin->type;
 279             info.category  = plugin->get_category();
 280             info.hints     = plugin->hints;
 281             info.binary    = plugin->filename;
 282             info.name      = plugin->name;
 283             info.unique_id = plugin->get_unique_id();
 284
 285             plugin->get_label(buf_str);
 286             info.label = strdup(buf_str);
 287
 288             plugin->get_maker(buf_str);
 289             info.maker = strdup(buf_str);
 290
 291             plugin->get_copyright(buf_str);
 292             info.copyright = strdup(buf_str);
 293
 294             return &info;
 295         }
 296     }
 297
 298     if (carla_is_engine_running())
 299         qCritical("get_plugin_info(%i) - could not find plugin", plugin_id);
 300
 301     return &info;
 302 }
 303
 304 PortCountInfo* get_audio_port_count_info(unsigned short plugin_id)
 305 {
 306     qDebug("get_audio_port_count_info(%i)", plugin_id);
 307
 308     static PortCountInfo info = { false, 0, 0, 0 };
 309     info.valid = false;
 310
 311     for (unsigned short i=0; i<MAX_PLUGINS; i++)
 312     {
 313         AudioPlugin* plugin = AudioPlugins[i];
 314         if (plugin && plugin->id == plugin_id)
 315         {
 316             info.valid = true;
 317             info.ins   = plugin->ain.count;
 318             info.outs  = plugin->aout.count;
 319             info.total = info.ins + info.outs;
 320             return &info;
 321         }
 322     }
 323
 324     qCritical("get_audio_port_count_info(%i) - could not find plugin", plugin_id);
 325     return &info;
 326 }
 327
 328 PortCountInfo* get_midi_port_count_info(unsigned short plugin_id)
 329 {
 330     qDebug("get_midi_port_count_info(%i)", plugin_id);
 331
 332     static PortCountInfo info = { false, 0, 0, 0 };
 333     info.valid = false;
 334
 335     for (unsigned short i=0; i<MAX_PLUGINS; i++)
 336     {
 337         AudioPlugin* plugin = AudioPlugins[i];
 338         if (plugin && plugin->id == plugin_id)
 339         {
 340             info.valid = true;
 341             info.ins   = plugin->min.count;
 342             info.outs  = plugin->mout.count;
 343             info.total = info.ins + info.outs;
 344             return &info;
 345         }
 346     }
 347
 348     qCritical("get_midi_port_count_info(%i) - could not find plugin", plugin_id);
 349     return &info;
 350 }
 351
 352 PortCountInfo* get_parameter_count_info(unsigned short plugin_id)
 353 {
 354     qDebug("get_parameter_port_count_info(%i)", plugin_id);
 355
 356     static PortCountInfo info = { false, 0, 0, 0 };
 357     info.valid = false;
 358
 359     for (unsigned short i=0; i<MAX_PLUGINS; i++)
 360     {
 361         AudioPlugin* plugin = AudioPlugins[i];
 362         if (plugin && plugin->id == plugin_id)
 363         {
 364             info.valid = true;
 365             info.ins   = 0;
 366             info.outs  = 0;
 367             info.total = plugin->param.count;
 368
 369             for (uint32_t j=0; j < plugin->param.count; j++)
 370             {
 371                 ParameterType ParamType = plugin->param.data[j].type;
 372                 if (ParamType == PARAMETER_INPUT)
 373                     info.ins += 1;
 374                 else if (ParamType == PARAMETER_OUTPUT)
 375                     info.outs += 1;
 376             }
 377
 378             return &info;
 379         }
 380     }
 381
 382     qCritical("get_parameter_port_count_info(%i) - could not find plugin", plugin_id);
 383     return &info;
 384 }
 385
 386 ParameterInfo* get_parameter_info(unsigned short plugin_id, uint32_t parameter_id)
 387 {
 388     qDebug("get_parameter_info(%i, %i)", plugin_id, parameter_id);
 389
 390     static ParameterInfo info = { false, nullptr, nullptr, nullptr, 0 };
 391
 392     if (info.valid)
 393     {
 394         free((void*)info.name);
 395         free((void*)info.symbol);
 396         free((void*)info.label);
 397     }
 398
 399     info.valid = false;
 400
 401     for (unsigned short i=0; i<MAX_PLUGINS; i++)
 402     {
 403         AudioPlugin* plugin = AudioPlugins[i];
 404         if (plugin && plugin->id == plugin_id)
 405         {
 406             if (parameter_id < plugin->param.count)
 407             {
 408                 char buf_str[STR_MAX] = { 0 };
 409                 int32_t rindex = plugin->param.data[parameter_id].rindex;
 410
 411                 if (rindex >= 0)
 412                 {
 413                     info.valid = true;
 414                     info.scalepoint_count = plugin->get_scalepoint_count(rindex);
 415
 416                     plugin->get_parameter_name(rindex, buf_str);
 417                     info.name = strdup(buf_str);
 418
 419                     plugin->get_parameter_symbol(rindex, buf_str);
 420                     info.symbol = strdup(buf_str);
 421
 422                     plugin->get_parameter_label(rindex, buf_str);
 423                     info.label = strdup(buf_str);
 424                 }
 425                 else
 426                     qCritical("get_parameter_info(%i, %i) - invalid rindex: %i", plugin_id, parameter_id, rindex);
 427             }
 428             else
 429                 qCritical("get_parameter_info(%i, %i) - parameter_id out of bounds", plugin_id, parameter_id);
 430
 431             return &info;
 432         }
 433     }
 434
 435     if (carla_is_engine_running())
 436         qCritical("get_parameter_info(%i, %i) - could not find plugin", plugin_id, parameter_id);
 437
 438     return &info;
 439 }
 440
 441 ScalePointInfo* get_scalepoint_info(unsigned short plugin_id, uint32_t parameter_id, uint32_t scalepoint_id)
 442 {
 443     qDebug("get_scalepoint_info(%i, %i, %i)", plugin_id, parameter_id, scalepoint_id);
 444
 445     static ScalePointInfo info = { false, 0.0, nullptr };
 446
 447     if (info.valid)
 448     {
 449         free((void*)info.label);
 450     }
 451
 452     info.valid = false;
 453
 454     for (unsigned short i=0; i<MAX_PLUGINS; i++)
 455     {
 456         AudioPlugin* plugin = AudioPlugins[i];
 457         if (plugin && plugin->id == plugin_id)
 458         {
 459             if (parameter_id < plugin->param.count)
 460             {
 461                 int32_t rindex = plugin->param.data[parameter_id].rindex;
 462
 463                 if (scalepoint_id < plugin->get_scalepoint_count(rindex))
 464                 {
 465                     char buf_str[STR_MAX] = { 0 };
 466
 467                     info.valid = true;
 468                     info.value = plugin->get_scalepoint_value(rindex, scalepoint_id);
 469
 470                     plugin->get_scalepoint_label(rindex, scalepoint_id, buf_str);
 471                     info.label = strdup(buf_str);
 472                 }
 473                 else
 474                     qCritical("get_scalepoint_info(%i, %i, %i) - scalepoint_id out of bounds", plugin_id, parameter_id, scalepoint_id);
 475             }
 476             else
 477                 qCritical("get_scalepoint_info(%i, %i, %i) - parameter_id out of bounds", plugin_id, parameter_id, parameter_id);
 478
 479             return &info;
 480         }
 481     }
 482
 483     if (carla_is_engine_running())
 484         qCritical("get_scalepoint_info(%i, %i, %i) - could not find plugin", plugin_id, parameter_id, scalepoint_id);
 485
 486     return &info;
 487 }
 488
 489 MidiProgramInfo* get_midi_program_info(unsigned short plugin_id, uint32_t midi_program_id)
 490 {
 491     qDebug("get_midi_program_info(%i, %i)", plugin_id, midi_program_id);
 492
 493     static MidiProgramInfo info = { false, 0, 0, nullptr };
 494     info.valid = false;
 495
 496     for (unsigned short i=0; i<MAX_PLUGINS; i++)
 497     {
 498         AudioPlugin* plugin = AudioPlugins[i];
 499         if (plugin && plugin->id == plugin_id)
 500         {
 501             if (midi_program_id < plugin->midiprog.count)
 502             {
 503                 info.valid   = true;
 504                 info.bank    = plugin->midiprog.data[midi_program_id].bank;
 505                 info.program = plugin->midiprog.data[midi_program_id].program;
 506                 info.label   = plugin->midiprog.names[midi_program_id];
 507             }
 508             else
 509                 qCritical("get_midi_program_info(%i, %i) - midi_program_id out of bounds", plugin_id, midi_program_id);
 510
 511             return &info;
 512         }
 513     }
 514
 515     qCritical("get_midi_program_info(%i, %i) - could not find plugin", plugin_id, midi_program_id);
 516     return &info;
 517 }
 518
 519 ParameterData* get_parameter_data(unsigned short plugin_id, uint32_t parameter_id)
 520 {
 521     qDebug("get_parameter_data(%i, %i)", plugin_id, parameter_id);
 522
 523     static ParameterData data = { PARAMETER_UNKNOWN, -1, -1, 0, 0, -1 };
 524
 525     for (unsigned short i=0; i<MAX_PLUGINS; i++)
 526     {
 527         AudioPlugin* plugin = AudioPlugins[i];
 528         if (plugin && plugin->id == plugin_id)
 529         {
 530             if (parameter_id < plugin->param.count)
 531                 return &plugin->param.data[parameter_id];
 532             else
 533                 qCritical("get_parameter_data(%i, %i) - parameter_id out of bounds", plugin_id, parameter_id);
 534
 535             return &data;
 536         }
 537     }
 538
 539     qCritical("get_parameter_data(%i, %i) - could not find plugin", plugin_id, parameter_id);
 540     return &data;
 541 }
 542
 543 ParameterRanges* get_parameter_ranges(unsigned short plugin_id, uint32_t parameter_id)
 544 {
 545     qDebug("get_parameter_ranges(%i, %i)", plugin_id, parameter_id);
 546
 547     static ParameterRanges ranges = { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 };
 548
 549     for (unsigned short i=0; i<MAX_PLUGINS; i++)
 550     {
 551         AudioPlugin* plugin = AudioPlugins[i];
 552         if (plugin && plugin->id == plugin_id)
 553         {
 554             if (parameter_id < plugin->param.count)
 555                 return &plugin->param.ranges[parameter_id];
 556             else
 557                 qCritical("get_parameter_ranges(%i, %i) - parameter_id out of bounds", plugin_id, parameter_id);
 558
 559             return &ranges;
 560         }
 561     }
 562
 563     qCritical("get_parameter_ranges(%i, %i) - could not find plugin", plugin_id, parameter_id);
 564     return &ranges;
 565 }
 566
 567 CustomData* get_custom_data(unsigned short plugin_id, uint32_t custom_data_id)
 568 {
 569     qDebug("get_custom_data(%i, %i)", plugin_id, custom_data_id);
 570
 571     static CustomData data = { CUSTOM_DATA_INVALID, nullptr, nullptr };
 572
 573     for (unsigned short i=0; i<MAX_PLUGINS; i++)
 574     {
 575         AudioPlugin* plugin = AudioPlugins[i];
 576         if (plugin && plugin->id == plugin_id)
 577         {
 578             if (custom_data_id < (uint32_t)plugin->custom.count())
 579                 return &plugin->custom[custom_data_id];
 580             else
 581                 qCritical("get_custom_data(%i, %i) - custom_data_id out of bounds", plugin_id, custom_data_id);
 582
 583             return &data;
 584         }
 585     }
 586
 587     qCritical("get_custom_data(%i, %i) - could not find plugin", plugin_id, custom_data_id);
 588     return &data;
 589 }
 590
 591 const char* get_chunk_data(unsigned short plugin_id)
 592 {
 593     qDebug("get_chunk_data(%i)", plugin_id);
 594
 595     static const char* chunk_data = nullptr;
 596
 597     if (chunk_data)
 598         free((void*)chunk_data);
 599
 600     chunk_data = nullptr;
 601
 602     for (unsigned short i=0; i<MAX_PLUGINS; i++)
 603     {
 604         AudioPlugin* plugin = AudioPlugins[i];
 605         if (plugin && plugin->id == plugin_id)
 606         {
 607             if (plugin->hints & PLUGIN_USES_CHUNKS)
 608             {
 609                 void* data = nullptr;
 610                 int32_t data_size = plugin->get_chunk_data(&data);
 611
 612                 if (data && data_size >= 4)
 613                 {
 614                     QByteArray chunk((const char*)data, data_size);
 615                     chunk_data = strdup(chunk.toBase64().data());
 616                 }
 617                 else
 618                     qCritical("get_chunk_data(%i) - got invalid chunk data", plugin_id);
 619             }
 620             else
 621                 qCritical("get_chunk_data(%i) - plugin does not support chunks", plugin_id);
 622
 623             return chunk_data;
 624         }
 625     }
 626
 627     if (carla_is_engine_running())
 628         qCritical("get_chunk_data(%i) - could not find plugin", plugin_id);
 629
 630     return chunk_data;
 631 }
 632
 633 GuiData* get_gui_data(unsigned short plugin_id)
 634 {
 635     qDebug("get_gui_data(%i)", plugin_id);
 636
 637     static GuiData data = { GUI_NONE, false, false, 0, 0, nullptr, false };
 638
 639     for (unsigned short i=0; i<MAX_PLUGINS; i++)
 640     {
 641         AudioPlugin* plugin = AudioPlugins[i];
 642         if (plugin && plugin->id == plugin_id)
 643             return &plugin->gui;
 644     }
 645
 646     qCritical("get_gui_data(%i) - could not find plugin", plugin_id);
 647     return &data;
 648 }
 649
 650 uint32_t get_parameter_count(unsigned short plugin_id)
 651 {
 652     qDebug("get_parameter_count(%i)", plugin_id);
 653
 654     for (unsigned short i=0; i<MAX_PLUGINS; i++)
 655     {
 656         AudioPlugin* plugin = AudioPlugins[i];
 657         if (plugin && plugin->id == plugin_id)
 658             return plugin->param.count;
 659     }
 660
 661     qCritical("get_parameter_count(%i) - could not find plugin", plugin_id);
 662     return 0;
 663 }
 664
 665 uint32_t get_program_count(unsigned short plugin_id)
 666 {
 667     qDebug("get_program_count(%i)", plugin_id);
 668
 669     for (unsigned short i=0; i<MAX_PLUGINS; i++)
 670     {
 671         AudioPlugin* plugin = AudioPlugins[i];
 672         if (plugin && plugin->id == plugin_id)
 673             return plugin->prog.count;
 674     }
 675
 676     qCritical("get_program_count(%i) - could not find plugin", plugin_id);
 677     return 0;
 678 }
 679
 680 uint32_t get_midi_program_count(unsigned short plugin_id)
 681 {
 682     qDebug("get_midi_program_count(%i)", plugin_id);
 683
 684     for (unsigned short i=0; i<MAX_PLUGINS; i++)
 685     {
 686         AudioPlugin* plugin = AudioPlugins[i];
 687         if (plugin && plugin->id == plugin_id)
 688             return plugin->midiprog.count;
 689     }
 690
 691     qCritical("get_midi_program_count(%i) - could not find plugin", plugin_id);
 692     return 0;
 693 }
 694
 695 uint32_t get_custom_data_count(unsigned short plugin_id)
 696 {
 697     qDebug("get_custom_data_count(%i)", plugin_id);
 698
 699     for (unsigned short i=0; i<MAX_PLUGINS; i++)
 700     {
 701         AudioPlugin* plugin = AudioPlugins[i];
 702         if (plugin && plugin->id == plugin_id)
 703             return plugin->custom.count();
 704     }
 705
 706     qCritical("get_custom_data_count(%i) - could not find plugin", plugin_id);
 707     return 0;
 708 }
 709
 710 const char* get_program_name(unsigned short plugin_id, uint32_t program_id)
 711 {
 712     qDebug("get_program_name(%i, %i)", plugin_id, program_id);
 713
 714     for (unsigned short i=0; i<MAX_PLUGINS; i++)
 715     {
 716         AudioPlugin* plugin = AudioPlugins[i];
 717         if (plugin && plugin->id == plugin_id)
 718         {
 719             if (program_id < plugin->prog.count)
 720                 return plugin->prog.names[program_id];
 721             else
 722                 qCritical("get_program_name(%i, %i) - program_id out of bounds", plugin_id, program_id);
 723
 724             return nullptr;
 725         }
 726     }
 727
 728     qCritical("get_program_name(%i, %i) - could not find plugin", plugin_id, program_id);
 729     return nullptr;
 730 }
 731
 732 const char* get_midi_program_name(unsigned short plugin_id, uint32_t midi_program_id)
 733 {
 734     qDebug("get_midi_program_name(%i, %i)", plugin_id, midi_program_id);
 735
 736     for (unsigned short i=0; i<MAX_PLUGINS; i++)
 737     {
 738         AudioPlugin* plugin = AudioPlugins[i];
 739         if (plugin && plugin->id == plugin_id)
 740         {
 741             if (midi_program_id < plugin->midiprog.count)
 742                 return plugin->midiprog.names[midi_program_id];
 743             else
 744                 qCritical("get_midi_program_name(%i, %i) - program_id out of bounds", plugin_id, midi_program_id);
 745
 746             return nullptr;
 747         }
 748     }
 749
 750     qCritical("get_midi_program_name(%i, %i) - could not find plugin", plugin_id, midi_program_id);
 751     return nullptr;
 752 }
 753
 754 const char* get_real_plugin_name(unsigned short plugin_id)
 755 {
 756     qDebug("get_real_plugin_name(%i)", plugin_id);
 757
 758     static const char* real_plugin_name = nullptr;
 759
 760     if (real_plugin_name)
 761         free((void*)real_plugin_name);
 762
 763     real_plugin_name = nullptr;
 764
 765     for (unsigned short i=0; i<MAX_PLUGINS; i++)
 766     {
 767         AudioPlugin* plugin = AudioPlugins[i];
 768         if (plugin && plugin->id == plugin_id)
 769         {
 770             char buf_str[STR_MAX] = { 0 };
 771
 772             plugin->get_real_name(buf_str);
 773             real_plugin_name = strdup(buf_str);
 774
 775             return real_plugin_name;
 776         }
 777     }
 778
 779     if (carla_is_engine_running())
 780         qCritical("get_real_plugin_name(%i) - could not find plugin", plugin_id);
 781
 782     return real_plugin_name;
 783 }
 784
 785 int32_t get_current_program_index(unsigned short plugin_id)
 786 {
 787     qDebug("get_current_program_index(%i)", plugin_id);
 788
 789     for (unsigned short i=0; i<MAX_PLUGINS; i++)
 790     {
 791         AudioPlugin* plugin = AudioPlugins[i];
 792         if (plugin && plugin->id == plugin_id)
 793             return plugin->prog.current;
 794     }
 795
 796     qCritical("get_current_program_index(%i) - could not find plugin", plugin_id);
 797     return -1;
 798 }
 799
 800 int32_t get_current_midi_program_index(unsigned short plugin_id)
 801 {
 802     qDebug("get_current_midi_program_index(%i)", plugin_id);
 803
 804     for (unsigned short i=0; i<MAX_PLUGINS; i++)
 805     {
 806         AudioPlugin* plugin = AudioPlugins[i];
 807         if (plugin && plugin->id == plugin_id)
 808             return plugin->midiprog.current;
 809     }
 810
 811     qCritical("get_current_midi_program_index(%i) - could not find plugin", plugin_id);
 812     return -1;
 813 }
 814
 815 double get_default_parameter_value(unsigned short plugin_id, uint32_t parameter_id)
 816 {
 817     qDebug("get_default_parameter_value(%i, %i)", plugin_id, parameter_id);
 818
 819     for (unsigned short i=0; i<MAX_PLUGINS; i++)
 820     {
 821         AudioPlugin* plugin = AudioPlugins[i];
 822         if (plugin && plugin->id == plugin_id)
 823         {
 824             if (parameter_id < plugin->param.count)
 825                 return plugin->param.ranges[parameter_id].def;
 826             else
 827                 qCritical("get_default_parameter_value(%i, %i) - parameter_id out of bounds", plugin_id, parameter_id);
 828
 829             return 0.0;
 830         }
 831     }
 832
 833     qCritical("get_default_parameter_value(%i, %i) - could not find plugin", plugin_id, parameter_id);
 834     return 0.0;
 835 }
 836
 837 double get_current_parameter_value(unsigned short plugin_id, uint32_t parameter_id)
 838 {
 839     //qDebug("get_current_parameter_value(%i, %i)", plugin_id, parameter_id);
 840
 841     for (unsigned short i=0; i<MAX_PLUGINS; i++)
 842     {
 843         AudioPlugin* plugin = AudioPlugins[i];
 844         if (plugin && plugin->id == plugin_id)
 845         {
 846             if (parameter_id < plugin->param.count)
 847             {
 848                 double value = plugin->param.buffers[parameter_id];
 849
 850                 if (plugin->param.data[parameter_id].hints & PARAMETER_HAS_STRICT_BOUNDS)
 851                     plugin->fix_parameter_value(value, plugin->param.ranges[parameter_id]);
 852
 853                 return value;
 854             }
 855             else
 856                 qCritical("get_current_parameter_value(%i, %i) - parameter_id out of bounds", plugin_id, parameter_id);
 857
 858             return 0.0;
 859         }
 860     }
 861
 862     qCritical("get_current_parameter_value(%i, %i) - could not find plugin", plugin_id, parameter_id);
 863     return 0.0;
 864 }
 865
 866 double get_input_peak_value(unsigned short plugin_id, unsigned short port_id)
 867 {
 868     if (port_id == 1 || port_id == 2)
 869         return ains_peak[(plugin_id*2)+port_id-1];
 870     else
 871         return 0.0;
 872 }
 873
 874 double get_output_peak_value(unsigned short plugin_id, unsigned short port_id)
 875 {
 876     if (port_id == 1 || port_id == 2)
 877         return aouts_peak[(plugin_id*2)+port_id-1];
 878     else
 879         return 0.0;
 880 }
 881
 882 void set_active(unsigned short plugin_id, bool onoff)
 883 {
 884     qDebug("set_active(%i, %s)", plugin_id, bool2str(onoff));
 885
 886     for (unsigned short i=0; i<MAX_PLUGINS; i++)
 887     {
 888         AudioPlugin* plugin = AudioPlugins[i];
 889         if (plugin && plugin->id == plugin_id)
 890             return plugin->set_active(onoff, true, false);
 891     }
 892
 893     qCritical("set_active(%i, %s) - could not find plugin", plugin_id, bool2str(onoff));
 894 }
 895
 896 void set_drywet(unsigned short plugin_id, double value)
 897 {
 898     qDebug("set_drywet(%i, %f)", plugin_id, value);
 899
 900     for (unsigned short i=0; i<MAX_PLUGINS; i++)
 901     {
 902         AudioPlugin* plugin = AudioPlugins[i];
 903         if (plugin && plugin->id == plugin_id)
 904             return plugin->set_drywet(value, true, false);
 905     }
 906
 907     qCritical("set_drywet(%i, %f) - could not find plugin", plugin_id, value);
 908 }
 909
 910 void set_vol(unsigned short plugin_id, double value)
 911 {
 912     qDebug("set_vol(%i, %f)", plugin_id, value);
 913
 914     for (unsigned short i=0; i<MAX_PLUGINS; i++)
 915     {
 916         AudioPlugin* plugin = AudioPlugins[i];
 917         if (plugin && plugin->id == plugin_id)
 918             return plugin->set_vol(value, true, false);
 919     }
 920
 921     qCritical("set_vol(%i, %f) - could not find plugin", plugin_id, value);
 922 }
 923
 924 void set_balance_left(unsigned short plugin_id, double value)
 925 {
 926     qDebug("set_balance_left(%i, %f)", plugin_id, value);
 927
 928     for (unsigned short i=0; i<MAX_PLUGINS; i++)
 929     {
 930         AudioPlugin* plugin = AudioPlugins[i];
 931         if (plugin && plugin->id == plugin_id)
 932             return plugin->set_balance_left(value, true, false);
 933     }
 934
 935     qCritical("set_balance_left(%i, %f) - could not find plugin", plugin_id, value);
 936 }
 937
 938 void set_balance_right(unsigned short plugin_id, double value)
 939 {
 940     qDebug("set_balance_right(%i, %f)", plugin_id, value);
 941
 942     for (unsigned short i=0; i<MAX_PLUGINS; i++)
 943     {
 944         AudioPlugin* plugin = AudioPlugins[i];
 945         if (plugin && plugin->id == plugin_id)
 946             return plugin->set_balance_right(value, true, false);
 947     }
 948
 949     qCritical("set_balance_right(%i, %f) - could not find plugin", plugin_id, value);
 950 }
 951
 952 void set_parameter_value(unsigned short plugin_id, uint32_t parameter_id, double value)
 953 {
 954     qDebug("set_parameter_value(%i, %i, %f)", plugin_id, parameter_id, value);
 955
 956     for (unsigned short i=0; i<MAX_PLUGINS; i++)
 957     {
 958         AudioPlugin* plugin = AudioPlugins[i];
 959         if (plugin && plugin->id == plugin_id)
 960         {
 961             if (parameter_id < plugin->param.count)
 962                 plugin->set_parameter_value(parameter_id, value, true, true, false);
 963             else
 964                 qCritical("set_parameter_value(%i, %i, %f) - parameter_id out of bounds", plugin_id, parameter_id, value);
 965
 966             return;
 967         }
 968     }
 969
 970     qCritical("set_parameter_value(%i, %i, %f) - could not find plugin", plugin_id, parameter_id, value);
 971 }
 972
 973 void set_parameter_midi_channel(unsigned short plugin_id, uint32_t parameter_id, uint8_t channel)
 974 {
 975     qDebug("set_parameter_midi_channel(%i, %i, %i)", plugin_id, parameter_id, channel);
 976
 977     if (channel > 15)
 978     {
 979         qCritical("set_parameter_midi_channel(%i, %i, %i) - invalid channel number", plugin_id, parameter_id, channel);
 980         return;
 981     }
 982
 983     for (unsigned short i=0; i<MAX_PLUGINS; i++)
 984     {
 985         AudioPlugin* plugin = AudioPlugins[i];
 986         if (plugin && plugin->id == plugin_id)
 987         {
 988             if (parameter_id < plugin->param.count)
 989             {
 990                 plugin->param.data[parameter_id].midi_channel = channel;
 991
 992                 if (plugin->hints & PLUGIN_IS_BRIDGE)
 993                     osc_send_set_parameter_midi_channel(&plugin->osc.data, plugin->id, parameter_id, channel);
 994             }
 995             else
 996                 qCritical("set_parameter_midi_channel(%i, %i, %i) - parameter_id out of bounds", plugin_id, parameter_id, channel);
 997
 998             return;
 999         }
1000     }
1001
1002     qCritical("set_parameter_midi_channel(%i, %i, %i) - could not find plugin", plugin_id, parameter_id, channel);
1003 }
1004
1005 void set_parameter_midi_cc(unsigned short plugin_id, uint32_t parameter_id, int16_t midi_cc)
1006 {
1007     qDebug("set_parameter_midi_cc(%i, %i, %i)", plugin_id, parameter_id, midi_cc);
1008
1009     if (midi_cc < -1)
1010     {
1011         midi_cc = -1;
1012     }
1013     else if (midi_cc > 0x5F) // 95
1014     {
1015         qCritical("set_parameter_midi_cc(%i, %i, %i) - invalid midi_cc number", plugin_id, parameter_id, midi_cc);
1016         return;
1017     }
1018
1019     for (unsigned short i=0; i<MAX_PLUGINS; i++)
1020     {
1021         AudioPlugin* plugin = AudioPlugins[i];
1022         if (plugin && plugin->id == plugin_id)
1023         {
1024             if (parameter_id < plugin->param.count)
1025             {
1026                 plugin->param.data[parameter_id].midi_cc = midi_cc;
1027
1028                 if (plugin->hints & PLUGIN_IS_BRIDGE)
1029                     osc_send_set_parameter_midi_cc(&plugin->osc.data, plugin->id, parameter_id, midi_cc);
1030             }
1031             else
1032                 qCritical("set_parameter_midi_cc(%i, %i, %i) - parameter_id out of bounds", plugin_id, parameter_id, midi_cc);
1033
1034             return;
1035         }
1036     }
1037
1038     qCritical("set_parameter_midi_cc(%i, %i, %i) - could not find plugin", plugin_id, parameter_id, midi_cc);
1039 }
1040
1041 void set_program(unsigned short plugin_id, uint32_t program_id)
1042 {
1043     qDebug("set_program(%i, %i)", plugin_id, program_id);
1044
1045     for (unsigned short i=0; i<MAX_PLUGINS; i++)
1046     {
1047         AudioPlugin* plugin = AudioPlugins[i];
1048         if (plugin && plugin->id == plugin_id)
1049         {
1050             if (program_id < plugin->prog.count)
1051                 plugin->set_program(program_id, true, true, false, true);
1052             else
1053                 qCritical("set_program(%i, %i) - program_id out of bounds", plugin_id, program_id);
1054
1055             return;
1056         }
1057     }
1058
1059     qCritical("set_program(%i, %i) - could not find plugin", plugin_id, program_id);
1060 }
1061
1062 void set_midi_program(unsigned short plugin_id, uint32_t midi_program_id)
1063 {
1064     qDebug("set_midi_program(%i, %i)", plugin_id, midi_program_id);
1065
1066     for (unsigned short i=0; i<MAX_PLUGINS; i++)
1067     {
1068         AudioPlugin* plugin = AudioPlugins[i];
1069         if (plugin && plugin->id == plugin_id)
1070         {
1071             if (midi_program_id < plugin->midiprog.count)
1072                 plugin->set_midi_program(midi_program_id, true, true, false, true);
1073             else
1074                 qCritical("set_midi_program(%i, %i) - program_id out of bounds", plugin_id, midi_program_id);
1075
1076             return;
1077         }
1078     }
1079
1080     qCritical("set_midi_program(%i, %i) - could not find plugin", plugin_id, midi_program_id);
1081 }
1082
1083 void set_custom_data(unsigned short plugin_id, CustomDataType type, const char* key, const char* value)
1084 {
1085     qDebug("set_custom_data(%i, %i, %s, %s)", plugin_id, type, key, value);
1086
1087     for (unsigned short i=0; i<MAX_PLUGINS; i++)
1088     {
1089         AudioPlugin* plugin = AudioPlugins[i];
1090         if (plugin && plugin->id == plugin_id)
1091             return plugin->set_custom_data(type, key, value, true);
1092     }
1093
1094     qCritical("set_custom_data(%i, %i, %s, %s) - could not find plugin", plugin_id, type, key, value);
1095 }
1096
1097 void set_chunk_data(unsigned short plugin_id, const char* chunk_data)
1098 {
1099     qDebug("set_chunk_data(%i, %s)", plugin_id, chunk_data);
1100
1101     for (unsigned short i=0; i<MAX_PLUGINS; i++)
1102     {
1103         AudioPlugin* plugin = AudioPlugins[i];
1104         if (plugin && plugin->id == plugin_id)
1105         {
1106             if (plugin->hints & PLUGIN_USES_CHUNKS)
1107                 plugin->set_chunk_data(chunk_data);
1108             else
1109                 qCritical("set_chunk_data(%i, %s) - plugin does not support chunks", plugin_id, chunk_data);
1110
1111             return;
1112         }
1113     }
1114
1115     qCritical("set_chunk_data(%i, %s) - could not find plugin", plugin_id, chunk_data);
1116 }
1117
1118 void set_gui_data(unsigned short plugin_id, int data, intptr_t gui_addr)
1119 {
1120     qDebug("set_gui_data(%i, %i, " P_INTPTR ")", plugin_id, data, gui_addr);
1121
1122     for (unsigned short i=0; i<MAX_PLUGINS; i++)
1123     {
1124         AudioPlugin* plugin = AudioPlugins[i];
1125         if (plugin && plugin->id == plugin_id)
1126         {
1127             if (plugin->gui.type != GUI_NONE)
1128                 plugin->set_gui_data(data, get_pointer(gui_addr));
1129             else
1130                 qCritical("set_gui_data(%i, %i, " P_INTPTR ") - plugin has no UI", plugin_id, data, gui_addr);
1131
1132             return;
1133         }
1134     }
1135
1136     qCritical("set_gui_data(%i, %i, " P_INTPTR ") - could not find plugin", plugin_id, data, gui_addr);
1137 }
1138
1139 void show_gui(unsigned short plugin_id, bool yesno)
1140 {
1141     qDebug("show_gui(%i, %s)", plugin_id, bool2str(yesno));
1142
1143     for (unsigned short i=0; i<MAX_PLUGINS; i++)
1144     {
1145         AudioPlugin* plugin = AudioPlugins[i];
1146         if (plugin && plugin->id == plugin_id)
1147         {
1148             plugin->show_gui(yesno);
1149             return;
1150         }
1151     }
1152
1153     qCritical("show_gui(%i, %s) - could not find plugin", plugin_id, bool2str(yesno));
1154 }
1155
1156 void idle_gui(unsigned short plugin_id)
1157 {
1158     qDebug("idle_gui(%i)", plugin_id);
1159
1160     for (unsigned short i=0; i<MAX_PLUGINS; i++)
1161     {
1162         AudioPlugin* plugin = AudioPlugins[i];
1163         if (plugin && plugin->id == plugin_id)
1164         {
1165             plugin->idle_gui();
1166             return;
1167         }
1168     }
1169
1170     qCritical("idle_gui(%i) - could not find plugin", plugin_id);
1171 }
1172
1173 void send_midi_note(unsigned short plugin_id, bool onoff, uint8_t note, uint8_t velocity)
1174 {
1175     qDebug("send_midi_note(%i, %s, %i, %i)", plugin_id, bool2str(onoff), note, velocity);
1176
1177     for (unsigned short i=0; i<MAX_PLUGINS; i++)
1178     {
1179         AudioPlugin* plugin = AudioPlugins[i];
1180         if (plugin && plugin->id == plugin_id)
1181             return send_plugin_midi_note(plugin_id, onoff, note, velocity, true, true, false);
1182     }
1183
1184     qCritical("send_midi_note(%i, %s, %i, %i) - could not find plugin", plugin_id, bool2str(onoff), note, velocity);
1185 }
1186
1187 void prepare_for_save(unsigned short plugin_id)
1188 {
1189     qDebug("prepare_for_save(%i)", plugin_id);
1190
1191     for (unsigned short i=0; i<MAX_PLUGINS; i++)
1192     {
1193         AudioPlugin* plugin = AudioPlugins[i];
1194         if (plugin && plugin->id == plugin_id)
1195             return plugin->prepare_for_save();
1196     }
1197
1198     qCritical("prepare_for_save(%i) - could not find plugin", plugin_id);
1199 }
1200
1201 void set_callback_function(CallbackFunc func)
1202 {
1203     qDebug("set_callback_function(%p)", func);
1204     Callback = func;
1205 }
1206
1207 void set_option(OptionsType option, int value, const char* value_str)
1208 {
1209     qDebug("set_option(%i, %i, %s)", option, value, value_str);
1210
1211     if (carla_options._initiated)
1212         return;
1213
1214     switch(option)
1215     {
1216     case OPTION_GLOBAL_JACK_CLIENT:
1217         carla_options.global_jack_client = value;
1218         break;
1219     case OPTION_BRIDGE_PATH_LV2_GTK2:
1220         if (value_str) carla_options.bridge_path_lv2_gtk2 = strdup(value_str);
1221         break;
1222     case OPTION_BRIDGE_PATH_LV2_QT4:
1223         if (value_str) carla_options.bridge_path_lv2_qt4 = strdup(value_str);
1224         break;
1225     case OPTION_BRIDGE_PATH_LV2_X11:
1226         if (value_str) carla_options.bridge_path_lv2_x11 = strdup(value_str);
1227         break;
1228     case OPTION_BRIDGE_PATH_VST_QT4:
1229         if (value_str) carla_options.bridge_path_vst_qt4 = strdup(value_str);
1230         break;
1231     case OPTION_BRIDGE_PATH_WINVST:
1232         if (value_str) carla_options.bridge_path_winvst = strdup(value_str);
1233         break;
1234     default:
1235         break;
1236     }
1237 }
1238
1239 const char* get_last_error()
1240 {
1241     qDebug("get_last_error()");
1242     return last_error;
1243 }
1244
1245 const char* get_host_client_name()
1246 {
1247     qDebug("get_host_client_name()");
1248     return carla_client_name;
1249 }
1250
1251 const char* get_host_osc_url()
1252 {
1253     qDebug("get_host_osc_url()");
1254     return global_osc_server_path;
1255 }
1256
1257 uint32_t get_buffer_size()
1258 {
1259     qDebug("get_buffer_size()");
1260     return carla_buffer_size;
1261 }
1262
1263 double get_sample_rate()
1264 {
1265     qDebug("get_sample_rate()");
1266     return carla_sample_rate;
1267 }
1268
1269 double get_latency()
1270 {
1271     qDebug("get_latency()");
1272     return double(carla_buffer_size)/carla_sample_rate*1000;
1273 }
1274 // End of exported symbols (API)
1275 // -------------------------------------------------------------------------------------------------------------------
1276
1277 // -------------------------------------------------------------------------------------------------------------------
1278 // Helper functions
1279
1280 short get_new_plugin_id()
1281 {
1282     for (unsigned short i=0; i<MAX_PLUGINS; i++)
1283     {
1284         if (!AudioPlugins[i])
1285             return i;
1286     }
1287
1288     return -1;
1289 }
1290
1291 const char* get_unique_name(const char* name)
1292 {
1293     QString qname(name);
1294     qname.replace(":", "."); // ":" is used in JACK to split client/port names
1295
1296     for (unsigned short i=0; i<MAX_PLUGINS; i++)
1297     {
1298         // Check if unique name already exists
1299         if (unique_names[i] && qname == unique_names[i])
1300         {
1301             // Check if string has already been modified
1302             uint len = qname.size();
1303
1304             if (qname.at(len-3) == QChar('(') && qname.at(len-2).isDigit() && qname.at(len-1) == QChar(')'))
1305             {
1306                 int number = qname.at(len-2).toAscii()-'0';
1307
1308                 if (number == 9)
1309                     // next number is 10, 2 digits
1310                     qname.replace(" (9)", " (10)");
1311                 else
1312                     qname[len-2] = QChar('0'+number+1);
1313
1314                 continue;
1315             }
1316             else if (qname.at(len-4) == QChar('(') && qname.at(len-3).isDigit() && qname.at(len-2).isDigit() && qname.at(len-1) == QChar(')'))
1317             {
1318                 QChar n2 = qname.at(len-2); // (1x)
1319                 QChar n3 = qname.at(len-3); // (x0)
1320
1321                 if (n2 == QChar('9'))
1322                 {
1323                     n2 = QChar('0');
1324                     n3 = QChar(n3.toAscii()+1);
1325                 } else
1326                     n2 = QChar(n2.toAscii()+1);
1327
1328                 qname[len-2] = n2;
1329                 qname[len-3] = n3;
1330
1331                 continue;
1332             }
1333
1334             // Modify string if not
1335             qname += " (2)";
1336         }
1337     }
1338
1339     return strdup(qname.toStdString().data());
1340 }
1341
1342 void* get_pointer(intptr_t ptr_addr)
1343 {
1344     intptr_t* ptr = (intptr_t*)ptr_addr;
1345     return (void*)ptr;
1346 }
1347
1348 void set_last_error(const char* error)
1349 {
1350     if (last_error)
1351         free((void*)last_error);
1352
1353     last_error = strdup(error);
1354 }
1355
1356 void callback_action(CallbackType action, unsigned short plugin_id, int value1, int value2, double value3)
1357 {
1358     if (Callback)
1359         Callback(action, plugin_id, value1, value2, value3);
1360 }
1361
1362 void carla_proc_lock()
1363 {
1364     carla_proc_lock_var.lock();
1365 }
1366
1367 bool carla_proc_trylock()
1368 {
1369     return carla_proc_lock_var.tryLock();
1370 }
1371
1372 void carla_proc_unlock()
1373 {
1374     carla_proc_lock_var.unlock();
1375 }
1376
1377 void carla_midi_lock()
1378 {
1379     carla_midi_lock_var.lock();
1380 }
1381
1382 void carla_midi_unlock()
1383 {
1384     carla_midi_lock_var.unlock();
1385 }
1386
1387 void send_plugin_midi_note(unsigned short plugin_id, bool onoff, uint8_t note, uint8_t velo, bool gui_send, bool osc_send, bool callback_send)
1388 {
1389     carla_midi_lock();
1390     for (unsigned int i=0; i<MAX_MIDI_EVENTS; i++)
1391     {
1392         if (ExternalMidiNotes[i].valid == false)
1393         {
1394             ExternalMidiNotes[i].valid = true;
1395             ExternalMidiNotes[i].plugin_id = plugin_id;
1396             ExternalMidiNotes[i].onoff = onoff;
1397             ExternalMidiNotes[i].note = note;
1398             ExternalMidiNotes[i].velo = velo;
1399             break;
1400         }
1401     }
1402     carla_midi_unlock();
1403
1404     if (gui_send)
1405     {
1406         // TODO - send midi note to GUI?
1407     }
1408
1409     if (osc_send)
1410     {
1411         if (onoff)
1412             osc_send_note_on(&AudioPlugins[plugin_id]->osc.data, plugin_id, note, velo);
1413         else
1414             osc_send_note_off(&AudioPlugins[plugin_id]->osc.data, plugin_id, note, velo);
1415     }
1416
1417     if (callback_send)
1418         callback_action(onoff ? CALLBACK_NOTE_ON : CALLBACK_NOTE_OFF, plugin_id, note, velo, 0.0);
1419 }
1420 // End of helper functions
1421 // -------------------------------------------------------------------------------------------------------------------