src/carla/dssi.cpp

   1 /* Code for DSSI plugins */
   2
   3 #include "carla_backend.h"
   4 #include "audio_plugin.h"
   5 #include "misc.h"
   6
   7 #include <math.h>
   8 #include <unistd.h>
   9
  10 #include "dssi/dssi+chunks.h"
  11
  12 // Global variables
  13 extern const char* unique_names[MAX_PLUGINS];
  14 extern AudioPlugin* AudioPlugins[MAX_PLUGINS];
  15 extern ExternalMidiNote ExternalMidiNotes[MAX_MIDI_EVENTS];
  16
  17 extern volatile double ains_peak[MAX_PLUGINS*2];
  18 extern volatile double aouts_peak[MAX_PLUGINS*2];
  19
  20 // Global JACK client
  21 extern jack_client_t* carla_jack_client;
  22
  23 // Global options
  24 extern carla_options_t carla_options;
  25
  26 // jack.cpp
  27 void carla_jack_register_plugin(AudioPlugin* plugin);
  28
  29 class DssiOscGuiThread : public QThread
  30 {
  31 public:
  32     DssiOscGuiThread(QObject* parent=0);
  33     void set_plugin_id(short plugin_id);
  34     void run();
  35
  36 private:
  37     short plugin_id;
  38 };
  39
  40 class DssiAudioPlugin : public AudioPlugin
  41 {
  42 public:
  43     LADSPA_Handle handle;
  44     const LADSPA_Descriptor* ldescriptor;
  45     const DSSI_Descriptor* descriptor;
  46     snd_seq_event_t midi_events[MAX_MIDI_EVENTS];
  47
  48     DssiAudioPlugin()
  49     {
  50         qDebug("DssiAudioPlugin::DssiAudioPlugin()");
  51         type = PLUGIN_DSSI;
  52
  53         handle = nullptr;
  54         descriptor = nullptr;
  55         ldescriptor = nullptr;
  56
  57         for (unsigned int i=0; i<MAX_MIDI_EVENTS; i++)
  58             memset(&midi_events[i], 0, sizeof(snd_seq_event_t));
  59     }
  60
  61     ~DssiAudioPlugin()
  62     {
  63         qDebug("DssiAudioPlugin::~DssiAudioPlugin()");
  64
  65         // close UI
  66         if (hints & PLUGIN_HAS_GUI)
  67         {
  68             if (gui.visible)
  69                 osc_send_hide(&osc.data);
  70
  71             osc_send_quit(&osc.data);
  72
  73             if (osc.thread)
  74             {
  75                 osc.thread->quit();
  76
  77                 if (!osc.thread->wait(3000)) // 3 sec
  78                     qWarning("Failed to properly stop DSSI GUI thread");
  79
  80                 delete osc.thread;
  81             }
  82
  83             osc_clear_data(&osc.data);
  84         }
  85
  86         if (handle && ldescriptor->deactivate && active_before)
  87             ldescriptor->deactivate(handle);
  88
  89         if (handle && ldescriptor->cleanup)
  90             ldescriptor->cleanup(handle);
  91     }
  92
  93     void delete_me()
  94     {
  95         qDebug("DssiAudioPlugin::delete_me()");
  96         delete this;
  97     }
  98
  99     int set_osc_bridge_info(PluginOscBridgeInfoType, lo_arg**)
 100     {
 101         return 1;
 102     }
 103
 104     PluginCategory get_category()
 105     {
 106         if (min.count > 0 && aout.count > 0)
 107             return PLUGIN_CATEGORY_SYNTH;
 108         else
 109             return PLUGIN_CATEGORY_NONE;
 110     }
 111
 112     void get_label(char* buf_str)
 113     {
 114         strncpy(buf_str, ldescriptor->Label, STR_MAX);
 115     }
 116
 117     void get_maker(char* buf_str)
 118     {
 119         strncpy(buf_str, ldescriptor->Maker, STR_MAX);
 120     }
 121
 122     void get_copyright(char* buf_str)
 123     {
 124         strncpy(buf_str, ldescriptor->Copyright, STR_MAX);
 125     }
 126
 127     void get_real_name(char* buf_str)
 128     {
 129         strncpy(buf_str, ldescriptor->Name, STR_MAX);
 130     }
 131
 132     long get_unique_id()
 133     {
 134         return ldescriptor->UniqueID;
 135     }
 136
 137     void get_parameter_name(uint32_t rindex, char* buf_str)
 138     {
 139         strncpy(buf_str, ldescriptor->PortNames[rindex], STR_MAX);
 140     }
 141
 142     void get_parameter_symbol(uint32_t, char* buf_str)
 143     {
 144         *buf_str = 0;
 145     }
 146
 147     void get_parameter_label(uint32_t, char* buf_str)
 148     {
 149         *buf_str = 0;
 150     }
 151
 152     uint32_t get_scalepoint_count(uint32_t)
 153     {
 154         return 0;
 155     }
 156
 157     double get_scalepoint_value(uint32_t, uint32_t)
 158     {
 159         return 0.0;
 160     }
 161
 162     void get_scalepoint_label(uint32_t, uint32_t, char* buf_str)
 163     {
 164         *buf_str = 0;
 165     }
 166
 167     int32_t get_chunk_data(void** data_ptr)
 168     {
 169         unsigned long long_data_size = 0;
 170         if (descriptor->getCustomData(handle, data_ptr, &long_data_size))
 171             return long_data_size;
 172         else
 173             return 0;
 174     }
 175
 176     void x_set_parameter_value(uint32_t parameter_id, double value, bool gui_send)
 177     {
 178         if (gui_send && gui.visible)
 179             osc_send_control(&osc.data, param.data[parameter_id].rindex, value);
 180     }
 181
 182     void x_set_program(uint32_t, bool, bool)
 183     {
 184     }
 185
 186     void x_set_midi_program(uint32_t midi_program_id, bool gui_send, bool block)
 187     {
 188         if (!descriptor->get_program || !descriptor->select_program)
 189             return;
 190
 191         if (block) carla_proc_lock();
 192         descriptor->select_program(handle, midiprog.data[midi_program_id].bank, midiprog.data[midi_program_id].program);
 193         if (block) carla_proc_unlock();
 194
 195         if (gui_send && gui.visible)
 196             osc_send_program_as_midi(&osc.data, midiprog.data[midi_program_id].bank, midiprog.data[midi_program_id].program);
 197     }
 198
 199     void x_set_custom_data(CustomDataType, const char* key, const char* value, bool gui_send)
 200     {
 201         descriptor->configure(handle, key, value);
 202
 203         if (gui_send && gui.visible)
 204             osc_send_configure(&osc.data, key, value);
 205
 206         if (strcmp(key, "reloadprograms") == 0 || strcmp(key, "load") == 0 || strncmp(key, "patches", 7) == 0)
 207         {
 208             reload_programs(false);
 209         }
 210         else if (strcmp(key, "names") == 0) // Not in the API!
 211         {
 212             if (prog.count > 0)
 213             {
 214                 osc_send_set_program_count(&osc.data, id, prog.count);
 215
 216                 // Parse names
 217                 int j, k, last_str_n = 0;
 218                 int str_len = strlen(value);
 219                 char name[256];
 220
 221                 for (uint32_t i=0; i < prog.count; i++)
 222                 {
 223                     for (j=0, k=last_str_n; j<256 && k+j<str_len; j++)
 224                     {
 225                         name[j] = value[k+j];
 226                         if (value[k+j] == ',')
 227                         {
 228                             name[j] = 0;
 229                             last_str_n = k+j+1;
 230                             free((void*)prog.names[i]);
 231                             prog.names[i] = strdup(name);
 232                             break;
 233                         }
 234                     }
 235
 236                     osc_send_set_program_name(&osc.data, id, i, prog.names[i]);
 237                 }
 238
 239                 callback_action(CALLBACK_RELOAD_PROGRAMS, id, 0, 0, 0.0f);
 240             }
 241         }
 242     }
 243
 244     void set_chunk_data(const char* string_data)
 245     {
 246         QByteArray chunk = QByteArray::fromBase64(string_data);
 247         descriptor->setCustomData(handle, chunk.data(), chunk.size());
 248     }
 249
 250     void set_gui_data(int, void*)
 251     {
 252     }
 253
 254     void show_gui(bool yesno)
 255     {
 256         if (yesno)
 257         {
 258             gui.show_now = true;
 259
 260             // 40 re-tries, 4 secs
 261             for (int j=1; j<40 && gui.show_now; j++)
 262             {
 263                 if (osc.data.target)
 264                 {
 265                     osc_send_show(&osc.data);
 266                     gui.visible = true;
 267                     return;
 268                 }
 269                 else
 270                     // 100 ms
 271                     usleep(100000);
 272             }
 273
 274             qDebug("DssiAudioPlugin::show_gui() - GUI timeout");
 275             callback_action(CALLBACK_SHOW_GUI, id, 0, 0, 0.0);
 276         }
 277         else
 278         {
 279             gui.visible = false;
 280             osc_send_hide(&osc.data);
 281             osc_send_quit(&osc.data);
 282             osc_clear_data(&osc.data);
 283         }
 284     }
 285
 286     void idle_gui()
 287     {
 288     }
 289
 290     void reload()
 291     {
 292         qDebug("DssiAudioPlugin::reload()");
 293         short _id = id;
 294
 295         // Safely disable plugin for reload
 296         carla_proc_lock();
 297
 298         id = -1;
 299         if (carla_options.global_jack_client == false)
 300             jack_deactivate(jack_client);
 301
 302         carla_proc_unlock();
 303
 304         // Unregister jack ports
 305         remove_from_jack();
 306
 307         // Delete old data
 308         delete_buffers();
 309
 310         uint32_t ains, aouts, mins, params, j;
 311         ains = aouts = mins = params = 0;
 312
 313         const unsigned long PortCount = ldescriptor->PortCount;
 314         for (unsigned long i=0; i<PortCount; i++)
 315         {
 316             LADSPA_PortDescriptor PortType = ldescriptor->PortDescriptors[i];
 317             if (LADSPA_IS_PORT_AUDIO(PortType))
 318             {
 319                 if (LADSPA_IS_PORT_INPUT(PortType))
 320                     ains += 1;
 321                 else if (LADSPA_IS_PORT_OUTPUT(PortType))
 322                     aouts += 1;
 323             }
 324             else if (LADSPA_IS_PORT_CONTROL(PortType))
 325                 params += 1;
 326         }
 327
 328         if (descriptor->run_synth || descriptor->run_multiple_synths)
 329             mins = 1;
 330
 331         if (ains > 0)
 332         {
 333             ain.rindexes = new uint32_t[ains];
 334             ain.ports    = new jack_port_t*[ains];
 335         }
 336
 337         if (aouts > 0)
 338         {
 339             aout.rindexes = new uint32_t[aouts];
 340             aout.ports    = new jack_port_t*[aouts];
 341         }
 342
 343         if (mins > 0)
 344         {
 345             min.ports = new jack_port_t*[mins];
 346         }
 347
 348         if (params > 0)
 349         {
 350             param.buffers = new float[params];
 351             param.data    = new ParameterData[params];
 352             param.ranges  = new ParameterRanges[params];
 353         }
 354
 355         const int port_name_size = jack_port_name_size();
 356         char port_name[port_name_size];
 357         bool needs_cin  = false;
 358         bool needs_cout = false;
 359
 360         for (unsigned long i=0; i<PortCount; i++)
 361         {
 362             LADSPA_PortDescriptor PortType = ldescriptor->PortDescriptors[i];
 363             LADSPA_PortRangeHint PortHint  = ldescriptor->PortRangeHints[i];
 364
 365             if (LADSPA_IS_PORT_AUDIO(PortType))
 366             {
 367                 if (carla_options.global_jack_client)
 368                 {
 369                     strncpy(port_name, name, (port_name_size/2)-2);
 370                     strcat(port_name, ":");
 371                     strncat(port_name, ldescriptor->PortNames[i], port_name_size/2);
 372                 }
 373                 else
 374                     strncpy(port_name, ldescriptor->PortNames[i], port_name_size);
 375
 376                 if (LADSPA_IS_PORT_INPUT(PortType))
 377                 {
 378                     j = ain.count++;
 379                     ain.ports[j] = jack_port_register(jack_client, port_name, JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0);
 380                     ain.rindexes[j] = i;
 381                 }
 382                 else if (LADSPA_IS_PORT_OUTPUT(PortType))
 383                 {
 384                     j = aout.count++;
 385                     aout.ports[j] = jack_port_register(jack_client, port_name, JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0);
 386                     aout.rindexes[j] = i;
 387                     needs_cin = true;
 388                 }
 389                 else
 390                     qWarning("WARNING - Got a broken Port (Audio, but not input or output)");
 391             }
 392             else if (LADSPA_IS_PORT_CONTROL(PortType))
 393             {
 394                 j = param.count++;
 395                 param.data[j].index  = j;
 396                 param.data[j].rindex = i;
 397                 param.data[j].hints  = 0;
 398                 param.data[j].midi_channel = 0;
 399                 param.data[j].midi_cc = -1;
 400
 401                 double min, max, def, step, step_small, step_large;
 402
 403                 // min value
 404                 if (LADSPA_IS_HINT_BOUNDED_BELOW(PortHint.HintDescriptor))
 405                     min = PortHint.LowerBound;
 406                 else
 407                     min = 0.0;
 408
 409                 // max value
 410                 if (LADSPA_IS_HINT_BOUNDED_ABOVE(PortHint.HintDescriptor))
 411                     max = PortHint.UpperBound;
 412                 else
 413                     max = 1.0;
 414
 415                 if (min > max)
 416                     max = min;
 417                 else if (max < min)
 418                     min = max;
 419
 420                 // default value
 421                 if (LADSPA_IS_HINT_HAS_DEFAULT(PortHint.HintDescriptor))
 422                 {
 423                     switch (PortHint.HintDescriptor & LADSPA_HINT_DEFAULT_MASK)
 424                     {
 425                     case LADSPA_HINT_DEFAULT_MINIMUM:
 426                         def = min;
 427                         break;
 428                     case LADSPA_HINT_DEFAULT_MAXIMUM:
 429                         def = max;
 430                         break;
 431                     case LADSPA_HINT_DEFAULT_0:
 432                         def = 0.0;
 433                         break;
 434                     case LADSPA_HINT_DEFAULT_1:
 435                         def = 1.0;
 436                         break;
 437                     case LADSPA_HINT_DEFAULT_100:
 438                         def = 100.0;
 439                         break;
 440                     case LADSPA_HINT_DEFAULT_440:
 441                         def = 440.0;
 442                         break;
 443                     case LADSPA_HINT_DEFAULT_LOW:
 444                         if (LADSPA_IS_HINT_LOGARITHMIC(PortHint.HintDescriptor))
 445                             def = exp((log(min)*0.75) + (log(max)*0.25));
 446                         else
 447                             def = (min*0.75) + (max*0.25);
 448                         break;
 449                     case LADSPA_HINT_DEFAULT_MIDDLE:
 450                         if (LADSPA_IS_HINT_LOGARITHMIC(PortHint.HintDescriptor))
 451                             def = sqrt(min*max);
 452                         else
 453                             def = (min+max)/2;
 454                         break;
 455                     case LADSPA_HINT_DEFAULT_HIGH:
 456                         if (LADSPA_IS_HINT_LOGARITHMIC(PortHint.HintDescriptor))
 457                             def = exp((log(min)*0.25) + (log(max)*0.75));
 458                         else
 459                             def = (min*0.25) + (max*0.75);
 460                         break;
 461                     default:
 462                         if (min < 0.0 && max > 0.0)
 463                             def = 0.0;
 464                         else
 465                             def = min;
 466                         break;
 467                     }
 468                 }
 469                 else
 470                 {
 471                     // no default value
 472                     if (min < 0.0 && max > 0.0)
 473                         def = 0.0;
 474                     else
 475                         def = min;
 476                 }
 477
 478                 if (def < min)
 479                     def = min;
 480                 else if (def > max)
 481                     def = max;
 482
 483                 if (max - min == 0.0)
 484                 {
 485                     qWarning("Broken plugin parameter -> max - min == 0");
 486                     max = min + 0.1;
 487                 }
 488
 489                 if (LADSPA_IS_HINT_SAMPLE_RATE(PortHint.HintDescriptor))
 490                 {
 491                     double sample_rate = get_sample_rate();
 492                     min *= sample_rate;
 493                     max *= sample_rate;
 494                     def *= sample_rate;
 495                     param.data[j].hints |= PARAMETER_USES_SAMPLERATE;
 496                 }
 497
 498                 if (LADSPA_IS_HINT_INTEGER(PortHint.HintDescriptor))
 499                 {
 500                     step = 1.0;
 501                     step_small = 1.0;
 502                     step_large = 10.0;
 503                 }
 504                 else if (LADSPA_IS_HINT_TOGGLED(PortHint.HintDescriptor))
 505                 {
 506                     step = max - min;
 507                     step_small = step;
 508                     step_large = step;
 509                 }
 510                 else
 511                 {
 512                     double range = max - min;
 513                     step = range/100.0;
 514                     step_small = range/1000.0;
 515                     step_large = range/10.0;
 516                 }
 517
 518                 if (LADSPA_IS_PORT_INPUT(PortType))
 519                 {
 520                     param.data[j].type = PARAMETER_INPUT;
 521                     param.data[j].hints |= PARAMETER_IS_ENABLED;
 522                     param.data[j].hints |= PARAMETER_IS_AUTOMABLE;
 523                     needs_cin = true;
 524
 525                     // MIDI CC value
 526                     if (descriptor->get_midi_controller_for_port)
 527                     {
 528                         int cc = descriptor->get_midi_controller_for_port(handle, i);
 529                         if (DSSI_CONTROLLER_IS_SET(cc) && DSSI_IS_CC(cc))
 530                             param.data[j].midi_cc = DSSI_CC_NUMBER(cc);
 531                     }
 532                 }
 533                 else if (LADSPA_IS_PORT_OUTPUT(PortType))
 534                 {
 535                     param.data[j].type = PARAMETER_OUTPUT;
 536                     param.data[j].hints |= PARAMETER_IS_ENABLED;
 537
 538                     if (strcmp(ldescriptor->PortNames[i], "latency") != 0 && strcmp(ldescriptor->PortNames[i], "_latency") != 0)
 539                     {
 540                         param.data[j].hints |= PARAMETER_IS_AUTOMABLE;
 541                         needs_cout = true;
 542                     }
 543                     else
 544                     {
 545                         // latency parameter
 546                         min = 0;
 547                         max = get_sample_rate();
 548                         def = 0;
 549                         step = 1;
 550                         step_small = 1;
 551                         step_large = 1;
 552                     }
 553                 }
 554                 else
 555                 {
 556                     param.data[j].type = PARAMETER_UNKNOWN;
 557                     qWarning("WARNING - Got a broken Port (Control, but not input or output)");
 558                 }
 559
 560                 param.ranges[j].min = min;
 561                 param.ranges[j].max = max;
 562                 param.ranges[j].def = def;
 563                 param.ranges[j].step = step;
 564                 param.ranges[j].step_small = step_small;
 565                 param.ranges[j].step_large = step_large;
 566
 567                 // Start parameters in their default values
 568                 param.buffers[j] = def;
 569
 570                 ldescriptor->connect_port(handle, i, &param.buffers[j]);
 571             }
 572             else
 573             {
 574                 // Not Audio or Control
 575                 qCritical("ERROR - Got a broken Port (neither Audio or Control)");
 576                 ldescriptor->connect_port(handle, i, nullptr);
 577             }
 578         }
 579
 580         if (needs_cin)
 581         {
 582             if (carla_options.global_jack_client)
 583             {
 584                 strncpy(port_name, name, (port_name_size/2)-2);
 585                 strcat(port_name, ":control-in");
 586             }
 587             else
 588                 strcpy(port_name, "control-in");
 589
 590             param.port_in = jack_port_register(jack_client, port_name, JACK_DEFAULT_MIDI_TYPE, JackPortIsInput, 0);
 591         }
 592
 593         if (needs_cout)
 594         {
 595             if (carla_options.global_jack_client)
 596             {
 597                 strncpy(port_name, name, (port_name_size/2)-2);
 598                 strcat(port_name, ":control-out");
 599             }
 600             else
 601                 strcpy(port_name, "control-out");
 602
 603             param.port_out = jack_port_register(jack_client, port_name, JACK_DEFAULT_MIDI_TYPE, JackPortIsOutput, 0);
 604         }
 605
 606         if (mins == 1)
 607         {
 608             if (carla_options.global_jack_client)
 609             {
 610                 strncpy(port_name, name, (port_name_size/2)-2);
 611                 strcat(port_name, ":midi-in");
 612             }
 613             else
 614                 strcpy(port_name, "midi-in");
 615
 616             min.ports[0] = jack_port_register(jack_client, port_name, JACK_DEFAULT_MIDI_TYPE, JackPortIsInput, 0);
 617         }
 618
 619         ain.count   = ains;
 620         aout.count  = aouts;
 621         min.count   = mins;
 622         param.count = params;
 623
 624         reload_programs(true);
 625
 626         // Check if plugin is synth
 627         if (min.count > 0 && aout.count > 0)
 628             hints |= PLUGIN_IS_SYNTH;
 629
 630         // Check if plugin uses chunks -> hack by name check ["some-name VST"]
 631         if (QString(ldescriptor->Name).endsWith(" VST", Qt::CaseSensitive))
 632         {
 633             if (descriptor->getCustomData && descriptor->setCustomData)
 634                 hints |= PLUGIN_USES_CHUNKS;
 635         }
 636
 637         // Other plugin checks
 638         if (aouts > 0 && (ains == aouts || ains == 1))
 639             hints |= PLUGIN_CAN_DRYWET;
 640
 641         if (aouts > 0)
 642             hints |= PLUGIN_CAN_VOL;
 643
 644         if (aouts >= 2 && aouts%2 == 0)
 645             hints |= PLUGIN_CAN_BALANCE;
 646
 647         carla_proc_lock();
 648         id = _id;
 649         carla_proc_unlock();
 650
 651         if (carla_options.global_jack_client == false)
 652             jack_activate(jack_client);
 653     }
 654
 655     void reload_programs(bool init)
 656     {
 657         qDebug("DssiAudioPlugin::reload_programs(%s)", bool2str(init));
 658         uint32_t i, old_count = midiprog.count;
 659
 660         // Delete old programs
 661         if (midiprog.count > 0)
 662         {
 663             for (uint32_t i=0; i < midiprog.count; i++)
 664                 free((void*)midiprog.names[i]);
 665
 666             delete[] midiprog.data;
 667             delete[] midiprog.names;
 668         }
 669         midiprog.count = 0;
 670
 671         // Query new programs
 672         if (descriptor->get_program && descriptor->select_program)
 673         {
 674             while (descriptor->get_program(handle, midiprog.count))
 675                 midiprog.count += 1;
 676         }
 677
 678         if (midiprog.count > 0)
 679         {
 680             midiprog.data  = new midi_program_t [midiprog.count];
 681             midiprog.names = new const char* [midiprog.count];
 682         }
 683
 684         // Update data
 685         for (i=0; i < midiprog.count; i++)
 686         {
 687             const DSSI_Program_Descriptor* pdesc = descriptor->get_program(handle, i);
 688             if (pdesc)
 689             {
 690                 midiprog.data[i].bank    = pdesc->Bank;
 691                 midiprog.data[i].program = pdesc->Program;
 692                 midiprog.names[i] = strdup(pdesc->Name);
 693             }
 694             else
 695             {
 696                 midiprog.data[i].bank    = 0;
 697                 midiprog.data[i].program = 0;
 698                 midiprog.names[i] = strdup("(error)");
 699             }
 700         }
 701
 702         // Update OSC Names
 703         osc_send_set_midi_program_count(&global_osc_data, id, midiprog.count);
 704
 705         if (midiprog.count > 0)
 706         {
 707             for (i=0; i < midiprog.count; i++)
 708                 osc_send_set_midi_program_data(&global_osc_data, id, i, midiprog.data[i].bank, midiprog.data[i].program, midiprog.names[i]);
 709         }
 710
 711         callback_action(CALLBACK_RELOAD_PROGRAMS, id, 0, 0, 0.0);
 712
 713         if (init)
 714         {
 715             if (midiprog.count > 0)
 716                 set_midi_program(0, false, false, false, true);
 717         }
 718         else
 719         {
 720             callback_action(CALLBACK_UPDATE, id, 0, 0, 0.0);
 721
 722             // Check if current program is invalid
 723             bool program_changed = false;
 724
 725             if (midiprog.count == old_count+1)
 726             {
 727                 // one midi program added, probably created by user
 728                 midiprog.current = old_count;
 729                 program_changed  = true;
 730             }
 731             else if (midiprog.current >= (int32_t)midiprog.count)
 732             {
 733                 // current midi program > count
 734                 midiprog.current = 0;
 735                 program_changed  = true;
 736             }
 737             else if (midiprog.current < 0 && midiprog.count > 0)
 738             {
 739                 // programs exist now, but not before
 740                 midiprog.current = 0;
 741                 program_changed  = true;
 742             }
 743             else if (midiprog.current >= 0 && midiprog.count == 0)
 744             {
 745                 // programs existed before, but not anymore
 746                 midiprog.current = -1;
 747                 program_changed  = true;
 748             }
 749
 750             if (program_changed)
 751                 set_midi_program(midiprog.current, true, true, true, true);
 752         }
 753     }
 754
 755     void prepare_for_save()
 756     {
 757     }
 758
 759     void process(jack_nframes_t nframes)
 760     {
 761         uint32_t i, k;
 762         unsigned short plugin_id = id;
 763         unsigned long midi_event_count = 0;
 764
 765         double ains_peak_tmp[2]  = { 0.0 };
 766         double aouts_peak_tmp[2] = { 0.0 };
 767
 768         jack_default_audio_sample_t* ains_buffer[ain.count];
 769         jack_default_audio_sample_t* aouts_buffer[aout.count];
 770         jack_default_audio_sample_t* mins_buffer[min.count];
 771
 772         for (i=0; i < ain.count; i++)
 773             ains_buffer[i] = (jack_default_audio_sample_t*)jack_port_get_buffer(ain.ports[i], nframes);
 774
 775         for (i=0; i < aout.count; i++)
 776             aouts_buffer[i] = (jack_default_audio_sample_t*)jack_port_get_buffer(aout.ports[i], nframes);
 777
 778         for (i=0; i < min.count; i++)
 779             mins_buffer[i] = (jack_default_audio_sample_t*)jack_port_get_buffer(min.ports[i], nframes);
 780
 781         // --------------------------------------------------------------------------------------------------------
 782         // Input VU
 783
 784         if (ain.count > 0)
 785         {
 786             short j2 = (ain.count == 1) ? 0 : 1;
 787
 788             for (k=0; k<nframes; k++)
 789             {
 790                 if (ains_buffer[0][k] > ains_peak_tmp[0])
 791                     ains_peak_tmp[0] = ains_buffer[0][k];
 792                 if (ains_buffer[j2][k] > ains_peak_tmp[1])
 793                     ains_peak_tmp[1] = ains_buffer[j2][k];
 794             }
 795         }
 796
 797         CARLA_PROCESS_CONTINUE_CHECK;
 798
 799         // --------------------------------------------------------------------------------------------------------
 800         // Parameters Input [Automation]
 801
 802         if (param.port_in)
 803         {
 804             jack_default_audio_sample_t* pin_buffer = (jack_default_audio_sample_t*)jack_port_get_buffer(param.port_in, nframes);
 805
 806             jack_midi_event_t pin_event;
 807             uint32_t n_pin_events = jack_midi_get_event_count(pin_buffer);
 808
 809             for (i=0; i<n_pin_events; i++)
 810             {
 811                 if (jack_midi_event_get(&pin_event, pin_buffer, i) != 0)
 812                     break;
 813
 814                 unsigned char channel = pin_event.buffer[0] & 0x0F;
 815                 unsigned char mode    = pin_event.buffer[0] & 0xF0;
 816
 817                 // Status change
 818                 if (mode == 0xB0)
 819                 {
 820                     unsigned char status  = pin_event.buffer[1] & 0x7F;
 821                     unsigned char velo    = pin_event.buffer[2] & 0x7F;
 822                     double value, velo_per = double(velo)/127;
 823
 824                     // Control GUI stuff (channel 0 only)
 825                     if (channel == 0)
 826                     {
 827                         if (status == 0x78)
 828                         {
 829                             // All Sound Off
 830                             set_active(false, false, false);
 831                             postpone_event(PostEventParameter, PARAMETER_ACTIVE, 0.0);
 832                             break;
 833                         }
 834                         else if (status == 0x09 && hints & PLUGIN_CAN_DRYWET)
 835                         {
 836                             // Dry/Wet (using '0x09', undefined)
 837                             set_drywet(velo_per, false, false);
 838                             postpone_event(PostEventParameter, PARAMETER_DRYWET, velo_per);
 839                         }
 840                         else if (status == 0x07 && hints & PLUGIN_CAN_VOL)
 841                         {
 842                             // Volume
 843                             value = double(velo)/100;
 844                             set_vol(value, false, false);
 845                             postpone_event(PostEventParameter, PARAMETER_VOLUME, value);
 846                         }
 847                         else if (status == 0x08 && hints & PLUGIN_CAN_BALANCE)
 848                         {
 849                             // Balance
 850                             double left, right;
 851                             value = (double(velo)-63.5)/63.5;
 852
 853                             if (value < 0)
 854                             {
 855                                 left  = -1.0;
 856                                 right = (value*2)+1.0;
 857                             }
 858                             else if (value > 0)
 859                             {
 860                                 left  = (value*2)-1.0;
 861                                 right = 1.0;
 862                             }
 863                             else
 864                             {
 865                                 left  = -1.0;
 866                                 right = 1.0;
 867                             }
 868
 869                             set_balance_left(left, false, false);
 870                             set_balance_right(right, false, false);
 871                             postpone_event(PostEventParameter, PARAMETER_BALANCE_LEFT, left);
 872                             postpone_event(PostEventParameter, PARAMETER_BALANCE_RIGHT, right);
 873                         }
 874                     }
 875
 876                     // Control plugin parameters
 877                     for (k=0; k < param.count; k++)
 878                     {
 879                         if (param.data[k].type == PARAMETER_INPUT && (param.data[k].hints & PARAMETER_IS_AUTOMABLE) > 0 &&
 880                                 param.data[k].midi_channel == channel && param.data[k].midi_cc == status)
 881                         {
 882                             value = (velo_per * (param.ranges[k].max - param.ranges[k].min)) + param.ranges[k].min;
 883                             set_parameter_value(k, value, false, false, false);
 884                             postpone_event(PostEventParameter, k, value);
 885                         }
 886                     }
 887                 }
 888                 // Program change
 889                 else if (mode == 0xC0)
 890                 {
 891                     unsigned char midi_program = pin_event.buffer[1] & 0x7F;
 892
 893                     if (midi_program < midiprog.count)
 894                     {
 895                         set_midi_program(midi_program, false, false, false, false);
 896                         postpone_event(PostEventMidiProgram, midi_program, 0.0);
 897                     }
 898                 }
 899             }
 900         } // End of Parameters Input
 901
 902         CARLA_PROCESS_CONTINUE_CHECK;
 903
 904         // --------------------------------------------------------------------------------------------------------
 905         // MIDI Input (External)
 906
 907         if (min.count > 0)
 908         {
 909             carla_midi_lock();
 910
 911             for (i=0; i<MAX_MIDI_EVENTS && midi_event_count < MAX_MIDI_EVENTS; i++)
 912             {
 913                 if (ExternalMidiNotes[i].valid)
 914                 {
 915                     if (ExternalMidiNotes[i].plugin_id == plugin_id)
 916                     {
 917                         ExternalMidiNote* enote = &ExternalMidiNotes[i];
 918                         enote->valid = false;
 919
 920                         snd_seq_event_t* midi_event = &midi_events[midi_event_count];
 921                         memset(midi_event, 0, sizeof(snd_seq_event_t));
 922
 923                         midi_event->type = enote->onoff ? SND_SEQ_EVENT_NOTEON : SND_SEQ_EVENT_NOTEOFF;
 924                         midi_event->data.note.channel  = 0;
 925                         midi_event->data.note.note     = enote->note;
 926                         midi_event->data.note.velocity = enote->velo;
 927
 928                         midi_event_count += 1;
 929                     }
 930                 }
 931                 else
 932                     break;
 933             }
 934
 935             carla_midi_unlock();
 936
 937         } // End of MIDI Input (External)
 938
 939         CARLA_PROCESS_CONTINUE_CHECK;
 940
 941         // --------------------------------------------------------------------------------------------------------
 942         // MIDI Input (JACK)
 943
 944         if (min.count > 0)
 945         {
 946             jack_midi_event_t min_event;
 947             uint32_t n_min_events = jack_midi_get_event_count(mins_buffer[0]);
 948
 949             for (k=0; k<n_min_events && midi_event_count < MAX_MIDI_EVENTS; k++)
 950             {
 951                 if (jack_midi_event_get(&min_event, mins_buffer[0], k) != 0)
 952                     break;
 953
 954                 unsigned char channel = min_event.buffer[0] & 0x0F;
 955                 unsigned char mode = min_event.buffer[0] & 0xF0;
 956                 unsigned char note = min_event.buffer[1] & 0x7F;
 957                 unsigned char velo = min_event.buffer[2] & 0x7F;
 958
 959                 // fix bad note off
 960                 if (mode == 0x90 && velo == 0)
 961                 {
 962                     mode = 0x80;
 963                     velo = 64;
 964                 }
 965
 966                 snd_seq_event_t* midi_event = &midi_events[midi_event_count];
 967                 memset(midi_event, 0, sizeof(snd_seq_event_t));
 968
 969                 if (mode == 0x80)
 970                 {
 971                     midi_event->type = SND_SEQ_EVENT_NOTEOFF;
 972                     midi_event->data.note.channel = channel;
 973                     midi_event->data.note.note = note;
 974                     midi_event->data.note.velocity = velo;
 975                     midi_event->time.tick = min_event.time;
 976                     postpone_event(PostEventNoteOff, note, velo);
 977                 }
 978                 else if (mode == 0x90)
 979                 {
 980                     midi_event->type = SND_SEQ_EVENT_NOTEON;
 981                     midi_event->data.note.channel = channel;
 982                     midi_event->data.note.note = note;
 983                     midi_event->data.note.velocity = velo;
 984                     midi_event->time.tick = min_event.time;
 985                     postpone_event(PostEventNoteOn, note, velo);
 986                 }
 987                 else if (mode == 0xB0)
 988                 {
 989                     midi_event->type = SND_SEQ_EVENT_CONTROLLER;
 990                     midi_event->data.control.channel = channel;
 991                     midi_event->data.control.param = note;
 992                     midi_event->data.control.value = velo;
 993                     midi_event->time.tick = min_event.time;
 994                 }
 995                 else if (mode == 0xE0)
 996                 {
 997                     // TODO
 998                     //midi_event->type = SND_SEQ_EVENT_PITCHBEND;
 999                     //midi_event->data.control.channel = channel;
1000                     //midi_event->data.control.param = note;
1001                     //midi_event->data.control.value = (min_event.buffer[2] << 7) | min_event.buffer[1];
1002                     //midi_event->time.tick = min_event.time;
1003                 }
1004
1005                 midi_event_count += 1;
1006             }
1007         } // End of MIDI Input (JACK)
1008
1009         CARLA_PROCESS_CONTINUE_CHECK;
1010
1011         // --------------------------------------------------------------------------------------------------------
1012         // Plugin processing
1013
1014         if (active)
1015         {
1016             if (!active_before)
1017             {
1018                 if (ldescriptor->activate)
1019                     ldescriptor->activate(handle);
1020             }
1021
1022             for (i=0; i < ain.count; i++)
1023                 ldescriptor->connect_port(handle, ain.rindexes[i], ains_buffer[i]);
1024
1025             for (i=0; i < aout.count; i++)
1026                 ldescriptor->connect_port(handle, aout.rindexes[i], aouts_buffer[i]);
1027
1028             if (descriptor->run_synth)
1029             {
1030                 descriptor->run_synth(handle, nframes, midi_events, midi_event_count);
1031             }
1032             else if (descriptor->run_multiple_synths)
1033             {
1034                 snd_seq_event_t* dssi_events_ptr[] = { midi_events, nullptr };
1035                 descriptor->run_multiple_synths(1, &handle, nframes, dssi_events_ptr, &midi_event_count);
1036             }
1037             else if (ldescriptor->run)
1038                 ldescriptor->run(handle, nframes);
1039         }
1040         else
1041         {
1042             if (active_before)
1043             {
1044                 if (ldescriptor->deactivate)
1045                     ldescriptor->deactivate(handle);
1046             }
1047         }
1048
1049         CARLA_PROCESS_CONTINUE_CHECK;
1050
1051         // --------------------------------------------------------------------------------------------------------
1052         // Post-processing (dry/wet, volume and balance)
1053
1054         if (active)
1055         {
1056             double bal_rangeL, bal_rangeR;
1057             jack_default_audio_sample_t old_bal_left[nframes];
1058
1059             for (i=0; i < aout.count; i++)
1060             {
1061                 // Dry/Wet and Volume
1062                 for (k=0; k<nframes; k++)
1063                 {
1064                     if (hints & PLUGIN_CAN_DRYWET && x_drywet != 1.0)
1065                     {
1066                         if (aout.count == 1)
1067                             aouts_buffer[i][k] = (aouts_buffer[i][k]*x_drywet)+(ains_buffer[0][k]*(1.0-x_drywet));
1068                         else
1069                             aouts_buffer[i][k] = (aouts_buffer[i][k]*x_drywet)+(ains_buffer[i][k]*(1.0-x_drywet));
1070                     }
1071
1072                     if (hints & PLUGIN_CAN_VOL)
1073                         aouts_buffer[i][k] *= x_vol;
1074                 }
1075
1076                 // Balance
1077                 if (hints & PLUGIN_CAN_BALANCE)
1078                 {
1079                     if (i%2 == 0)
1080                         memcpy(&old_bal_left, aouts_buffer[i], sizeof(jack_default_audio_sample_t)*nframes);
1081
1082                     bal_rangeL = (x_bal_left+1.0)/2;
1083                     bal_rangeR = (x_bal_right+1.0)/2;
1084
1085                     for (k=0; k<nframes; k++)
1086                     {
1087                         if (i%2 == 0)
1088                         {
1089                             // left output
1090                             aouts_buffer[i][k]  = old_bal_left[k]*(1.0-bal_rangeL);
1091                             aouts_buffer[i][k] += aouts_buffer[i+1][k]*(1.0-bal_rangeR);
1092                         }
1093                         else
1094                         {
1095                             // right
1096                             aouts_buffer[i][k]  = aouts_buffer[i][k]*bal_rangeR;
1097                             aouts_buffer[i][k] += old_bal_left[k]*bal_rangeL;
1098                         }
1099                     }
1100                 }
1101
1102                 // Output VU
1103                 if (i < 2)
1104                 {
1105                     for (k=0; k<nframes; k++)
1106                     {
1107                         if (aouts_buffer[i][k] > aouts_peak_tmp[i])
1108                             aouts_peak_tmp[i] = aouts_buffer[i][k];
1109                     }
1110                 }
1111             }
1112         }
1113         else
1114         {
1115             // disable any output sound if not active
1116             for (i=0; i < aout.count; i++)
1117                 memset(aouts_buffer[i], 0.0f, sizeof(jack_default_audio_sample_t)*nframes);
1118
1119             aouts_peak_tmp[0] = 0.0;
1120             aouts_peak_tmp[1] = 0.0;
1121
1122         } // End of Post-processing
1123
1124         CARLA_PROCESS_CONTINUE_CHECK;
1125
1126         // --------------------------------------------------------------------------------------------------------
1127         // Control Output
1128
1129         if (param.port_out)
1130         {
1131             jack_default_audio_sample_t* cout_buffer = (jack_default_audio_sample_t*)jack_port_get_buffer(param.port_out, nframes);
1132             jack_midi_clear_buffer(cout_buffer);
1133
1134             double value_per;
1135
1136             for (k=0; k < param.count; k++)
1137             {
1138                 if (param.data[k].type == PARAMETER_OUTPUT && param.data[k].midi_cc >= 0)
1139                 {
1140                     value_per = (param.buffers[k] - param.ranges[k].min)/(param.ranges[k].max - param.ranges[k].min);
1141
1142                     jack_midi_data_t* event_buffer = jack_midi_event_reserve(cout_buffer, 0, 3);
1143                     event_buffer[0] = 0xB0 + param.data[k].midi_channel;
1144                     event_buffer[1] = param.data[k].midi_cc;
1145                     event_buffer[2] = 127*value_per;
1146                 }
1147             }
1148         } // End of Control Output
1149
1150         CARLA_PROCESS_CONTINUE_CHECK;
1151
1152         // --------------------------------------------------------------------------------------------------------
1153         // Peak Values
1154
1155         ains_peak[(plugin_id*2)+0]  = ains_peak_tmp[0];
1156         ains_peak[(plugin_id*2)+1]  = ains_peak_tmp[1];
1157         aouts_peak[(plugin_id*2)+0] = aouts_peak_tmp[0];
1158         aouts_peak[(plugin_id*2)+1] = aouts_peak_tmp[1];
1159
1160         active_before = active;
1161     }
1162
1163     void buffer_size_changed(jack_nframes_t)
1164     {
1165     }
1166 };
1167
1168 DssiOscGuiThread::DssiOscGuiThread(QObject* parent) :
1169     QThread(parent)
1170 {
1171     plugin_id = -1;
1172 }
1173
1174 void DssiOscGuiThread::set_plugin_id(short plugin_id_)
1175 {
1176     plugin_id = plugin_id_;
1177 }
1178
1179 void DssiOscGuiThread::run()
1180 {
1181     if (plugin_id < 0 || plugin_id > MAX_PLUGINS)
1182     {
1183         qCritical("DssiOscGuiThread::run() - invalid plugin id '%i'", plugin_id);
1184         return;
1185     }
1186
1187     DssiAudioPlugin* plugin = (DssiAudioPlugin*)AudioPlugins[plugin_id];
1188
1189     if (!plugin)
1190     {
1191         qCritical("DssiOscGuiThread::run() - invalid plugin");
1192         return;
1193     }
1194
1195     if (plugin->id != plugin_id)
1196     {
1197         qCritical("DssiOscGuiThread::run() - plugin mismatch '%i'' != '%i'", plugin->id, plugin_id);
1198         return;
1199     }
1200
1201     QString cmd = QString("%1 '%2/%3' '%4' '%5' '%6 (GUI)'").arg(plugin->gui.name).arg(get_host_osc_url()).arg(plugin_id).arg(plugin->filename).arg(plugin->ldescriptor->Label).arg(plugin->name);
1202
1203     qDebug("DssiOscGuiThread::run() - command: %s", cmd.toStdString().data());
1204
1205     int ret;
1206
1207     while (plugin && plugin->id == plugin_id && carla_is_engine_running())
1208     {
1209         if (plugin->gui.show_now)
1210         {
1211             ret = system(cmd.toStdString().data());
1212             plugin->gui.visible  = false;
1213             plugin->gui.show_now = false;
1214
1215             if (ret == 0)
1216             {
1217                 // Hide
1218                 callback_action(CALLBACK_SHOW_GUI, plugin_id, 0, 0, 0.0f);
1219             }
1220             else
1221             {
1222                 // Kill
1223                 callback_action(CALLBACK_SHOW_GUI, plugin_id, -1, 0, 0.0f);
1224                 qWarning("DssiOscGuiThread::run() - DSSI GUI crashed");
1225                 break;
1226             }
1227         }
1228         else
1229             sleep(1);
1230     }
1231
1232     if (plugin->gui.name)
1233         free((void*)plugin->gui.name);
1234
1235     plugin->gui.name = nullptr;
1236     plugin->gui.visible = false;
1237 }
1238
1239 short add_plugin_dssi(const char* filename, const char* label, void* extra_stuff)
1240 {
1241     qDebug("add_plugin_dssi(%s, %s, %p)", filename, label, extra_stuff);
1242
1243     short id = get_new_plugin_id();
1244
1245     if (id >= 0)
1246     {
1247         DssiAudioPlugin* plugin = new DssiAudioPlugin;
1248
1249         if ((plugin->lib_open(filename)))
1250         {
1251             DSSI_Descriptor_Function descfn = (DSSI_Descriptor_Function)plugin->lib_symbol("dssi_descriptor");
1252
1253             if (descfn)
1254             {
1255                 unsigned long i = 0;
1256                 while ((plugin->descriptor = descfn(i++)))
1257                 {
1258                     plugin->ldescriptor = plugin->descriptor->LADSPA_Plugin;
1259                     if (strcmp(plugin->ldescriptor->Label, label) == 0)
1260                         break;
1261                 }
1262
1263                 if (plugin->descriptor && plugin->ldescriptor)
1264                 {
1265                     plugin->handle = plugin->ldescriptor->instantiate(plugin->ldescriptor, get_sample_rate());
1266
1267                     if (plugin->handle)
1268                     {
1269                         plugin->name = get_unique_name(plugin->ldescriptor->Name);
1270                         plugin->filename = strdup(filename);
1271
1272                         if (carla_options.global_jack_client)
1273                             plugin->jack_client = carla_jack_client;
1274                         else
1275                             carla_jack_register_plugin(plugin);
1276
1277                         if (plugin->jack_client)
1278                         {
1279                             plugin->reload();
1280
1281                             plugin->id = id;
1282                             unique_names[id] = plugin->name;
1283                             AudioPlugins[id] = plugin;
1284
1285                             // GUI Stuff
1286                             const char* gui_filename = (char*)extra_stuff;
1287
1288                             if (gui_filename)
1289                             {
1290                                 DssiOscGuiThread* dssi_thread = new DssiOscGuiThread();
1291                                 dssi_thread->set_plugin_id(plugin->id);
1292                                 dssi_thread->start();
1293
1294                                 plugin->gui.name   = strdup(gui_filename);
1295                                 plugin->gui.type   = GUI_EXTERNAL_OSC;
1296                                 plugin->osc.thread = dssi_thread;
1297                             }
1298
1299                             if (plugin->gui.type != GUI_NONE)
1300                                 plugin->hints |= PLUGIN_HAS_GUI;
1301
1302                             osc_new_plugin(plugin);
1303                         }
1304                         else
1305                         {
1306                             set_last_error("Failed to register plugin in JACK");
1307                             delete plugin;
1308                             id = -1;
1309                         }
1310                     }
1311                     else
1312                     {
1313                         set_last_error("Plugin failed to initialize");
1314                         delete plugin;
1315                         id = -1;
1316                     }
1317                 }
1318                 else
1319                 {
1320                     set_last_error("Could not find the requested plugin Label in the plugin library");
1321                     delete plugin;
1322                     id = -1;
1323                 }
1324             }
1325             else
1326             {
1327                 set_last_error("Could not find the DSSI Descriptor in the plugin library");
1328                 delete plugin;
1329                 id = -1;
1330             }
1331         }
1332         else
1333         {
1334             set_last_error(plugin->lib_error());
1335             delete plugin;
1336             id = -1;
1337         }
1338     }
1339     else
1340         set_last_error("Maximum number of plugins reached");
1341
1342     return id;
1343 }