source/backend/plugin/CarlaPluginNative.cpp

   1 /*
   2  * Carla Native Plugin
   3  * Copyright (C) 2012-2022 Filipe Coelho <falktx@falktx.com>
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License as
   7  * published by the Free Software Foundation; either version 2 of
   8  * the License, or any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13  * GNU General Public License for more details.
  14  *
  15  * For a full copy of the GNU General Public License see the doc/GPL.txt file.
  16  */
  17
  18 #include "CarlaPluginInternal.hpp"
  19 #include "CarlaEngine.hpp"
  20
  21 #include "CarlaBackendUtils.hpp"
  22 #include "CarlaMathUtils.hpp"
  23 #include "CarlaNative.h"
  24
  25 #include "water/misc/Time.h"
  26 #include "water/text/StringArray.h"
  27
  28 using water::String;
  29 using water::StringArray;
  30
  31 // -----------------------------------------------------------------------
  32 // used in carla-base.cpp
  33
  34 std::size_t carla_getNativePluginCount() noexcept;
  35 const NativePluginDescriptor* carla_getNativePluginDescriptor(const std::size_t index) noexcept;
  36
  37 // -----------------------------------------------------------------------
  38
  39 static LinkedList<const NativePluginDescriptor*> gPluginDescriptors;
  40
  41 void carla_register_native_plugin(const NativePluginDescriptor* desc)
  42 {
  43     gPluginDescriptors.append(desc);
  44 }
  45
  46 // -----------------------------------------------------------------------
  47
  48 static
  49 class NativePluginInitializer
  50 {
  51 public:
  52     NativePluginInitializer() noexcept
  53         : fNeedsInit(true) {}
  54
  55     ~NativePluginInitializer() noexcept
  56     {
  57         gPluginDescriptors.clear();
  58     }
  59
  60     void initIfNeeded() noexcept
  61     {
  62         if (! fNeedsInit)
  63             return;
  64
  65         fNeedsInit = false;
  66
  67         try {
  68             carla_register_all_native_plugins();
  69         } CARLA_SAFE_EXCEPTION("carla_register_all_native_plugins")
  70     }
  71
  72 private:
  73     bool fNeedsInit;
  74
  75 } sPluginInitializer;
  76
  77 // -----------------------------------------------------------------------
  78
  79 std::size_t carla_getNativePluginCount() noexcept
  80 {
  81     sPluginInitializer.initIfNeeded();
  82     return gPluginDescriptors.count();
  83 }
  84
  85 const NativePluginDescriptor* carla_getNativePluginDescriptor(const std::size_t index) noexcept
  86 {
  87     sPluginInitializer.initIfNeeded();
  88     return gPluginDescriptors.getAt(index, nullptr);
  89 }
  90
  91 // -----------------------------------------------------------------------
  92
  93 CARLA_BACKEND_START_NAMESPACE
  94
  95 // -------------------------------------------------------------------
  96 // Fallback data
  97
  98 static const CustomData  kCustomDataFallback = { nullptr, nullptr, nullptr };
  99 static EngineEvent kNullEngineEvent = {
 100     kEngineEventTypeNull, 0, 0, {{ kEngineControlEventTypeNull, 0, -1, 0.0f, true }}
 101 };
 102
 103 // -----------------------------------------------------------------------
 104
 105 struct NativePluginMidiOutData {
 106     uint32_t  count;
 107     uint32_t* indexes;
 108     CarlaEngineEventPort** ports;
 109
 110     NativePluginMidiOutData() noexcept
 111         : count(0),
 112           indexes(nullptr),
 113           ports(nullptr) {}
 114
 115     ~NativePluginMidiOutData() noexcept
 116     {
 117         CARLA_SAFE_ASSERT_INT(count == 0, count);
 118         CARLA_SAFE_ASSERT(indexes == nullptr);
 119         CARLA_SAFE_ASSERT(ports == nullptr);
 120     }
 121
 122     bool createNew(const uint32_t newCount)
 123     {
 124         CARLA_SAFE_ASSERT_INT(count == 0, count);
 125         CARLA_SAFE_ASSERT_RETURN(indexes == nullptr, false);
 126         CARLA_SAFE_ASSERT_RETURN(ports == nullptr, false);
 127         CARLA_SAFE_ASSERT_RETURN(newCount > 0, false);
 128
 129         indexes       = new uint32_t[newCount];
 130         ports         = new CarlaEngineEventPort*[newCount];
 131         count         = newCount;
 132
 133         carla_zeroStructs(indexes, newCount);
 134         carla_zeroStructs(ports, newCount);
 135
 136         return true;
 137     }
 138
 139     void clear() noexcept
 140     {
 141         if (ports != nullptr)
 142         {
 143             for (uint32_t i=0; i < count; ++i)
 144             {
 145                 if (ports[i] != nullptr)
 146                 {
 147                     delete ports[i];
 148                     ports[i] = nullptr;
 149                 }
 150             }
 151
 152             delete[] ports;
 153             ports = nullptr;
 154         }
 155
 156         if (indexes != nullptr)
 157         {
 158             delete[] indexes;
 159             indexes = nullptr;
 160         }
 161
 162         count = 0;
 163     }
 164
 165     void initBuffers() const noexcept
 166     {
 167         for (uint32_t i=0; i < count; ++i)
 168         {
 169             if (ports[i] != nullptr)
 170                 ports[i]->initBuffer();
 171         }
 172     }
 173
 174     CARLA_DECLARE_NON_COPYABLE(NativePluginMidiOutData)
 175 };
 176
 177 struct NativePluginMidiInData : NativePluginMidiOutData {
 178     struct MultiPortData {
 179         uint32_t cachedEventCount;
 180         uint32_t usedIndex;
 181     };
 182
 183     MultiPortData* multiportData;
 184
 185     NativePluginMidiInData() noexcept
 186         : NativePluginMidiOutData(),
 187           multiportData(nullptr) {}
 188
 189     ~NativePluginMidiInData() noexcept
 190     {
 191         CARLA_SAFE_ASSERT(multiportData == nullptr);
 192     }
 193
 194     bool createNew(const uint32_t newCount)
 195     {
 196         if (! NativePluginMidiOutData::createNew(newCount))
 197             return false;
 198
 199         multiportData = new MultiPortData[newCount];
 200         carla_zeroStructs(multiportData, newCount);
 201
 202         return true;
 203     }
 204
 205     void clear() noexcept
 206     {
 207         if (multiportData != nullptr)
 208         {
 209             delete[] multiportData;
 210             multiportData = nullptr;
 211         }
 212
 213         NativePluginMidiOutData::clear();
 214     }
 215
 216     void initBuffers(CarlaEngineEventPort* const port) const noexcept
 217     {
 218         if (count == 1)
 219         {
 220             CARLA_SAFE_ASSERT_RETURN(port != nullptr,);
 221
 222             carla_zeroStruct(multiportData[0]);
 223             multiportData[0].cachedEventCount = port->getEventCount();
 224             return;
 225         }
 226
 227         for (uint32_t i=0; i < count; ++i)
 228         {
 229             carla_zeroStruct(multiportData[i]);
 230
 231             if (ports[i] != nullptr)
 232             {
 233                 ports[i]->initBuffer();
 234                 multiportData[i].cachedEventCount = ports[i]->getEventCount();
 235             }
 236         }
 237     }
 238
 239     CARLA_DECLARE_NON_COPYABLE(NativePluginMidiInData)
 240 };
 241
 242 // -----------------------------------------------------
 243
 244 class CarlaPluginNative : public CarlaPlugin
 245 {
 246 public:
 247     CarlaPluginNative(CarlaEngine* const engine, const uint id)
 248         : CarlaPlugin(engine, id),
 249           fHandle(nullptr),
 250           fHandle2(nullptr),
 251           fHost(),
 252           fDescriptor(nullptr),
 253           fIsProcessing(false),
 254           fIsOffline(engine->isOffline()),
 255           fIsUiAvailable(false),
 256           fIsUiVisible(false),
 257           fNeedsIdle(false),
 258           fInlineDisplayNeedsRedraw(false),
 259           fInlineDisplayLastRedrawTime(0),
 260           fLastProjectFilename(),
 261           fLastProjectFolder(),
 262           fAudioAndCvInBuffers(nullptr),
 263           fAudioAndCvOutBuffers(nullptr),
 264           fMidiEventInCount(0),
 265           fMidiEventOutCount(0),
 266           fCurBufferSize(engine->getBufferSize()),
 267           fCurSampleRate(engine->getSampleRate()),
 268           fMidiIn(),
 269           fMidiOut(),
 270           fTimeInfo()
 271     {
 272         carla_debug("CarlaPluginNative::CarlaPluginNative(%p, %i)", engine, id);
 273
 274         carla_fill(fCurMidiProgs, 0, MAX_MIDI_CHANNELS);
 275         carla_zeroStructs(fMidiInEvents, kPluginMaxMidiEvents);
 276         carla_zeroStructs(fMidiOutEvents, kPluginMaxMidiEvents);
 277         carla_zeroStruct(fTimeInfo);
 278
 279         fHost.handle      = this;
 280         fHost.resourceDir = carla_strdup(engine->getOptions().resourceDir);
 281         fHost.uiName      = nullptr;
 282         fHost.uiParentId  = engine->getOptions().frontendWinId;
 283
 284         fHost.get_buffer_size        = carla_host_get_buffer_size;
 285         fHost.get_sample_rate        = carla_host_get_sample_rate;
 286         fHost.is_offline             = carla_host_is_offline;
 287         fHost.get_time_info          = carla_host_get_time_info;
 288         fHost.write_midi_event       = carla_host_write_midi_event;
 289         fHost.ui_parameter_changed   = carla_host_ui_parameter_changed;
 290         fHost.ui_custom_data_changed = carla_host_ui_custom_data_changed;
 291         fHost.ui_closed              = carla_host_ui_closed;
 292         fHost.ui_open_file           = carla_host_ui_open_file;
 293         fHost.ui_save_file           = carla_host_ui_save_file;
 294         fHost.dispatcher             = carla_host_dispatcher;
 295     }
 296
 297     ~CarlaPluginNative() override
 298     {
 299         carla_debug("CarlaPluginNative::~CarlaPluginNative()");
 300
 301         fInlineDisplayNeedsRedraw = false;
 302
 303         // close UI
 304         if (pData->hints & PLUGIN_HAS_CUSTOM_UI)
 305         {
 306             if (fIsUiVisible && fDescriptor != nullptr && fDescriptor->ui_show != nullptr && fHandle != nullptr)
 307                 fDescriptor->ui_show(fHandle, false);
 308
 309 #ifndef BUILD_BRIDGE
 310             pData->transientTryCounter = 0;
 311 #endif
 312         }
 313
 314         pData->singleMutex.lock();
 315         pData->masterMutex.lock();
 316
 317         if (pData->client != nullptr && pData->client->isActive())
 318             pData->client->deactivate(true);
 319
 320         CARLA_ASSERT(! fIsProcessing);
 321
 322         if (pData->active)
 323         {
 324             deactivate();
 325             pData->active = false;
 326         }
 327
 328         if (fDescriptor != nullptr)
 329         {
 330             if (fDescriptor->cleanup != nullptr)
 331             {
 332                 if (fHandle != nullptr)
 333                     fDescriptor->cleanup(fHandle);
 334                 if (fHandle2 != nullptr)
 335                     fDescriptor->cleanup(fHandle2);
 336             }
 337
 338             fHandle  = nullptr;
 339             fHandle2 = nullptr;
 340             fDescriptor = nullptr;
 341         }
 342
 343         if (fHost.resourceDir != nullptr)
 344         {
 345             delete[] fHost.resourceDir;
 346             fHost.resourceDir = nullptr;
 347         }
 348
 349         if (fHost.uiName != nullptr)
 350         {
 351             std::free(const_cast<char*>(fHost.uiName));
 352             fHost.uiName = nullptr;
 353         }
 354
 355         clearBuffers();
 356     }
 357
 358     // -------------------------------------------------------------------
 359     // Information (base)
 360
 361     PluginType getType() const noexcept override
 362     {
 363         return PLUGIN_INTERNAL;
 364     }
 365
 366     PluginCategory getCategory() const noexcept override
 367     {
 368         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr, PLUGIN_CATEGORY_NONE);
 369
 370         return static_cast<PluginCategory>(fDescriptor->category);
 371     }
 372
 373     // -------------------------------------------------------------------
 374     // Information (count)
 375
 376     uint32_t getMidiInCount() const noexcept override
 377     {
 378         return fMidiIn.count;
 379     }
 380
 381     uint32_t getMidiOutCount() const noexcept override
 382     {
 383         return fMidiOut.count;
 384     }
 385
 386     uint32_t getParameterScalePointCount(const uint32_t parameterId) const noexcept override
 387     {
 388         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr, 0);
 389         CARLA_SAFE_ASSERT_RETURN(fDescriptor->get_parameter_info != nullptr, 0);
 390         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr, 0);
 391         CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count, 0);
 392
 393         // FIXME - try
 394         if (const NativeParameter* const param = fDescriptor->get_parameter_info(fHandle, parameterId))
 395             return param->scalePointCount;
 396
 397         carla_safe_assert("const Parameter* const param = fDescriptor->get_parameter_info(fHandle, parameterId)", __FILE__, __LINE__);
 398         return 0;
 399     }
 400
 401     // -------------------------------------------------------------------
 402     // Information (current data)
 403
 404     // nothing
 405
 406     // -------------------------------------------------------------------
 407     // Information (per-plugin data)
 408
 409     uint getOptionsAvailable() const noexcept override
 410     {
 411         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr, 0x0);
 412         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,     0x0);
 413
 414         bool hasMidiProgs = false;
 415
 416         if (fDescriptor->get_midi_program_count != nullptr)
 417         {
 418             try {
 419                 hasMidiProgs = fDescriptor->get_midi_program_count(fHandle) > 0;
 420             } catch (...) {}
 421         }
 422
 423         uint options = 0x0;
 424
 425         // can't disable fixed buffers if required by the plugin
 426         if ((fDescriptor->hints & NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS) == 0x0)
 427             options |= PLUGIN_OPTION_FIXED_BUFFERS;
 428
 429         // can't disable forced stereo if enabled in the engine, or using CV
 430         if (pData->engine->getOptions().forceStereo || pData->cvIn.count != 0 || pData->cvOut.count != 0)
 431             pass();
 432         // if inputs or outputs are just 1, then yes we can force stereo
 433         else if (pData->audioIn.count == 1 || pData->audioOut.count == 1 || fHandle2 != nullptr)
 434             options |= PLUGIN_OPTION_FORCE_STEREO;
 435
 436         if (fDescriptor->supports & NATIVE_PLUGIN_SUPPORTS_CONTROL_CHANGES)
 437             options |= PLUGIN_OPTION_SEND_CONTROL_CHANGES;
 438         if (fDescriptor->supports & NATIVE_PLUGIN_SUPPORTS_CHANNEL_PRESSURE)
 439             options |= PLUGIN_OPTION_SEND_CHANNEL_PRESSURE;
 440         if (fDescriptor->supports & NATIVE_PLUGIN_SUPPORTS_NOTE_AFTERTOUCH)
 441             options |= PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH;
 442         if (fDescriptor->supports & NATIVE_PLUGIN_SUPPORTS_PITCHBEND)
 443             options |= PLUGIN_OPTION_SEND_PITCHBEND;
 444         if (fDescriptor->supports & NATIVE_PLUGIN_SUPPORTS_ALL_SOUND_OFF)
 445             options |= PLUGIN_OPTION_SEND_ALL_SOUND_OFF;
 446
 447         if (fDescriptor->midiIns > 0)
 448             options |= PLUGIN_OPTION_SKIP_SENDING_NOTES;
 449
 450         if (fDescriptor->supports & NATIVE_PLUGIN_SUPPORTS_PROGRAM_CHANGES)
 451             options |= PLUGIN_OPTION_SEND_PROGRAM_CHANGES;
 452         else if (hasMidiProgs)
 453             options |= PLUGIN_OPTION_MAP_PROGRAM_CHANGES;
 454
 455         return options;
 456     }
 457
 458     float getParameterValue(const uint32_t parameterId) const noexcept override
 459     {
 460         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr, 0.0f);
 461         CARLA_SAFE_ASSERT_RETURN(fDescriptor->get_parameter_value != nullptr, 0.0f);
 462         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr, 0.0f);
 463         CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count, 0.0f);
 464
 465         // FIXME - try
 466         return fDescriptor->get_parameter_value(fHandle, parameterId);
 467     }
 468
 469     float getParameterScalePointValue(const uint32_t parameterId, const uint32_t scalePointId) const noexcept override
 470     {
 471         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr, 0.0f);
 472         CARLA_SAFE_ASSERT_RETURN(fDescriptor->get_parameter_info != nullptr, 0.0f);
 473         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr, 0.0f);
 474         CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count, 0.0f);
 475
 476         // FIXME - try
 477         if (const NativeParameter* const param = fDescriptor->get_parameter_info(fHandle, parameterId))
 478         {
 479             CARLA_SAFE_ASSERT_RETURN(scalePointId < param->scalePointCount, 0.0f);
 480
 481             const NativeParameterScalePoint* scalePoint(&param->scalePoints[scalePointId]);
 482             return scalePoint->value;
 483         }
 484
 485         carla_safe_assert("const Parameter* const param = fDescriptor->get_parameter_info(fHandle, parameterId)", __FILE__, __LINE__);
 486         return 0.0f;
 487     }
 488
 489     bool getLabel(char* const strBuf) const noexcept override
 490     {
 491         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr, false);
 492
 493         if (fDescriptor->label != nullptr)
 494         {
 495             std::strncpy(strBuf, fDescriptor->label, STR_MAX);
 496             return true;
 497         }
 498
 499         return CarlaPlugin::getLabel(strBuf);
 500     }
 501
 502     bool getMaker(char* const strBuf) const noexcept override
 503     {
 504         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr, false);
 505
 506         if (fDescriptor->maker != nullptr)
 507         {
 508             std::strncpy(strBuf, fDescriptor->maker, STR_MAX);
 509             return true;
 510         }
 511
 512         return CarlaPlugin::getMaker(strBuf);
 513     }
 514
 515     bool getCopyright(char* const strBuf) const noexcept override
 516     {
 517         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr, false);
 518
 519         if (fDescriptor->copyright != nullptr)
 520         {
 521             std::strncpy(strBuf, fDescriptor->copyright, STR_MAX);
 522             return true;
 523         }
 524
 525         return CarlaPlugin::getCopyright(strBuf);
 526     }
 527
 528     bool getRealName(char* const strBuf) const noexcept override
 529     {
 530         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr, false);
 531
 532         if (fDescriptor->name != nullptr)
 533         {
 534             std::strncpy(strBuf, fDescriptor->name, STR_MAX);
 535             return true;
 536         }
 537
 538         return CarlaPlugin::getRealName(strBuf);
 539     }
 540
 541     bool getParameterName(const uint32_t parameterId, char* const strBuf) const noexcept override
 542     {
 543         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr, false);
 544         CARLA_SAFE_ASSERT_RETURN(fDescriptor->get_parameter_info != nullptr, false);
 545         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr, false);
 546         CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count, false);
 547
 548         // FIXME - try
 549         if (const NativeParameter* const param = fDescriptor->get_parameter_info(fHandle, parameterId))
 550         {
 551             if (param->name != nullptr)
 552             {
 553                 std::strncpy(strBuf, param->name, STR_MAX);
 554                 return true;
 555             }
 556
 557             carla_safe_assert("param->name != nullptr", __FILE__, __LINE__);
 558             return CarlaPlugin::getParameterName(parameterId, strBuf);
 559         }
 560
 561         carla_safe_assert("const Parameter* const param = fDescriptor->get_parameter_info(fHandle, parameterId)", __FILE__, __LINE__);
 562         return CarlaPlugin::getParameterName(parameterId, strBuf);
 563     }
 564
 565     bool getParameterUnit(const uint32_t parameterId, char* const strBuf) const noexcept override
 566     {
 567         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr, false);
 568         CARLA_SAFE_ASSERT_RETURN(fDescriptor->get_parameter_info != nullptr, false);
 569         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr, false);
 570         CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count, false);
 571
 572         // FIXME - try
 573         if (const NativeParameter* const param = fDescriptor->get_parameter_info(fHandle, parameterId))
 574         {
 575             if (param->unit != nullptr)
 576             {
 577                 std::strncpy(strBuf, param->unit, STR_MAX);
 578                 return true;
 579             }
 580
 581             return CarlaPlugin::getParameterUnit(parameterId, strBuf);
 582         }
 583
 584         carla_safe_assert("const Parameter* const param = fDescriptor->get_parameter_info(fHandle, parameterId)", __FILE__, __LINE__);
 585         return CarlaPlugin::getParameterUnit(parameterId, strBuf);
 586     }
 587
 588     bool getParameterComment(const uint32_t parameterId, char* const strBuf) const noexcept override
 589     {
 590         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr, false);
 591         CARLA_SAFE_ASSERT_RETURN(fDescriptor->get_parameter_info != nullptr, false);
 592         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr, false);
 593         CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count, false);
 594
 595         // FIXME - try
 596         if (const NativeParameter* const param = fDescriptor->get_parameter_info(fHandle, parameterId))
 597         {
 598             if (param->comment != nullptr)
 599             {
 600                 std::strncpy(strBuf, param->comment, STR_MAX);
 601                 return true;
 602             }
 603
 604             return CarlaPlugin::getParameterComment(parameterId, strBuf);
 605         }
 606
 607         carla_safe_assert("const Parameter* const param = fDescriptor->get_parameter_info(fHandle, parameterId)", __FILE__, __LINE__);
 608         return CarlaPlugin::getParameterComment(parameterId, strBuf);
 609     }
 610
 611     bool getParameterGroupName(const uint32_t parameterId, char* const strBuf) const noexcept override
 612     {
 613         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr, false);
 614         CARLA_SAFE_ASSERT_RETURN(fDescriptor->get_parameter_info != nullptr, false);
 615         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr, false);
 616         CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count, false);
 617
 618         // FIXME - try
 619         if (const NativeParameter* const param = fDescriptor->get_parameter_info(fHandle, parameterId))
 620         {
 621             if (param->groupName != nullptr)
 622             {
 623                 std::strncpy(strBuf, param->groupName, STR_MAX);
 624                 return true;
 625             }
 626
 627             return CarlaPlugin::getParameterGroupName(parameterId, strBuf);
 628         }
 629
 630         carla_safe_assert("const Parameter* const param = fDescriptor->get_parameter_info(fHandle, parameterId)", __FILE__, __LINE__);
 631         return CarlaPlugin::getParameterGroupName(parameterId, strBuf);
 632     }
 633
 634     bool getParameterScalePointLabel(const uint32_t parameterId, const uint32_t scalePointId, char* const strBuf) const noexcept override
 635     {
 636         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr, false);
 637         CARLA_SAFE_ASSERT_RETURN(fDescriptor->get_parameter_info != nullptr, false);
 638         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr, false);
 639         CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count, false);
 640
 641         // FIXME - try
 642         if (const NativeParameter* const param = fDescriptor->get_parameter_info(fHandle, parameterId))
 643         {
 644             CARLA_SAFE_ASSERT_RETURN(scalePointId < param->scalePointCount, false);
 645
 646             const NativeParameterScalePoint* scalePoint(&param->scalePoints[scalePointId]);
 647
 648             if (scalePoint->label != nullptr)
 649             {
 650                 std::strncpy(strBuf, scalePoint->label, STR_MAX);
 651                 return true;
 652             }
 653
 654             carla_safe_assert("scalePoint->label != nullptr", __FILE__, __LINE__);
 655             return CarlaPlugin::getParameterScalePointLabel(parameterId, scalePointId, strBuf);
 656         }
 657
 658         carla_safe_assert("const Parameter* const param = fDescriptor->get_parameter_info(fHandle, parameterId)", __FILE__, __LINE__);
 659         return CarlaPlugin::getParameterScalePointLabel(parameterId, scalePointId, strBuf);
 660     }
 661
 662     // -------------------------------------------------------------------
 663     // Set data (state)
 664
 665     void prepareForSave(bool) override
 666     {
 667         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);
 668         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);
 669
 670         if (pData->midiprog.count > 0 && fDescriptor->category == NATIVE_PLUGIN_CATEGORY_SYNTH)
 671         {
 672             char strBuf[STR_MAX+1];
 673             std::snprintf(strBuf, STR_MAX, "%i:%i:%i:%i:%i:%i:%i:%i:%i:%i:%i:%i:%i:%i:%i:%i",
 674                           fCurMidiProgs[0],  fCurMidiProgs[1],  fCurMidiProgs[2],  fCurMidiProgs[3],
 675                           fCurMidiProgs[4],  fCurMidiProgs[5],  fCurMidiProgs[6],  fCurMidiProgs[7],
 676                           fCurMidiProgs[8],  fCurMidiProgs[9],  fCurMidiProgs[10], fCurMidiProgs[11],
 677                           fCurMidiProgs[12], fCurMidiProgs[13], fCurMidiProgs[14], fCurMidiProgs[15]);
 678             strBuf[STR_MAX] = '\0';
 679
 680             CarlaPlugin::setCustomData(CUSTOM_DATA_TYPE_STRING, "midiPrograms", strBuf, false);
 681         }
 682
 683         if (fDescriptor == nullptr || fDescriptor->get_state == nullptr || (fDescriptor->hints & NATIVE_PLUGIN_USES_STATE) == 0)
 684             return;
 685
 686         if (char* data = fDescriptor->get_state(fHandle))
 687         {
 688             CarlaPlugin::setCustomData(CUSTOM_DATA_TYPE_CHUNK, "State", data, false);
 689             std::free(data);
 690         }
 691     }
 692
 693     // -------------------------------------------------------------------
 694     // Set data (internal stuff)
 695
 696     void setName(const char* const newName) override
 697     {
 698         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);
 699         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);
 700         CARLA_SAFE_ASSERT_RETURN(newName != nullptr && newName[0] != '\0',);
 701
 702         CarlaPlugin::setName(newName);
 703
 704         if (pData->uiTitle.isEmpty())
 705             setWindowTitle(nullptr);
 706     }
 707
 708     void setCtrlChannel(const int8_t channel, const bool sendOsc, const bool sendCallback) noexcept override
 709     {
 710         if (channel >= 0 && channel < MAX_MIDI_CHANNELS && pData->midiprog.count > 0)
 711             pData->midiprog.current = fCurMidiProgs[channel];
 712
 713         CarlaPlugin::setCtrlChannel(channel, sendOsc, sendCallback);
 714     }
 715
 716     void setWindowTitle(const char* const title) noexcept
 717     {
 718         CarlaString uiName;
 719
 720         if (title != nullptr)
 721         {
 722             uiName = title;
 723         }
 724         else
 725         {
 726             uiName  = pData->name;
 727             uiName += " (GUI)";
 728         }
 729
 730         std::free(const_cast<char*>(fHost.uiName));
 731         fHost.uiName = uiName.releaseBufferPointer();
 732
 733         if (fDescriptor->dispatcher != nullptr && fIsUiVisible)
 734         {
 735             try {
 736                 fDescriptor->dispatcher(fHandle,
 737                                         NATIVE_PLUGIN_OPCODE_UI_NAME_CHANGED,
 738                                         0, 0,
 739                                         const_cast<char*>(fHost.uiName),
 740                                         0.0f);
 741             } CARLA_SAFE_EXCEPTION("set custom ui title");
 742         }
 743
 744     }
 745
 746     // -------------------------------------------------------------------
 747     // Set data (plugin-specific stuff)
 748
 749     void setParameterValue(const uint32_t parameterId, const float value, const bool sendGui, const bool sendOsc, const bool sendCallback) noexcept override
 750     {
 751         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);
 752         CARLA_SAFE_ASSERT_RETURN(fDescriptor->set_parameter_value != nullptr,);
 753         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);
 754         CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count,);
 755
 756         const float fixedValue(pData->param.getFixedValue(parameterId, value));
 757
 758         // FIXME - try
 759         fDescriptor->set_parameter_value(fHandle, parameterId, fixedValue);
 760
 761         if (fHandle2 != nullptr)
 762             fDescriptor->set_parameter_value(fHandle2, parameterId, fixedValue);
 763
 764         CarlaPlugin::setParameterValue(parameterId, fixedValue, sendGui, sendOsc, sendCallback);
 765     }
 766
 767     void setParameterValueRT(const uint32_t parameterId, const float value, const uint32_t frameOffset, const bool sendCallbackLater) noexcept override
 768     {
 769         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);
 770         CARLA_SAFE_ASSERT_RETURN(fDescriptor->set_parameter_value != nullptr,);
 771         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);
 772         CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count,);
 773
 774         const float fixedValue(pData->param.getFixedValue(parameterId, value));
 775
 776         // FIXME - try
 777         fDescriptor->set_parameter_value(fHandle, parameterId, fixedValue);
 778
 779         if (fHandle2 != nullptr)
 780             fDescriptor->set_parameter_value(fHandle2, parameterId, fixedValue);
 781
 782         CarlaPlugin::setParameterValueRT(parameterId, fixedValue, frameOffset, sendCallbackLater);
 783     }
 784
 785     void setCustomData(const char* const type, const char* const key, const char* const value, const bool sendGui) override
 786     {
 787         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);
 788         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);
 789         CARLA_SAFE_ASSERT_RETURN(type != nullptr && type[0] != '\0',);
 790         CARLA_SAFE_ASSERT_RETURN(key != nullptr && key[0] != '\0',);
 791         CARLA_SAFE_ASSERT_RETURN(value != nullptr,);
 792         carla_debug("CarlaPluginNative::setCustomData(\"%s\", \"%s\", ..., %s)", type, key, bool2str(sendGui));
 793
 794         if (std::strcmp(type, CUSTOM_DATA_TYPE_PROPERTY) == 0)
 795             return CarlaPlugin::setCustomData(type, key, value, sendGui);
 796
 797         if (std::strcmp(type, CUSTOM_DATA_TYPE_PATH) == 0)
 798         {
 799             CARLA_SAFE_ASSERT_RETURN(std::strcmp(key, "file") == 0,);
 800             CARLA_SAFE_ASSERT_RETURN(value[0] != '\0',);
 801         }
 802         else if (std::strcmp(type, CUSTOM_DATA_TYPE_STRING) != 0 && std::strcmp(type, CUSTOM_DATA_TYPE_CHUNK) != 0)
 803         {
 804             return carla_stderr2("CarlaPluginNative::setCustomData(\"%s\", \"%s\", \"%s\", %s) - type is invalid",
 805                                  type, key, value, bool2str(sendGui));
 806         }
 807
 808         if (std::strcmp(type, CUSTOM_DATA_TYPE_CHUNK) == 0)
 809         {
 810             if (fDescriptor->set_state != nullptr && (fDescriptor->hints & NATIVE_PLUGIN_USES_STATE) != 0)
 811             {
 812                 const ScopedSingleProcessLocker spl(this, true);
 813
 814                 fDescriptor->set_state(fHandle, value);
 815
 816                 if (fHandle2 != nullptr)
 817                     fDescriptor->set_state(fHandle2, value);
 818             }
 819         }
 820         else if (std::strcmp(key, "midiPrograms") == 0 && fDescriptor->set_midi_program != nullptr)
 821         {
 822             StringArray midiProgramList(StringArray::fromTokens(value, ":", ""));
 823
 824             if (midiProgramList.size() == MAX_MIDI_CHANNELS)
 825             {
 826                 uint8_t channel = 0;
 827                 for (String *it=midiProgramList.begin(), *end=midiProgramList.end(); it != end; ++it)
 828                 {
 829                     const int index(it->getIntValue());
 830
 831                     if (index >= 0 && index < static_cast<int>(pData->midiprog.count))
 832                     {
 833                         const uint32_t bank    = pData->midiprog.data[index].bank;
 834                         const uint32_t program = pData->midiprog.data[index].program;
 835
 836                         fDescriptor->set_midi_program(fHandle, channel, bank, program);
 837
 838                         if (fHandle2 != nullptr)
 839                             fDescriptor->set_midi_program(fHandle2, channel, bank, program);
 840
 841                         fCurMidiProgs[channel] = index;
 842
 843                         if (pData->ctrlChannel == static_cast<int32_t>(channel))
 844                         {
 845                             pData->midiprog.current = index;
 846                             pData->engine->callback(true, true,
 847                                                     ENGINE_CALLBACK_MIDI_PROGRAM_CHANGED,
 848                                                     pData->id,
 849                                                     index,
 850                                                     0, 0, 0.0f, nullptr);
 851                         }
 852                     }
 853
 854                     ++channel;
 855                 }
 856                 CARLA_SAFE_ASSERT(channel == MAX_MIDI_CHANNELS);
 857             }
 858         }
 859         else
 860         {
 861             if (fDescriptor->set_custom_data != nullptr)
 862             {
 863                 fDescriptor->set_custom_data(fHandle, key, value);
 864
 865                 if (fHandle2 != nullptr)
 866                     fDescriptor->set_custom_data(fHandle2, key, value);
 867             }
 868
 869             if (sendGui && fIsUiVisible && fDescriptor->ui_set_custom_data != nullptr)
 870                 fDescriptor->ui_set_custom_data(fHandle, key, value);
 871         }
 872
 873         CarlaPlugin::setCustomData(type, key, value, sendGui);
 874     }
 875
 876     void setMidiProgram(const int32_t index, const bool sendGui, const bool sendOsc, const bool sendCallback, const bool doingInit) noexcept override
 877     {
 878         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);
 879         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);
 880         CARLA_SAFE_ASSERT_RETURN(index >= -1 && index < static_cast<int32_t>(pData->midiprog.count),);
 881         CARLA_SAFE_ASSERT_RETURN(sendGui || sendOsc || sendCallback || doingInit,);
 882
 883         // TODO, put into check below
 884         if ((pData->hints & PLUGIN_IS_SYNTH) != 0 && (pData->ctrlChannel < 0 || pData->ctrlChannel >= MAX_MIDI_CHANNELS))
 885            return CarlaPlugin::setMidiProgram(index, sendGui, sendOsc, sendCallback, doingInit);
 886
 887         if (index >= 0)
 888         {
 889             const uint8_t  channel = uint8_t((pData->ctrlChannel >= 0 && pData->ctrlChannel < MAX_MIDI_CHANNELS) ? pData->ctrlChannel : 0);
 890             const uint32_t bank    = pData->midiprog.data[index].bank;
 891             const uint32_t program = pData->midiprog.data[index].program;
 892
 893             const ScopedSingleProcessLocker spl(this, (sendGui || sendOsc || sendCallback));
 894
 895             try {
 896                 fDescriptor->set_midi_program(fHandle, channel, bank, program);
 897             } catch(...) {}
 898
 899             if (fHandle2 != nullptr)
 900             {
 901                 try {
 902                     fDescriptor->set_midi_program(fHandle2, channel, bank, program);
 903                 } catch(...) {}
 904             }
 905
 906             fCurMidiProgs[channel] = index;
 907         }
 908
 909         CarlaPlugin::setMidiProgram(index, sendGui, sendOsc, sendCallback, doingInit);
 910     }
 911
 912     // FIXME: this is never used
 913     void setMidiProgramRT(const uint32_t index, const bool sendCallbackLater) noexcept override
 914     {
 915         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);
 916         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);
 917         CARLA_SAFE_ASSERT_RETURN(index < pData->midiprog.count,);
 918
 919         // TODO, put into check below
 920         if ((pData->hints & PLUGIN_IS_SYNTH) != 0 && (pData->ctrlChannel < 0 || pData->ctrlChannel >= MAX_MIDI_CHANNELS))
 921            return CarlaPlugin::setMidiProgramRT(index, sendCallbackLater);
 922
 923         const uint8_t  channel = uint8_t((pData->ctrlChannel >= 0 && pData->ctrlChannel < MAX_MIDI_CHANNELS) ? pData->ctrlChannel : 0);
 924         const uint32_t bank    = pData->midiprog.data[index].bank;
 925         const uint32_t program = pData->midiprog.data[index].program;
 926
 927         try {
 928             fDescriptor->set_midi_program(fHandle, channel, bank, program);
 929         } catch(...) {}
 930
 931         if (fHandle2 != nullptr)
 932         {
 933             try {
 934                 fDescriptor->set_midi_program(fHandle2, channel, bank, program);
 935             } catch(...) {}
 936         }
 937
 938         fCurMidiProgs[channel] = static_cast<int32_t>(index);
 939
 940         CarlaPlugin::setMidiProgramRT(index, sendCallbackLater);
 941     }
 942
 943     // -------------------------------------------------------------------
 944     // Set ui stuff
 945
 946     void setCustomUITitle(const char* const title) noexcept override
 947     {
 948         setWindowTitle(title);
 949         CarlaPlugin::setCustomUITitle(title);
 950     }
 951
 952     void showCustomUI(const bool yesNo) override
 953     {
 954         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);
 955         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);
 956
 957         if (fDescriptor->ui_show == nullptr)
 958             return;
 959
 960         fIsUiAvailable = true;
 961
 962         fDescriptor->ui_show(fHandle, yesNo);
 963
 964         // UI might not be available, see NATIVE_HOST_OPCODE_UI_UNAVAILABLE
 965         if (yesNo && ! fIsUiAvailable)
 966             return;
 967
 968         fIsUiVisible = yesNo;
 969
 970         if (! yesNo)
 971         {
 972 #ifndef BUILD_BRIDGE
 973             pData->transientTryCounter = 0;
 974 #endif
 975             return;
 976         }
 977
 978 #ifndef BUILD_BRIDGE
 979         if ((fDescriptor->hints & NATIVE_PLUGIN_USES_PARENT_ID) == 0 && std::strstr(fDescriptor->label, "file") == nullptr)
 980             pData->tryTransient();
 981 #endif
 982
 983         if (fDescriptor->ui_set_custom_data != nullptr)
 984         {
 985             for (LinkedList<CustomData>::Itenerator it = pData->custom.begin2(); it.valid(); it.next())
 986             {
 987                 const CustomData& cData(it.getValue(kCustomDataFallback));
 988                 CARLA_SAFE_ASSERT_CONTINUE(cData.isValid());
 989
 990                 if (std::strcmp(cData.type, CUSTOM_DATA_TYPE_STRING) == 0 && std::strcmp(cData.key, "midiPrograms") != 0)
 991                     fDescriptor->ui_set_custom_data(fHandle, cData.key, cData.value);
 992             }
 993         }
 994
 995         if (fDescriptor->ui_set_midi_program != nullptr && pData->midiprog.current >= 0 && pData->midiprog.count > 0)
 996         {
 997             const int32_t  index   = pData->midiprog.current;
 998             const uint8_t  channel = uint8_t((pData->ctrlChannel >= 0 && pData->ctrlChannel < MAX_MIDI_CHANNELS) ? pData->ctrlChannel : 0);
 999             const uint32_t bank    = pData->midiprog.data[index].bank;
1000             const uint32_t program = pData->midiprog.data[index].program;
1001
1002             fDescriptor->ui_set_midi_program(fHandle, channel, bank, program);
1003         }
1004
1005         if (fDescriptor->ui_set_parameter_value != nullptr)
1006         {
1007             for (uint32_t i=0; i < pData->param.count; ++i)
1008                 fDescriptor->ui_set_parameter_value(fHandle, i, fDescriptor->get_parameter_value(fHandle, i));
1009         }
1010     }
1011
1012     void idle() override
1013     {
1014         if (fNeedsIdle)
1015         {
1016             fNeedsIdle = false;
1017             fDescriptor->dispatcher(fHandle, NATIVE_PLUGIN_OPCODE_IDLE, 0, 0, nullptr, 0.0f);
1018         }
1019
1020         if (fInlineDisplayNeedsRedraw)
1021         {
1022             // TESTING
1023             CARLA_SAFE_ASSERT(pData->enabled)
1024             CARLA_SAFE_ASSERT(!pData->engine->isAboutToClose());
1025             CARLA_SAFE_ASSERT(pData->client->isActive());
1026
1027             if (pData->enabled && !pData->engine->isAboutToClose() && pData->client->isActive())
1028             {
1029                 const int64_t timeNow = water::Time::currentTimeMillis();
1030
1031                 if (timeNow - fInlineDisplayLastRedrawTime > (1000 / 30))
1032                 {
1033                     fInlineDisplayNeedsRedraw = false;
1034                     fInlineDisplayLastRedrawTime = timeNow;
1035                     pData->engine->callback(true, true,
1036                                             ENGINE_CALLBACK_INLINE_DISPLAY_REDRAW,
1037                                             pData->id,
1038                                             0, 0, 0, 0.0f, nullptr);
1039                 }
1040             }
1041             else
1042             {
1043                 fInlineDisplayNeedsRedraw = false;
1044             }
1045         }
1046
1047         CarlaPlugin::idle();
1048     }
1049
1050     void uiIdle() override
1051     {
1052         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);
1053         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);
1054
1055         if (fIsUiVisible && fDescriptor->ui_idle != nullptr)
1056             fDescriptor->ui_idle(fHandle);
1057
1058         CarlaPlugin::uiIdle();
1059     }
1060
1061     // -------------------------------------------------------------------
1062     // Plugin state
1063
1064     void reload() override
1065     {
1066         CARLA_SAFE_ASSERT_RETURN(pData->engine != nullptr,);
1067         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);
1068         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);
1069         carla_debug("CarlaPluginNative::reload() - start");
1070
1071         const EngineProcessMode processMode(pData->engine->getProccessMode());
1072
1073         // Safely disable plugin for reload
1074         const ScopedDisabler sd(this);
1075
1076         if (pData->active)
1077             deactivate();
1078
1079         clearBuffers();
1080
1081         uint32_t aIns, aOuts, cvIns, cvOuts, mIns, mOuts, j;
1082
1083         bool forcedStereoIn, forcedStereoOut;
1084         forcedStereoIn = forcedStereoOut = false;
1085
1086         bool needsCtrlIn, needsCtrlOut;
1087         needsCtrlIn = needsCtrlOut = false;
1088
1089         aIns   = fDescriptor->audioIns;
1090         aOuts  = fDescriptor->audioOuts;
1091         cvIns  = fDescriptor->cvIns;
1092         cvOuts = fDescriptor->cvOuts;
1093         mIns   = fDescriptor->midiIns;
1094         mOuts  = fDescriptor->midiOuts;
1095
1096         if ((pData->options & PLUGIN_OPTION_FORCE_STEREO) != 0 && (aIns == 1 || aOuts == 1) && mIns <= 1 && mOuts <= 1)
1097         {
1098             if (fHandle2 == nullptr)
1099                 fHandle2 = fDescriptor->instantiate(&fHost);
1100
1101             if (fHandle2 != nullptr)
1102             {
1103                 if (aIns == 1)
1104                 {
1105                     aIns = 2;
1106                     forcedStereoIn = true;
1107                 }
1108
1109                 if (aOuts == 1)
1110                 {
1111                     aOuts = 2;
1112                     forcedStereoOut = true;
1113                 }
1114             }
1115         }
1116
1117         if (aIns > 0)
1118         {
1119             pData->audioIn.createNew(aIns);
1120         }
1121
1122         if (aOuts > 0)
1123         {
1124             pData->audioOut.createNew(aOuts);
1125             needsCtrlIn = true;
1126         }
1127
1128         if (cvIns > 0)
1129         {
1130             pData->cvIn.createNew(cvIns);
1131         }
1132
1133         if (cvOuts > 0)
1134         {
1135             pData->cvOut.createNew(cvOuts);
1136         }
1137
1138         if (const uint32_t acIns = aIns + cvIns)
1139         {
1140             fAudioAndCvInBuffers = new float*[acIns];
1141             carla_zeroPointers(fAudioAndCvInBuffers, acIns);
1142         }
1143
1144         if (const uint32_t acOuts = aOuts + cvOuts)
1145         {
1146             fAudioAndCvOutBuffers = new float*[acOuts];
1147             carla_zeroPointers(fAudioAndCvOutBuffers, acOuts);
1148         }
1149
1150         if (mIns > 0)
1151         {
1152             fMidiIn.createNew(mIns);
1153             needsCtrlIn = (mIns == 1);
1154         }
1155
1156         if (mOuts > 0)
1157         {
1158             fMidiOut.createNew(mOuts);
1159             needsCtrlOut = (mOuts == 1);
1160         }
1161
1162         const uint portNameSize(pData->engine->getMaxPortNameSize());
1163         CarlaString portName;
1164
1165         // Audio Ins
1166         for (j=0; j < aIns; ++j)
1167         {
1168             portName.clear();
1169
1170             if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)
1171             {
1172                 portName  = pData->name;
1173                 portName += ":";
1174             }
1175
1176             if (fDescriptor->get_buffer_port_name != nullptr)
1177             {
1178                 portName += fDescriptor->get_buffer_port_name(fHandle, forcedStereoIn ? 0 : j, false);
1179             }
1180             else if (aIns > 1 && ! forcedStereoIn)
1181             {
1182                 portName += "input_";
1183                 portName += CarlaString(j+1);
1184             }
1185             else
1186                 portName += "input";
1187
1188             portName.truncate(portNameSize);
1189
1190             pData->audioIn.ports[j].port   = (CarlaEngineAudioPort*)pData->client->addPort(kEnginePortTypeAudio, portName, true, j);
1191             pData->audioIn.ports[j].rindex = j;
1192
1193             if (forcedStereoIn)
1194             {
1195                 portName += "_2";
1196                 pData->audioIn.ports[1].port   = (CarlaEngineAudioPort*)pData->client->addPort(kEnginePortTypeAudio, portName, true, 1);
1197                 pData->audioIn.ports[1].rindex = j;
1198                 break;
1199             }
1200         }
1201
1202         // Audio Outs
1203         for (j=0; j < aOuts; ++j)
1204         {
1205             portName.clear();
1206
1207             if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)
1208             {
1209                 portName  = pData->name;
1210                 portName += ":";
1211             }
1212
1213             if (fDescriptor->get_buffer_port_name != nullptr)
1214             {
1215                 portName += fDescriptor->get_buffer_port_name(fHandle, forcedStereoOut ? 0 : j, true);
1216             }
1217             else if (aOuts > 1 && ! forcedStereoOut)
1218             {
1219                 portName += "output_";
1220                 portName += CarlaString(j+1);
1221             }
1222             else
1223                 portName += "output";
1224
1225             portName.truncate(portNameSize);
1226
1227             pData->audioOut.ports[j].port   = (CarlaEngineAudioPort*)pData->client->addPort(kEnginePortTypeAudio, portName, false, j);
1228             pData->audioOut.ports[j].rindex = j;
1229
1230             if (forcedStereoOut)
1231             {
1232                 portName += "_2";
1233                 pData->audioOut.ports[1].port   = (CarlaEngineAudioPort*)pData->client->addPort(kEnginePortTypeAudio, portName, false, 1);
1234                 pData->audioOut.ports[1].rindex = j;
1235                 break;
1236             }
1237         }
1238
1239         // CV Ins
1240         for (j=0; j < cvIns; ++j)
1241         {
1242             portName.clear();
1243
1244             if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)
1245             {
1246                 portName  = pData->name;
1247                 portName += ":";
1248             }
1249
1250             if (fDescriptor->get_buffer_port_name != nullptr)
1251             {
1252                 portName += fDescriptor->get_buffer_port_name(fHandle, fDescriptor->audioIns + j, false);
1253             }
1254             else if (cvIns > 1)
1255             {
1256                 portName += "cv_input_";
1257                 portName += CarlaString(j+1);
1258             }
1259             else
1260                 portName += "cv_input";
1261
1262             portName.truncate(portNameSize);
1263
1264             float min = -1.0f, max = 1.0f;
1265             if (fDescriptor->get_buffer_port_range != nullptr)
1266             {
1267                 if (const NativePortRange* const range = fDescriptor->get_buffer_port_range(fHandle,
1268                                                                                             fDescriptor->audioIns + j,
1269                                                                                             false))
1270                 {
1271                     min = range->minimum;
1272                     max = range->maximum;
1273                 }
1274             }
1275
1276             pData->cvIn.ports[j].port   = (CarlaEngineCVPort*)pData->client->addPort(kEnginePortTypeCV, portName, true, j);
1277             pData->cvIn.ports[j].rindex = j;
1278             pData->cvIn.ports[j].port->setRange(min, max);
1279         }
1280
1281         // CV Outs
1282         for (j=0; j < cvOuts; ++j)
1283         {
1284             portName.clear();
1285
1286             if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)
1287             {
1288                 portName  = pData->name;
1289                 portName += ":";
1290             }
1291
1292             if (fDescriptor->get_buffer_port_name != nullptr)
1293             {
1294                 portName += fDescriptor->get_buffer_port_name(fHandle, fDescriptor->audioOuts + j, true);
1295             }
1296             else if (cvOuts > 1)
1297             {
1298                 portName += "cv_output_";
1299                 portName += CarlaString(j+1);
1300             }
1301             else
1302                 portName += "cv_output";
1303
1304             portName.truncate(portNameSize);
1305
1306             float min = -1.0f, max = 1.0f;
1307             if (fDescriptor->get_buffer_port_range != nullptr)
1308             {
1309                 if (const NativePortRange* const range = fDescriptor->get_buffer_port_range(fHandle,
1310                                                                                             fDescriptor->audioOuts + j,
1311                                                                                             true))
1312                 {
1313                     min = range->minimum;
1314                     max = range->maximum;
1315                 }
1316             }
1317
1318             pData->cvOut.ports[j].port   = (CarlaEngineCVPort*)pData->client->addPort(kEnginePortTypeCV, portName, false, j);
1319             pData->cvOut.ports[j].rindex = j;
1320             pData->cvOut.ports[j].port->setRange(min, max);
1321         }
1322
1323         // MIDI Input (only if multiple)
1324         if (mIns > 1)
1325         {
1326             for (j=0; j < mIns; ++j)
1327             {
1328                 portName.clear();
1329
1330                 if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)
1331                 {
1332                     portName  = pData->name;
1333                     portName += ":";
1334                 }
1335
1336                 portName += "midi-in_";
1337                 portName += CarlaString(j+1);
1338                 portName.truncate(portNameSize);
1339
1340                 fMidiIn.ports[j]   = (CarlaEngineEventPort*)pData->client->addPort(kEnginePortTypeEvent, portName, true, j);
1341                 fMidiIn.indexes[j] = j;
1342             }
1343
1344             pData->event.portIn = fMidiIn.ports[0];
1345         }
1346
1347         // MIDI Output (only if multiple)
1348         if (mOuts > 1)
1349         {
1350             for (j=0; j < mOuts; ++j)
1351             {
1352                 portName.clear();
1353
1354                 if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)
1355                 {
1356                     portName  = pData->name;
1357                     portName += ":";
1358                 }
1359
1360                 portName += "midi-out_";
1361                 portName += CarlaString(j+1);
1362                 portName.truncate(portNameSize);
1363
1364                 fMidiOut.ports[j]   = (CarlaEngineEventPort*)pData->client->addPort(kEnginePortTypeEvent, portName, false, j);
1365                 fMidiOut.indexes[j] = j;
1366             }
1367
1368             pData->event.portOut = fMidiOut.ports[0];
1369         }
1370
1371         reloadParameters(&needsCtrlIn, &needsCtrlOut);
1372
1373         if (needsCtrlIn || mIns == 1)
1374         {
1375             portName.clear();
1376
1377             if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)
1378             {
1379                 portName  = pData->name;
1380                 portName += ":";
1381             }
1382
1383             portName += "events-in";
1384             portName.truncate(portNameSize);
1385
1386             pData->event.portIn = (CarlaEngineEventPort*)pData->client->addPort(kEnginePortTypeEvent, portName, true, 0);
1387 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
1388             pData->event.cvSourcePorts = pData->client->createCVSourcePorts();
1389 #endif
1390         }
1391
1392         if (needsCtrlOut || mOuts == 1)
1393         {
1394             portName.clear();
1395
1396             if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)
1397             {
1398                 portName  = pData->name;
1399                 portName += ":";
1400             }
1401
1402             portName += "events-out";
1403             portName.truncate(portNameSize);
1404
1405             pData->event.portOut = (CarlaEngineEventPort*)pData->client->addPort(kEnginePortTypeEvent, portName, false, 0);
1406         }
1407
1408         if (forcedStereoIn || forcedStereoOut)
1409             pData->options |= PLUGIN_OPTION_FORCE_STEREO;
1410         else
1411             pData->options &= ~PLUGIN_OPTION_FORCE_STEREO;
1412
1413         // plugin hints
1414         pData->hints = 0x0;
1415
1416         if (aOuts > 0 && (aIns == aOuts || aIns == 1))
1417             pData->hints |= PLUGIN_CAN_DRYWET;
1418
1419         if (aOuts > 0)
1420             pData->hints |= PLUGIN_CAN_VOLUME;
1421
1422         if (aOuts >= 2 && aOuts % 2 == 0)
1423             pData->hints |= PLUGIN_CAN_BALANCE;
1424
1425         // native plugin hints
1426         if (fDescriptor->hints & NATIVE_PLUGIN_IS_RTSAFE)
1427             pData->hints |= PLUGIN_IS_RTSAFE;
1428         if (fDescriptor->hints & NATIVE_PLUGIN_IS_SYNTH)
1429             pData->hints |= PLUGIN_IS_SYNTH;
1430         if (fDescriptor->hints & NATIVE_PLUGIN_HAS_UI)
1431             pData->hints |= PLUGIN_HAS_CUSTOM_UI;
1432         if (fDescriptor->hints & NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS)
1433             pData->hints |= PLUGIN_NEEDS_FIXED_BUFFERS;
1434         if (fDescriptor->hints & NATIVE_PLUGIN_NEEDS_UI_MAIN_THREAD)
1435             pData->hints |= PLUGIN_NEEDS_UI_MAIN_THREAD;
1436         if (fDescriptor->hints & NATIVE_PLUGIN_NEEDS_UI_OPEN_SAVE)
1437             pData->hints |= PLUGIN_HAS_CUSTOM_UI_USING_FILE_OPEN;
1438         if (fDescriptor->hints & NATIVE_PLUGIN_USES_MULTI_PROGS)
1439             pData->hints |= PLUGIN_USES_MULTI_PROGS;
1440         if (fDescriptor->hints & NATIVE_PLUGIN_HAS_INLINE_DISPLAY)
1441             pData->hints |= PLUGIN_HAS_INLINE_DISPLAY;
1442
1443         // extra plugin hints
1444         pData->extraHints = 0x0;
1445
1446         bufferSizeChanged(pData->engine->getBufferSize());
1447         reloadPrograms(true);
1448
1449         if (pData->active)
1450             activate();
1451
1452         carla_debug("CarlaPluginNative::reload() - end");
1453     }
1454
1455     void reloadParameters(bool* const needsCtrlIn, bool* const needsCtrlOut)
1456     {
1457         carla_debug("CarlaPluginNative::reloadParameters() - start");
1458
1459         const float sampleRate = static_cast<float>(pData->engine->getSampleRate());
1460         const uint32_t params = (fDescriptor->get_parameter_count != nullptr && fDescriptor->get_parameter_info != nullptr)
1461                               ? fDescriptor->get_parameter_count(fHandle)
1462                               : 0;
1463
1464         pData->param.clear();
1465
1466         if (params > 0)
1467         {
1468             pData->param.createNew(params, true);
1469         }
1470
1471         for (uint32_t j=0; j < params; ++j)
1472         {
1473             const NativeParameter* const paramInfo(fDescriptor->get_parameter_info(fHandle, j));
1474
1475             CARLA_SAFE_ASSERT_CONTINUE(paramInfo != nullptr);
1476
1477             pData->param.data[j].type   = PARAMETER_UNKNOWN;
1478             pData->param.data[j].index  = static_cast<int32_t>(j);
1479             pData->param.data[j].rindex = static_cast<int32_t>(j);
1480
1481             float min, max, def, step, stepSmall, stepLarge;
1482
1483             // min value
1484             min = paramInfo->ranges.min;
1485
1486             // max value
1487             max = paramInfo->ranges.max;
1488
1489             if (min > max)
1490                 max = min;
1491
1492             if (carla_isEqual(min, max))
1493             {
1494                 carla_stderr2("WARNING - Broken plugin parameter '%s': max == min", paramInfo->name);
1495                 max = min + 0.1f;
1496             }
1497
1498             // default value
1499             def = paramInfo->ranges.def;
1500
1501             if (def < min)
1502                 def = min;
1503             else if (def > max)
1504                 def = max;
1505
1506             if (paramInfo->hints & NATIVE_PARAMETER_USES_SAMPLE_RATE)
1507             {
1508                 min *= sampleRate;
1509                 max *= sampleRate;
1510                 def *= sampleRate;
1511                 pData->param.data[j].hints |= PARAMETER_USES_SAMPLERATE;
1512             }
1513
1514             if (paramInfo->hints & NATIVE_PARAMETER_IS_BOOLEAN)
1515             {
1516                 step = max - min;
1517                 stepSmall = step;
1518                 stepLarge = step;
1519                 pData->param.data[j].hints |= PARAMETER_IS_BOOLEAN;
1520             }
1521             else if (paramInfo->hints & NATIVE_PARAMETER_IS_INTEGER)
1522             {
1523                 step = 1.0f;
1524                 stepSmall = 1.0f;
1525                 stepLarge = 10.0f;
1526                 pData->param.data[j].hints |= PARAMETER_IS_INTEGER;
1527             }
1528             else
1529             {
1530                 float range = max - min;
1531                 step = range/100.0f;
1532                 stepSmall = range/1000.0f;
1533                 stepLarge = range/10.0f;
1534             }
1535
1536             if (paramInfo->hints & NATIVE_PARAMETER_IS_OUTPUT)
1537             {
1538                 pData->param.data[j].type = PARAMETER_OUTPUT;
1539                 if (needsCtrlOut != nullptr)
1540                     *needsCtrlOut = true;
1541             }
1542             else
1543             {
1544                 pData->param.data[j].type = PARAMETER_INPUT;
1545                 if (needsCtrlIn != nullptr)
1546                     *needsCtrlIn = true;
1547             }
1548
1549             // extra parameter hints
1550             if (paramInfo->hints & NATIVE_PARAMETER_IS_ENABLED)
1551             {
1552                 pData->param.data[j].hints |= PARAMETER_IS_ENABLED;
1553
1554                 if (paramInfo->hints & NATIVE_PARAMETER_IS_AUTOMATABLE)
1555                 {
1556                     pData->param.data[j].hints |= PARAMETER_IS_AUTOMATABLE;
1557                     pData->param.data[j].hints |= PARAMETER_CAN_BE_CV_CONTROLLED;
1558                 }
1559             }
1560
1561             if (paramInfo->hints & NATIVE_PARAMETER_IS_LOGARITHMIC)
1562                 pData->param.data[j].hints |= PARAMETER_IS_LOGARITHMIC;
1563
1564             if (paramInfo->hints & NATIVE_PARAMETER_USES_SCALEPOINTS)
1565                 pData->param.data[j].hints |= PARAMETER_USES_SCALEPOINTS;
1566
1567             pData->param.ranges[j].min = min;
1568             pData->param.ranges[j].max = max;
1569             pData->param.ranges[j].def = def;
1570             pData->param.ranges[j].step = step;
1571             pData->param.ranges[j].stepSmall = stepSmall;
1572             pData->param.ranges[j].stepLarge = stepLarge;
1573         }
1574
1575         carla_debug("CarlaPluginNative::reloadParameters() - end");
1576     }
1577
1578     void reloadPrograms(const bool doInit) override
1579     {
1580         carla_debug("CarlaPluginNative::reloadPrograms(%s)", bool2str(doInit));
1581         uint32_t i, oldCount  = pData->midiprog.count;
1582         const int32_t current = pData->midiprog.current;
1583
1584         // Delete old programs
1585         pData->midiprog.clear();
1586
1587         // Query new programs
1588         uint32_t count = 0;
1589         if (fDescriptor->get_midi_program_count != nullptr && fDescriptor->get_midi_program_info != nullptr && fDescriptor->set_midi_program != nullptr)
1590             count = fDescriptor->get_midi_program_count(fHandle);
1591
1592         if (count > 0)
1593         {
1594             pData->midiprog.createNew(count);
1595
1596             // Update data
1597             for (i=0; i < count; ++i)
1598             {
1599                 const NativeMidiProgram* const mpDesc(fDescriptor->get_midi_program_info(fHandle, i));
1600                 CARLA_SAFE_ASSERT_CONTINUE(mpDesc != nullptr);
1601
1602                 pData->midiprog.data[i].bank    = mpDesc->bank;
1603                 pData->midiprog.data[i].program = mpDesc->program;
1604                 pData->midiprog.data[i].name    = carla_strdup(mpDesc->name);
1605             }
1606         }
1607
1608         if (doInit)
1609         {
1610             if (count > 0)
1611                 setMidiProgram(0, false, false, false, true);
1612         }
1613         else
1614         {
1615             // Check if current program is invalid
1616             bool programChanged = false;
1617
1618             if (count == oldCount+1)
1619             {
1620                 // one midi program added, probably created by user
1621                 pData->midiprog.current = static_cast<int32_t>(oldCount);
1622                 programChanged = true;
1623             }
1624             else if (current < 0 && count > 0)
1625             {
1626                 // programs exist now, but not before
1627                 pData->midiprog.current = 0;
1628                 programChanged = true;
1629             }
1630             else if (current >= 0 && count == 0)
1631             {
1632                 // programs existed before, but not anymore
1633                 pData->midiprog.current = -1;
1634                 programChanged = true;
1635             }
1636             else if (current >= static_cast<int32_t>(count))
1637             {
1638                 // current midi program > count
1639                 pData->midiprog.current = 0;
1640                 programChanged = true;
1641             }
1642             else
1643             {
1644                 // no change
1645                 pData->midiprog.current = current;
1646             }
1647
1648             if (programChanged)
1649                 setMidiProgram(pData->midiprog.current, true, true, true, false);
1650
1651             pData->engine->callback(true, true,
1652                                     ENGINE_CALLBACK_RELOAD_PROGRAMS,
1653                                     pData->id,
1654                                     0, 0, 0, 0.0f, nullptr);
1655         }
1656     }
1657
1658     // -------------------------------------------------------------------
1659     // Plugin processing
1660
1661     void activate() noexcept override
1662     {
1663         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);
1664         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);
1665
1666         if (fDescriptor->activate != nullptr)
1667         {
1668             try {
1669                 fDescriptor->activate(fHandle);
1670             } catch(...) {}
1671
1672             if (fHandle2 != nullptr)
1673             {
1674                 try {
1675                     fDescriptor->activate(fHandle2);
1676                 } catch(...) {}
1677             }
1678         }
1679     }
1680
1681     void deactivate() noexcept override
1682     {
1683         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);
1684         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);
1685
1686         if (fDescriptor->deactivate != nullptr)
1687         {
1688             try {
1689                 fDescriptor->deactivate(fHandle);
1690             } catch(...) {}
1691
1692             if (fHandle2 != nullptr)
1693             {
1694                 try {
1695                     fDescriptor->deactivate(fHandle2);
1696                 } catch(...) {}
1697             }
1698         }
1699     }
1700
1701     EngineEvent& findNextEvent()
1702     {
1703         if (fMidiIn.count == 1)
1704         {
1705             NativePluginMidiInData::MultiPortData& multiportData(fMidiIn.multiportData[0]);
1706
1707             if (multiportData.usedIndex == multiportData.cachedEventCount)
1708             {
1709                 const uint32_t eventCount = pData->event.portIn->getEventCount();
1710                 CARLA_SAFE_ASSERT_INT2(eventCount == multiportData.cachedEventCount,
1711                                        eventCount, multiportData.cachedEventCount);
1712                 return kNullEngineEvent;
1713             }
1714
1715             return pData->event.portIn->getEvent(multiportData.usedIndex++);
1716         }
1717
1718         uint32_t lowestSampleTime = 9999999;
1719         uint32_t portMatching = 0;
1720         bool found = false;
1721
1722         // process events in order for multiple ports
1723         for (uint32_t m=0; m < fMidiIn.count; ++m)
1724         {
1725             CarlaEngineEventPort* const eventPort(fMidiIn.ports[m]);
1726             NativePluginMidiInData::MultiPortData& multiportData(fMidiIn.multiportData[m]);
1727
1728             if (multiportData.usedIndex == multiportData.cachedEventCount)
1729                 continue;
1730
1731             const EngineEvent& event(eventPort->getEventUnchecked(multiportData.usedIndex));
1732
1733             if (event.time < lowestSampleTime)
1734             {
1735                 lowestSampleTime = event.time;
1736                 portMatching = m;
1737                 found = true;
1738             }
1739         }
1740
1741         if (found)
1742         {
1743             CarlaEngineEventPort* const eventPort(fMidiIn.ports[portMatching]);
1744             NativePluginMidiInData::MultiPortData& multiportData(fMidiIn.multiportData[portMatching]);
1745
1746             return eventPort->getEvent(multiportData.usedIndex++);
1747         }
1748
1749         return kNullEngineEvent;
1750     }
1751
1752     void process(const float* const* const audioIn, float** const audioOut,
1753                  const float* const* const cvIn, float** const cvOut, const uint32_t frames) override
1754     {
1755         // --------------------------------------------------------------------------------------------------------
1756         // Check if active
1757
1758         if (! pData->active)
1759         {
1760             // disable any output sound
1761             for (uint32_t i=0; i < pData->audioOut.count; ++i)
1762                 carla_zeroFloats(audioOut[i], frames);
1763             for (uint32_t i=0; i < pData->cvOut.count; ++i)
1764                 carla_zeroFloats(cvOut[i], frames);
1765             return;
1766         }
1767
1768         fMidiEventInCount = fMidiEventOutCount = 0;
1769         carla_zeroStructs(fMidiInEvents, kPluginMaxMidiEvents);
1770         carla_zeroStructs(fMidiOutEvents, kPluginMaxMidiEvents);
1771
1772         // --------------------------------------------------------------------------------------------------------
1773         // Check if needs reset
1774
1775         if (pData->needsReset)
1776         {
1777             if (pData->options & PLUGIN_OPTION_SEND_ALL_SOUND_OFF)
1778             {
1779                 fMidiEventInCount = MAX_MIDI_CHANNELS*2;
1780
1781                 for (uint8_t k=0, i=MAX_MIDI_CHANNELS; k < MAX_MIDI_CHANNELS; ++k)
1782                 {
1783                     fMidiInEvents[k].data[0] = uint8_t(MIDI_STATUS_CONTROL_CHANGE | (k & MIDI_CHANNEL_BIT));
1784                     fMidiInEvents[k].data[1] = MIDI_CONTROL_ALL_NOTES_OFF;
1785                     fMidiInEvents[k].data[2] = 0;
1786                     fMidiInEvents[k].size    = 3;
1787
1788                     fMidiInEvents[k+i].data[0] = uint8_t(MIDI_STATUS_CONTROL_CHANGE | (k & MIDI_CHANNEL_BIT));
1789                     fMidiInEvents[k+i].data[1] = MIDI_CONTROL_ALL_SOUND_OFF;
1790                     fMidiInEvents[k+i].data[2] = 0;
1791                     fMidiInEvents[k+i].size    = 3;
1792                 }
1793             }
1794             else if (pData->ctrlChannel >= 0 && pData->ctrlChannel < MAX_MIDI_CHANNELS)
1795             {
1796                 fMidiEventInCount = MAX_MIDI_NOTE;
1797
1798                 for (uint8_t k=0; k < MAX_MIDI_NOTE; ++k)
1799                 {
1800                     fMidiInEvents[k].data[0] = uint8_t(MIDI_STATUS_NOTE_OFF | (pData->ctrlChannel & MIDI_CHANNEL_BIT));
1801                     fMidiInEvents[k].data[1] = k;
1802                     fMidiInEvents[k].data[2] = 0;
1803                     fMidiInEvents[k].size    = 3;
1804                 }
1805             }
1806
1807             pData->needsReset = false;
1808         }
1809
1810         // --------------------------------------------------------------------------------------------------------
1811         // Set TimeInfo
1812
1813         const EngineTimeInfo timeInfo(pData->engine->getTimeInfo());
1814
1815         fTimeInfo.playing = timeInfo.playing;
1816         fTimeInfo.frame   = timeInfo.frame;
1817         fTimeInfo.usecs   = timeInfo.usecs;
1818
1819         if (timeInfo.bbt.valid)
1820         {
1821             fTimeInfo.bbt.valid = true;
1822
1823             fTimeInfo.bbt.bar  = timeInfo.bbt.bar;
1824             fTimeInfo.bbt.beat = timeInfo.bbt.beat;
1825             fTimeInfo.bbt.tick = timeInfo.bbt.tick;
1826             fTimeInfo.bbt.barStartTick = timeInfo.bbt.barStartTick;
1827
1828             fTimeInfo.bbt.beatsPerBar = timeInfo.bbt.beatsPerBar;
1829             fTimeInfo.bbt.beatType    = timeInfo.bbt.beatType;
1830
1831             fTimeInfo.bbt.ticksPerBeat   = timeInfo.bbt.ticksPerBeat;
1832             fTimeInfo.bbt.beatsPerMinute = timeInfo.bbt.beatsPerMinute;
1833         }
1834         else
1835         {
1836             fTimeInfo.bbt.valid = false;
1837         }
1838
1839 #if 0
1840         // This test code has proven to be quite useful
1841         // So I am leaving it behind, I might need it again..
1842         if (pData->id == 1)
1843         {
1844             static int64_t last_frame = timeInfo.frame;
1845             static int64_t last_dev_frame = 0;
1846             static double last_val = timeInfo.bbt.barStartTick + ((timeInfo.bbt.beat-1) * timeInfo.bbt.ticksPerBeat) + timeInfo.bbt.tick;
1847             static double last_dev_val = 0.0;
1848
1849             int64_t cur_frame = timeInfo.frame;
1850             int64_t cur_dev_frame = cur_frame - last_frame;
1851
1852             double cur_val = timeInfo.bbt.barStartTick + ((timeInfo.bbt.beat-1) * timeInfo.bbt.ticksPerBeat) + timeInfo.bbt.tick;
1853             double cur_dev_val = cur_val - last_val;
1854
1855             if (std::abs(last_dev_val - cur_dev_val) >= 0.0001 || last_dev_frame != cur_dev_frame)
1856             {
1857                 carla_stdout("currently %u at %u => %f : DEV1: %li : DEV2: %f",
1858                             frames,
1859                             timeInfo.frame,
1860                             cur_val,
1861                             cur_dev_frame,
1862                             cur_dev_val);
1863             }
1864
1865             last_val = cur_val;
1866             last_dev_val = cur_dev_val;
1867             last_frame = cur_frame;
1868             last_dev_frame = cur_dev_frame;
1869         }
1870 #endif
1871
1872         // --------------------------------------------------------------------------------------------------------
1873         // Event Input and Processing
1874
1875         if (pData->event.portIn != nullptr)
1876         {
1877             // ----------------------------------------------------------------------------------------------------
1878             // MIDI Input (External)
1879
1880             if (pData->extNotes.mutex.tryLock())
1881             {
1882                 ExternalMidiNote note = { 0, 0, 0 };
1883
1884                 for (; fMidiEventInCount < kPluginMaxMidiEvents && ! pData->extNotes.data.isEmpty();)
1885                 {
1886                     note = pData->extNotes.data.getFirst(note, true);
1887
1888                     CARLA_SAFE_ASSERT_CONTINUE(note.channel >= 0 && note.channel < MAX_MIDI_CHANNELS);
1889
1890                     NativeMidiEvent& nativeEvent(fMidiInEvents[fMidiEventInCount++]);
1891
1892                     nativeEvent.data[0] = uint8_t((note.velo > 0 ? MIDI_STATUS_NOTE_ON : MIDI_STATUS_NOTE_OFF) | (note.channel & MIDI_CHANNEL_BIT));
1893                     nativeEvent.data[1] = note.note;
1894                     nativeEvent.data[2] = note.velo;
1895                     nativeEvent.size    = 3;
1896                 }
1897
1898                 pData->extNotes.mutex.unlock();
1899
1900             } // End of MIDI Input (External)
1901
1902             // ----------------------------------------------------------------------------------------------------
1903             // Event Input (System)
1904
1905 #ifndef BUILD_BRIDGE
1906             bool allNotesOffSent = false;
1907 #endif
1908             const bool isSampleAccurate = (pData->options & PLUGIN_OPTION_FIXED_BUFFERS) == 0;
1909
1910             uint32_t startTime  = 0;
1911             uint32_t timeOffset = 0;
1912             uint32_t nextBankId;
1913
1914             if (pData->midiprog.current >= 0 && pData->midiprog.count > 0)
1915                 nextBankId = pData->midiprog.data[pData->midiprog.current].bank;
1916             else
1917                 nextBankId = 0;
1918
1919 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
1920             if (cvIn != nullptr && pData->event.cvSourcePorts != nullptr)
1921                 pData->event.cvSourcePorts->initPortBuffers(cvIn + pData->cvIn.count, frames, isSampleAccurate, pData->event.portIn);
1922 #endif
1923
1924             for (;;)
1925             {
1926                 EngineEvent& event(findNextEvent());
1927
1928                 if (event.type == kEngineEventTypeNull)
1929                     break;
1930
1931                 uint32_t eventTime = event.time;
1932                 CARLA_SAFE_ASSERT_UINT2_CONTINUE(eventTime < frames, eventTime, frames);
1933
1934                 if (eventTime < timeOffset)
1935                 {
1936                     carla_stderr2("Timing error, eventTime:%u < timeOffset:%u for '%s'",
1937                                   eventTime, timeOffset, pData->name);
1938                     eventTime = timeOffset;
1939                 }
1940
1941                 if (isSampleAccurate && eventTime > timeOffset)
1942                 {
1943                     if (processSingle(audioIn, audioOut, cvIn, cvOut, eventTime - timeOffset, timeOffset))
1944                     {
1945                         startTime  = 0;
1946                         timeOffset = eventTime;
1947
1948                         if (pData->midiprog.current >= 0 && pData->midiprog.count > 0)
1949                             nextBankId = pData->midiprog.data[pData->midiprog.current].bank;
1950                         else
1951                             nextBankId = 0;
1952
1953                         if (fMidiEventInCount > 0)
1954                         {
1955                             carla_zeroStructs(fMidiInEvents, fMidiEventInCount);
1956                             fMidiEventInCount = 0;
1957                         }
1958
1959                         if (fMidiEventOutCount > 0)
1960                         {
1961                             carla_zeroStructs(fMidiOutEvents, fMidiEventOutCount);
1962                             fMidiEventOutCount = 0;
1963                         }
1964                     }
1965                     else
1966                         startTime += timeOffset;
1967                 }
1968
1969                 // Control change
1970                 switch (event.type)
1971                 {
1972                 case kEngineEventTypeNull:
1973                     break;
1974
1975                 case kEngineEventTypeControl: {
1976                     EngineControlEvent& ctrlEvent(event.ctrl);
1977
1978                     switch (ctrlEvent.type)
1979                     {
1980                     case kEngineControlEventTypeNull:
1981                         break;
1982
1983                     case kEngineControlEventTypeParameter: {
1984                         float value;
1985
1986 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
1987                         // non-midi
1988                         if (event.channel == kEngineEventNonMidiChannel)
1989                         {
1990                             const uint32_t k = ctrlEvent.param;
1991                             CARLA_SAFE_ASSERT_CONTINUE(k < pData->param.count);
1992
1993                             ctrlEvent.handled = true;
1994                             value = pData->param.getFinalUnnormalizedValue(k, ctrlEvent.normalizedValue);
1995                             setParameterValueRT(k, value, event.time, true);
1996                             continue;
1997                         }
1998
1999                         // Control backend stuff
2000                         if (event.channel == pData->ctrlChannel)
2001                         {
2002                             if (MIDI_IS_CONTROL_BREATH_CONTROLLER(ctrlEvent.param) && (pData->hints & PLUGIN_CAN_DRYWET) > 0)
2003                             {
2004                                 ctrlEvent.handled = true;
2005                                 value = ctrlEvent.normalizedValue;
2006                                 setDryWetRT(value, true);
2007                             }
2008                             else if (MIDI_IS_CONTROL_CHANNEL_VOLUME(ctrlEvent.param) && (pData->hints & PLUGIN_CAN_VOLUME) > 0)
2009                             {
2010                                 ctrlEvent.handled = true;
2011                                 value = ctrlEvent.normalizedValue*127.0f/100.0f;
2012                                 setVolumeRT(value, true);
2013                             }
2014                             else if (MIDI_IS_CONTROL_BALANCE(ctrlEvent.param) && (pData->hints & PLUGIN_CAN_BALANCE) > 0)
2015                             {
2016                                 float left, right;
2017                                 value = ctrlEvent.normalizedValue/0.5f - 1.0f;
2018
2019                                 if (value < 0.0f)
2020                                 {
2021                                     left  = -1.0f;
2022                                     right = (value*2.0f)+1.0f;
2023                                 }
2024                                 else if (value > 0.0f)
2025                                 {
2026                                     left  = (value*2.0f)-1.0f;
2027                                     right = 1.0f;
2028                                 }
2029                                 else
2030                                 {
2031                                     left  = -1.0f;
2032                                     right = 1.0f;
2033                                 }
2034
2035                                 ctrlEvent.handled = true;
2036                                 setBalanceLeftRT(left, true);
2037                                 setBalanceRightRT(right, true);
2038                             }
2039                         }
2040 #endif
2041                         // Control plugin parameters
2042                         for (uint32_t k=0; k < pData->param.count; ++k)
2043                         {
2044                             if (pData->param.data[k].midiChannel != event.channel)
2045                                 continue;
2046                             if (pData->param.data[k].mappedControlIndex != ctrlEvent.param)
2047                                 continue;
2048                             if (pData->param.data[k].type != PARAMETER_INPUT)
2049                                 continue;
2050                             if ((pData->param.data[k].hints & PARAMETER_IS_AUTOMATABLE) == 0)
2051                                 continue;
2052
2053                             ctrlEvent.handled = true;
2054                             value = pData->param.getFinalUnnormalizedValue(k, ctrlEvent.normalizedValue);
2055                             setParameterValueRT(k, value, event.time, true);
2056                         }
2057
2058                         if ((pData->options & PLUGIN_OPTION_SEND_CONTROL_CHANGES) != 0 && ctrlEvent.param < MAX_MIDI_VALUE)
2059                         {
2060                             if (fMidiEventInCount >= kPluginMaxMidiEvents)
2061                                 continue;
2062
2063                             NativeMidiEvent& nativeEvent(fMidiInEvents[fMidiEventInCount++]);
2064                             carla_zeroStruct(nativeEvent);
2065
2066                             nativeEvent.time    = isSampleAccurate ? startTime : eventTime;
2067                             nativeEvent.data[0] = uint8_t(MIDI_STATUS_CONTROL_CHANGE | (event.channel & MIDI_CHANNEL_BIT));
2068                             nativeEvent.data[1] = uint8_t(ctrlEvent.param);
2069                             nativeEvent.data[2] = uint8_t(ctrlEvent.normalizedValue*127.0f + 0.5f);
2070                             nativeEvent.size    = 3;
2071                         }
2072
2073 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
2074                         if (! ctrlEvent.handled)
2075                             checkForMidiLearn(event);
2076 #endif
2077                         break;
2078                     } // case kEngineControlEventTypeParameter
2079
2080                     case kEngineControlEventTypeMidiBank:
2081                         if (pData->options & PLUGIN_OPTION_MAP_PROGRAM_CHANGES)
2082                         {
2083                             if (event.channel == pData->ctrlChannel)
2084                                 nextBankId = ctrlEvent.param;
2085                         }
2086                         else if (pData->options & PLUGIN_OPTION_SEND_PROGRAM_CHANGES)
2087                         {
2088                             if (fMidiEventInCount >= kPluginMaxMidiEvents)
2089                                 continue;
2090
2091                             NativeMidiEvent& nativeEvent(fMidiInEvents[fMidiEventInCount++]);
2092                             carla_zeroStruct(nativeEvent);
2093
2094                             nativeEvent.time    = isSampleAccurate ? startTime : eventTime;
2095                             nativeEvent.data[0] = uint8_t(MIDI_STATUS_CONTROL_CHANGE | (event.channel & MIDI_CHANNEL_BIT));
2096                             nativeEvent.data[1] = MIDI_CONTROL_BANK_SELECT;
2097                             nativeEvent.data[2] = uint8_t(ctrlEvent.param);
2098                             nativeEvent.size    = 3;
2099                         }
2100                         break;
2101
2102                     case kEngineControlEventTypeMidiProgram:
2103                         if (pData->options & PLUGIN_OPTION_MAP_PROGRAM_CHANGES)
2104                         {
2105                             if (event.channel < MAX_MIDI_CHANNELS)
2106                             {
2107                                 const uint32_t nextProgramId(ctrlEvent.param);
2108
2109                                 for (uint32_t k=0; k < pData->midiprog.count; ++k)
2110                                 {
2111                                     if (pData->midiprog.data[k].bank == nextBankId && pData->midiprog.data[k].program == nextProgramId)
2112                                     {
2113                                         fDescriptor->set_midi_program(fHandle, event.channel, nextBankId, nextProgramId);
2114
2115                                         if (fHandle2 != nullptr)
2116                                             fDescriptor->set_midi_program(fHandle2, event.channel, nextBankId, nextProgramId);
2117
2118                                         fCurMidiProgs[event.channel] = static_cast<int32_t>(k);
2119
2120                                         if (event.channel == pData->ctrlChannel)
2121                                         {
2122                                             pData->postponeMidiProgramChangeRtEvent(true, k);
2123                                         }
2124
2125                                         break;
2126                                     }
2127                                 }
2128                             }
2129                         }
2130                         else if (pData->options & PLUGIN_OPTION_SEND_PROGRAM_CHANGES)
2131                         {
2132                             if (fMidiEventInCount >= kPluginMaxMidiEvents)
2133                                 continue;
2134
2135                             NativeMidiEvent& nativeEvent(fMidiInEvents[fMidiEventInCount++]);
2136                             carla_zeroStruct(nativeEvent);
2137
2138                             nativeEvent.time    = isSampleAccurate ? startTime : eventTime;
2139                             nativeEvent.data[0] = uint8_t(MIDI_STATUS_PROGRAM_CHANGE | (event.channel & MIDI_CHANNEL_BIT));
2140                             nativeEvent.data[1] = uint8_t(ctrlEvent.param);
2141                             nativeEvent.size    = 2;
2142                         }
2143                         break;
2144
2145                     case kEngineControlEventTypeAllSoundOff:
2146                         if (pData->options & PLUGIN_OPTION_SEND_ALL_SOUND_OFF)
2147                         {
2148                             if (fMidiEventInCount >= kPluginMaxMidiEvents)
2149                                 continue;
2150
2151                             NativeMidiEvent& nativeEvent(fMidiInEvents[fMidiEventInCount++]);
2152                             carla_zeroStruct(nativeEvent);
2153
2154                             nativeEvent.time    = isSampleAccurate ? startTime : eventTime;
2155                             nativeEvent.data[0] = uint8_t(MIDI_STATUS_CONTROL_CHANGE | (event.channel & MIDI_CHANNEL_BIT));
2156                             nativeEvent.data[1] = MIDI_CONTROL_ALL_SOUND_OFF;
2157                             nativeEvent.data[2] = 0;
2158                             nativeEvent.size    = 3;
2159                         }
2160                         break;
2161
2162                     case kEngineControlEventTypeAllNotesOff:
2163                         if (pData->options & PLUGIN_OPTION_SEND_ALL_SOUND_OFF)
2164                         {
2165 #ifndef BUILD_BRIDGE
2166                             if (event.channel == pData->ctrlChannel && ! allNotesOffSent)
2167                             {
2168                                 allNotesOffSent = true;
2169                                 postponeRtAllNotesOff();
2170                             }
2171 #endif
2172
2173                             if (fMidiEventInCount >= kPluginMaxMidiEvents)
2174                                 continue;
2175
2176                             NativeMidiEvent& nativeEvent(fMidiInEvents[fMidiEventInCount++]);
2177                             carla_zeroStruct(nativeEvent);
2178
2179                             nativeEvent.time    = isSampleAccurate ? startTime : eventTime;
2180                             nativeEvent.data[0] = uint8_t(MIDI_STATUS_CONTROL_CHANGE | (event.channel & MIDI_CHANNEL_BIT));
2181                             nativeEvent.data[1] = MIDI_CONTROL_ALL_NOTES_OFF;
2182                             nativeEvent.data[2] = 0;
2183                             nativeEvent.size    = 3;
2184                         }
2185                         break;
2186                     }
2187                     break;
2188                 }
2189
2190                 case kEngineEventTypeMidi: {
2191                     if (fMidiEventInCount >= kPluginMaxMidiEvents)
2192                         continue;
2193
2194                     const EngineMidiEvent& midiEvent(event.midi);
2195
2196                     if (midiEvent.size > 4)
2197                         continue;
2198 #ifdef CARLA_PROPER_CPP11_SUPPORT
2199                     static_assert(4 <= EngineMidiEvent::kDataSize, "Incorrect data");
2200 #endif
2201
2202                     uint8_t status = uint8_t(MIDI_GET_STATUS_FROM_DATA(midiEvent.data));
2203
2204                     if ((status == MIDI_STATUS_NOTE_OFF || status == MIDI_STATUS_NOTE_ON) && (pData->options & PLUGIN_OPTION_SKIP_SENDING_NOTES))
2205                         continue;
2206                     if (status == MIDI_STATUS_CHANNEL_PRESSURE && (pData->options & PLUGIN_OPTION_SEND_CHANNEL_PRESSURE) == 0)
2207                         continue;
2208                     if (status == MIDI_STATUS_CONTROL_CHANGE && (pData->options & PLUGIN_OPTION_SEND_CONTROL_CHANGES) == 0)
2209                         continue;
2210                     if (status == MIDI_STATUS_POLYPHONIC_AFTERTOUCH && (pData->options & PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH) == 0)
2211                         continue;
2212                     if (status == MIDI_STATUS_PITCH_WHEEL_CONTROL && (pData->options & PLUGIN_OPTION_SEND_PITCHBEND) == 0)
2213                         continue;
2214
2215                     // Fix bad note-off
2216                     if (status == MIDI_STATUS_NOTE_ON && midiEvent.data[2] == 0)
2217                         status = MIDI_STATUS_NOTE_OFF;
2218
2219                     NativeMidiEvent& nativeEvent(fMidiInEvents[fMidiEventInCount++]);
2220                     carla_zeroStruct(nativeEvent);
2221
2222                     nativeEvent.port = midiEvent.port;
2223                     nativeEvent.time = isSampleAccurate ? startTime : eventTime;
2224                     nativeEvent.size = midiEvent.size;
2225
2226                     nativeEvent.data[0] = uint8_t(status | (event.channel & MIDI_CHANNEL_BIT));
2227                     nativeEvent.data[1] = midiEvent.size >= 2 ? midiEvent.data[1] : 0;
2228                     nativeEvent.data[2] = midiEvent.size >= 3 ? midiEvent.data[2] : 0;
2229                     nativeEvent.data[3] = midiEvent.size == 4 ? midiEvent.data[3] : 0;
2230
2231                     if (status == MIDI_STATUS_NOTE_ON)
2232                     {
2233                         pData->postponeNoteOnRtEvent(true, event.channel, midiEvent.data[1], midiEvent.data[2]);
2234                     }
2235                     else if (status == MIDI_STATUS_NOTE_OFF)
2236                     {
2237                         pData->postponeNoteOffRtEvent(true, event.channel, midiEvent.data[1]);
2238                     }
2239                 } break;
2240                 } // switch (event.type)
2241             }
2242
2243             pData->postRtEvents.trySplice();
2244
2245             if (frames > timeOffset)
2246                 processSingle(audioIn, audioOut, cvIn, cvOut, frames - timeOffset, timeOffset);
2247
2248         } // End of Event Input and Processing
2249
2250         // --------------------------------------------------------------------------------------------------------
2251         // Plugin processing (no events)
2252
2253         else
2254         {
2255             processSingle(audioIn, audioOut, cvIn, cvOut, frames, 0);
2256
2257         } // End of Plugin processing (no events)
2258
2259 #ifndef BUILD_BRIDGE
2260         // --------------------------------------------------------------------------------------------------------
2261         // Control Output
2262
2263         if (pData->event.portOut != nullptr)
2264         {
2265             float value, curValue;
2266
2267             for (uint32_t k=0; k < pData->param.count; ++k)
2268             {
2269                 if (pData->param.data[k].type != PARAMETER_OUTPUT)
2270                     continue;
2271
2272                 curValue = fDescriptor->get_parameter_value(fHandle, k);
2273                 pData->param.ranges[k].fixValue(curValue);
2274
2275                 if (pData->param.data[k].mappedControlIndex > 0)
2276                 {
2277                     value = pData->param.ranges[k].getNormalizedValue(curValue);
2278                     pData->event.portOut->writeControlEvent(0,
2279                                                             pData->param.data[k].midiChannel,
2280                                                             kEngineControlEventTypeParameter,
2281                                                             static_cast<uint16_t>(pData->param.data[k].mappedControlIndex),
2282                                                             -1,
2283                                                             value);
2284                 }
2285             }
2286         } // End of Control Output
2287 #endif
2288     }
2289
2290     bool processSingle(const float* const* const audioIn, float** const audioOut,
2291                        const float* const* const cvIn, float** const cvOut,
2292                        const uint32_t frames, const uint32_t timeOffset)
2293     {
2294         CARLA_SAFE_ASSERT_RETURN(frames > 0, false);
2295
2296         if (pData->audioIn.count > 0) {
2297             CARLA_SAFE_ASSERT_RETURN(audioIn != nullptr, false);
2298         }
2299         if (pData->audioOut.count > 0) {
2300             CARLA_SAFE_ASSERT_RETURN(audioOut != nullptr, false);
2301         }
2302         if (pData->cvIn.count > 0) {
2303             CARLA_SAFE_ASSERT_RETURN(cvIn != nullptr, false);
2304         }
2305         if (pData->cvOut.count > 0) {
2306             CARLA_SAFE_ASSERT_RETURN(cvOut != nullptr, false);
2307         }
2308
2309         // --------------------------------------------------------------------------------------------------------
2310         // Try lock, silence otherwise
2311
2312         if (fIsOffline)
2313         {
2314             pData->singleMutex.lock();
2315         }
2316         else if (! pData->singleMutex.tryLock())
2317         {
2318             for (uint32_t i=0; i < pData->audioOut.count; ++i)
2319             {
2320                 for (uint32_t k=0; k < frames; ++k)
2321                     audioOut[i][k+timeOffset] = 0.0f;
2322             }
2323             for (uint32_t i=0; i < pData->cvOut.count; ++i)
2324             {
2325                 for (uint32_t k=0; k < frames; ++k)
2326                     cvOut[i][k+timeOffset] = 0.0f;
2327             }
2328
2329             return false;
2330         }
2331
2332         // --------------------------------------------------------------------------------------------------------
2333         // Set audio buffers
2334
2335         {
2336             for (uint32_t i=0; i < pData->audioIn.count; ++i)
2337                 carla_copyFloats(fAudioAndCvInBuffers[i], audioIn[i]+timeOffset, frames);
2338             for (uint32_t i=0; i < pData->cvIn.count; ++i)
2339                 carla_copyFloats(fAudioAndCvInBuffers[pData->audioIn.count+i], cvIn[i]+timeOffset, frames);
2340
2341             for (uint32_t i=0; i < pData->audioOut.count; ++i)
2342                 carla_zeroFloats(fAudioAndCvOutBuffers[i], frames);
2343             for (uint32_t i=0; i < pData->cvOut.count; ++i)
2344                 carla_zeroFloats(fAudioAndCvOutBuffers[pData->audioOut.count+i], frames);
2345         }
2346
2347         // --------------------------------------------------------------------------------------------------------
2348         // Run plugin
2349
2350         fIsProcessing = true;
2351
2352         if (fHandle2 == nullptr)
2353         {
2354             fDescriptor->process(fHandle,
2355                                  fAudioAndCvInBuffers, fAudioAndCvOutBuffers, frames,
2356                                  fMidiInEvents, fMidiEventInCount);
2357         }
2358         else
2359         {
2360             fDescriptor->process(fHandle,
2361                                  (fAudioAndCvInBuffers != nullptr)  ? &fAudioAndCvInBuffers[0]  : nullptr,
2362                                  (fAudioAndCvOutBuffers != nullptr) ? &fAudioAndCvOutBuffers[0] : nullptr,
2363                                  frames, fMidiInEvents, fMidiEventInCount);
2364
2365             fDescriptor->process(fHandle2,
2366                                  (fAudioAndCvInBuffers != nullptr)  ? &fAudioAndCvInBuffers[1]  : nullptr,
2367                                  (fAudioAndCvOutBuffers != nullptr) ? &fAudioAndCvOutBuffers[1] : nullptr,
2368                                  frames, fMidiInEvents, fMidiEventInCount);
2369         }
2370
2371         fIsProcessing = false;
2372
2373         if (fTimeInfo.playing)
2374             fTimeInfo.frame += frames;
2375
2376         uint32_t i=0;
2377 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
2378         // --------------------------------------------------------------------------------------------------------
2379         // Post-processing (dry/wet, volume and balance)
2380
2381         {
2382             const bool doDryWet  = (pData->hints & PLUGIN_CAN_DRYWET) != 0 && carla_isNotEqual(pData->postProc.dryWet, 1.0f);
2383             const bool doBalance = (pData->hints & PLUGIN_CAN_BALANCE) != 0 && ! (carla_isEqual(pData->postProc.balanceLeft, -1.0f) && carla_isEqual(pData->postProc.balanceRight, 1.0f));
2384
2385             bool isPair;
2386             float bufValue;
2387             float* const oldBufLeft = pData->postProc.extraBuffer;
2388
2389             for (; i < pData->audioOut.count; ++i)
2390             {
2391                 // Dry/Wet
2392                 if (doDryWet)
2393                 {
2394                     for (uint32_t k=0; k < frames; ++k)
2395                     {
2396                         bufValue = fAudioAndCvInBuffers[(pData->audioIn.count == 1) ? 0 : i][k];
2397                         fAudioAndCvOutBuffers[i][k] = (fAudioAndCvOutBuffers[i][k] * pData->postProc.dryWet) + (bufValue * (1.0f - pData->postProc.dryWet));
2398                     }
2399                 }
2400
2401                 // Balance
2402                 if (doBalance)
2403                 {
2404                     isPair = (i % 2 == 0);
2405
2406                     if (isPair)
2407                     {
2408                         CARLA_ASSERT(i+1 < pData->audioOut.count);
2409                         carla_copyFloats(oldBufLeft, fAudioAndCvOutBuffers[i], frames);
2410                     }
2411
2412                     float balRangeL = (pData->postProc.balanceLeft  + 1.0f)/2.0f;
2413                     float balRangeR = (pData->postProc.balanceRight + 1.0f)/2.0f;
2414
2415                     for (uint32_t k=0; k < frames; ++k)
2416                     {
2417                         if (isPair)
2418                         {
2419                             // left
2420                             fAudioAndCvOutBuffers[i][k]  = oldBufLeft[k]            * (1.0f - balRangeL);
2421                             fAudioAndCvOutBuffers[i][k] += fAudioAndCvOutBuffers[i+1][k] * (1.0f - balRangeR);
2422                         }
2423                         else
2424                         {
2425                             // right
2426                             fAudioAndCvOutBuffers[i][k]  = fAudioAndCvOutBuffers[i][k] * balRangeR;
2427                             fAudioAndCvOutBuffers[i][k] += oldBufLeft[k]          * balRangeL;
2428                         }
2429                     }
2430                 }
2431
2432                 // Volume (and buffer copy)
2433                 {
2434                     for (uint32_t k=0; k < frames; ++k)
2435                         audioOut[i][k+timeOffset] = fAudioAndCvOutBuffers[i][k] * pData->postProc.volume;
2436                 }
2437             }
2438
2439         } // End of Post-processing
2440 #else
2441         for (; i < pData->audioOut.count; ++i)
2442         {
2443             for (uint32_t k=0; k < frames; ++k)
2444                 audioOut[i][k+timeOffset] = fAudioAndCvOutBuffers[i][k];
2445         }
2446 #endif
2447         // CV stuff too
2448         for (; i < pData->cvOut.count; ++i)
2449         {
2450             for (uint32_t k=0; k < frames; ++k)
2451                 cvOut[i][k+timeOffset] = fAudioAndCvOutBuffers[pData->audioOut.count+i][k];
2452         }
2453
2454         // --------------------------------------------------------------------------------------------------------
2455         // MIDI Output
2456
2457         if (pData->event.portOut != nullptr)
2458         {
2459             for (uint32_t k = 0; k < fMidiEventOutCount; ++k)
2460             {
2461                 const uint8_t channel = uint8_t(MIDI_GET_CHANNEL_FROM_DATA(fMidiOutEvents[k].data));
2462                 const uint8_t port    = fMidiOutEvents[k].port;
2463
2464                 if (fMidiOut.count > 1 && port < fMidiOut.count)
2465                     fMidiOut.ports[port]->writeMidiEvent(fMidiOutEvents[k].time+timeOffset, channel, fMidiOutEvents[k].size, fMidiOutEvents[k].data);
2466                 else
2467                     pData->event.portOut->writeMidiEvent(fMidiOutEvents[k].time+timeOffset, channel, fMidiOutEvents[k].size, fMidiOutEvents[k].data);
2468             }
2469         }
2470
2471         // --------------------------------------------------------------------------------------------------------
2472
2473         pData->singleMutex.unlock();
2474         return true;
2475     }
2476
2477     void bufferSizeChanged(const uint32_t newBufferSize) override
2478     {
2479         CARLA_ASSERT_INT(newBufferSize > 0, newBufferSize);
2480         carla_debug("CarlaPluginNative::bufferSizeChanged(%i)", newBufferSize);
2481
2482         for (uint32_t i=0; i < (pData->audioIn.count+pData->cvIn.count); ++i)
2483         {
2484             if (fAudioAndCvInBuffers[i] != nullptr)
2485                 delete[] fAudioAndCvInBuffers[i];
2486             fAudioAndCvInBuffers[i] = new float[newBufferSize];
2487         }
2488
2489         for (uint32_t i=0; i < (pData->audioOut.count+pData->cvOut.count); ++i)
2490         {
2491             if (fAudioAndCvOutBuffers[i] != nullptr)
2492                 delete[] fAudioAndCvOutBuffers[i];
2493             fAudioAndCvOutBuffers[i] = new float[newBufferSize];
2494         }
2495
2496         if (fCurBufferSize != newBufferSize)
2497         {
2498             fCurBufferSize = newBufferSize;
2499
2500             if (fDescriptor != nullptr && fDescriptor->dispatcher != nullptr)
2501             {
2502                 fDescriptor->dispatcher(fHandle, NATIVE_PLUGIN_OPCODE_BUFFER_SIZE_CHANGED, 0, static_cast<intptr_t>(newBufferSize), nullptr, 0.0f);
2503
2504                 if (fHandle2 != nullptr)
2505                     fDescriptor->dispatcher(fHandle2, NATIVE_PLUGIN_OPCODE_BUFFER_SIZE_CHANGED, 0, static_cast<intptr_t>(newBufferSize), nullptr, 0.0f);
2506             }
2507         }
2508
2509         CarlaPlugin::bufferSizeChanged(newBufferSize);
2510     }
2511
2512     void sampleRateChanged(const double newSampleRate) override
2513     {
2514         CARLA_ASSERT_INT(newSampleRate > 0.0, newSampleRate);
2515         carla_debug("CarlaPluginNative::sampleRateChanged(%g)", newSampleRate);
2516
2517         if (carla_isEqual(fCurSampleRate, newSampleRate))
2518             return;
2519
2520         fCurSampleRate = newSampleRate;
2521
2522         if (fDescriptor != nullptr && fDescriptor->dispatcher != nullptr)
2523         {
2524             fDescriptor->dispatcher(fHandle, NATIVE_PLUGIN_OPCODE_SAMPLE_RATE_CHANGED, 0, 0, nullptr, float(newSampleRate));
2525
2526             if (fHandle2 != nullptr)
2527                 fDescriptor->dispatcher(fHandle2, NATIVE_PLUGIN_OPCODE_SAMPLE_RATE_CHANGED, 0, 0, nullptr, float(newSampleRate));
2528         }
2529     }
2530
2531     void offlineModeChanged(const bool isOffline) override
2532     {
2533         if (fIsOffline == isOffline)
2534             return;
2535
2536         fIsOffline = isOffline;
2537
2538         if (fDescriptor != nullptr && fDescriptor->dispatcher != nullptr)
2539         {
2540             fDescriptor->dispatcher(fHandle, NATIVE_PLUGIN_OPCODE_OFFLINE_CHANGED, 0, isOffline ? 1 : 0, nullptr, 0.0f);
2541
2542             if (fHandle2 != nullptr)
2543                 fDescriptor->dispatcher(fHandle2, NATIVE_PLUGIN_OPCODE_OFFLINE_CHANGED, 0, isOffline ? 1 : 0, nullptr, 0.0f);
2544         }
2545     }
2546
2547     // -------------------------------------------------------------------
2548     // Plugin buffers
2549
2550     void initBuffers() const noexcept override
2551     {
2552         CarlaPlugin::initBuffers();
2553
2554         fMidiIn.initBuffers(pData->event.portIn);
2555         fMidiOut.initBuffers();
2556     }
2557
2558     void clearBuffers() noexcept override
2559     {
2560         carla_debug("CarlaPluginNative::clearBuffers() - start");
2561
2562         if (fAudioAndCvInBuffers != nullptr)
2563         {
2564             for (uint32_t i=0; i < (pData->audioIn.count+pData->cvIn.count); ++i)
2565             {
2566                 if (fAudioAndCvInBuffers[i] != nullptr)
2567                 {
2568                     delete[] fAudioAndCvInBuffers[i];
2569                     fAudioAndCvInBuffers[i] = nullptr;
2570                 }
2571             }
2572
2573             delete[] fAudioAndCvInBuffers;
2574             fAudioAndCvInBuffers = nullptr;
2575         }
2576
2577         if (fAudioAndCvOutBuffers != nullptr)
2578         {
2579             for (uint32_t i=0; i < (pData->audioOut.count+pData->cvOut.count); ++i)
2580             {
2581                 if (fAudioAndCvOutBuffers[i] != nullptr)
2582                 {
2583                     delete[] fAudioAndCvOutBuffers[i];
2584                     fAudioAndCvOutBuffers[i] = nullptr;
2585                 }
2586             }
2587
2588             delete[] fAudioAndCvOutBuffers;
2589             fAudioAndCvOutBuffers = nullptr;
2590         }
2591
2592         if (fMidiIn.count > 1)
2593             pData->event.portIn = nullptr;
2594
2595         if (fMidiOut.count > 1)
2596             pData->event.portOut = nullptr;
2597
2598         fMidiIn.clear();
2599         fMidiOut.clear();
2600
2601         CarlaPlugin::clearBuffers();
2602
2603         carla_debug("CarlaPluginNative::clearBuffers() - end");
2604     }
2605
2606     // -------------------------------------------------------------------
2607     // Post-poned UI Stuff
2608
2609     void uiParameterChange(const uint32_t index, const float value) noexcept override
2610     {
2611         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);
2612         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);
2613         CARLA_SAFE_ASSERT_RETURN(index < pData->param.count,);
2614
2615         if (! fIsUiVisible)
2616             return;
2617
2618         if (fDescriptor->ui_set_parameter_value != nullptr)
2619             fDescriptor->ui_set_parameter_value(fHandle, index, value);
2620     }
2621
2622     void uiMidiProgramChange(const uint32_t index) noexcept override
2623     {
2624         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);
2625         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);
2626         CARLA_SAFE_ASSERT_RETURN(index < pData->midiprog.count,);
2627
2628         if (! fIsUiVisible)
2629             return;
2630         if (index >= pData->midiprog.count)
2631             return;
2632
2633         if (fDescriptor->ui_set_midi_program != nullptr)
2634             fDescriptor->ui_set_midi_program(fHandle, 0, pData->midiprog.data[index].bank, pData->midiprog.data[index].program);
2635     }
2636
2637     void uiNoteOn(const uint8_t channel, const uint8_t note, const uint8_t velo) noexcept override
2638     {
2639         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);
2640         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);
2641         CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);
2642         CARLA_SAFE_ASSERT_RETURN(note < MAX_MIDI_NOTE,);
2643         CARLA_SAFE_ASSERT_RETURN(velo > 0 && velo < MAX_MIDI_VALUE,);
2644
2645         if (! fIsUiVisible)
2646             return;
2647
2648         if (fDescriptor->dispatcher != nullptr)
2649         {
2650             uint8_t data[3] = {
2651                 uint8_t(MIDI_STATUS_NOTE_ON | (channel & MIDI_CHANNEL_BIT)),
2652                 note,
2653                 velo
2654             };
2655             fDescriptor->dispatcher(fHandle, NATIVE_PLUGIN_OPCODE_UI_MIDI_EVENT,
2656                                     3, 0,
2657                                     data,
2658                                     0.0f);
2659         }
2660     }
2661
2662     void uiNoteOff(const uint8_t channel, const uint8_t note) noexcept override
2663     {
2664         CARLA_SAFE_ASSERT_RETURN(fDescriptor != nullptr,);
2665         CARLA_SAFE_ASSERT_RETURN(fHandle != nullptr,);
2666         CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);
2667         CARLA_SAFE_ASSERT_RETURN(note < MAX_MIDI_NOTE,);
2668
2669         if (! fIsUiVisible)
2670             return;
2671         if (fDescriptor == nullptr || fHandle == nullptr)
2672             return;
2673
2674         if (fDescriptor->dispatcher != nullptr)
2675         {
2676             uint8_t data[3] = {
2677                 uint8_t(MIDI_STATUS_NOTE_OFF | (channel & MIDI_CHANNEL_BIT)),
2678                 note,
2679                 0
2680             };
2681             fDescriptor->dispatcher(fHandle, NATIVE_PLUGIN_OPCODE_UI_MIDI_EVENT,
2682                                     3, 0,
2683                                     data,
2684                                     0.0f);
2685         }
2686     }
2687
2688     // -------------------------------------------------------------------
2689
2690     const NativeInlineDisplayImageSurface* renderInlineDisplay(const uint32_t width, const uint32_t height) const
2691     {
2692         CARLA_SAFE_ASSERT_RETURN(fDescriptor->hints & NATIVE_PLUGIN_HAS_INLINE_DISPLAY, nullptr);
2693         CARLA_SAFE_ASSERT_RETURN(fDescriptor->render_inline_display, nullptr);
2694         CARLA_SAFE_ASSERT_RETURN(width > 0, nullptr);
2695         CARLA_SAFE_ASSERT_RETURN(height > 0, nullptr);
2696
2697         return fDescriptor->render_inline_display(fHandle, width, height);
2698     }
2699
2700     // -------------------------------------------------------------------
2701
2702 protected:
2703     const NativeTimeInfo* handleGetTimeInfo() const noexcept
2704     {
2705         CARLA_SAFE_ASSERT_RETURN(fIsProcessing, nullptr);
2706
2707         return &fTimeInfo;
2708     }
2709
2710     bool handleWriteMidiEvent(const NativeMidiEvent* const event)
2711     {
2712         CARLA_SAFE_ASSERT_RETURN(pData->enabled, false);
2713         CARLA_SAFE_ASSERT_RETURN(fIsProcessing, false);
2714         CARLA_SAFE_ASSERT_RETURN(fMidiOut.count > 0 || pData->event.portOut != nullptr, false);
2715         CARLA_SAFE_ASSERT_RETURN(event != nullptr, false);
2716         CARLA_SAFE_ASSERT_RETURN(event->data[0] != 0, false);
2717
2718         if (fMidiEventOutCount == kPluginMaxMidiEvents)
2719         {
2720             carla_stdout("CarlaPluginNative::handleWriteMidiEvent(%p) - buffer full", event);
2721             return false;
2722         }
2723
2724         std::memcpy(&fMidiOutEvents[fMidiEventOutCount++], event, sizeof(NativeMidiEvent));
2725         return true;
2726     }
2727
2728     void handleUiParameterChanged(const uint32_t index, const float value)
2729     {
2730         setParameterValue(index, value, false, true, true);
2731     }
2732
2733     void handleUiCustomDataChanged(const char* const key, const char* const value)
2734     {
2735         setCustomData(CUSTOM_DATA_TYPE_STRING, key, value, false);
2736     }
2737
2738     void handleUiClosed()
2739     {
2740         pData->engine->callback(true, true, ENGINE_CALLBACK_UI_STATE_CHANGED, pData->id, 0, 0, 0, 0.0f, nullptr);
2741         fIsUiVisible = false;
2742     }
2743
2744     const char* handleUiOpenFile(const bool isDir, const char* const title, const char* const filter)
2745     {
2746         return pData->engine->runFileCallback(FILE_CALLBACK_OPEN, isDir, title, filter);
2747     }
2748
2749     const char* handleUiSaveFile(const bool isDir, const char* const title, const char* const filter)
2750     {
2751         return pData->engine->runFileCallback(FILE_CALLBACK_SAVE, isDir, title, filter);
2752     }
2753
2754     intptr_t handleDispatcher(const NativeHostDispatcherOpcode opcode,
2755                               const int32_t index, const intptr_t value, void* const ptr, const float opt)
2756     {
2757 #ifdef DEBUG
2758         if (opcode != NATIVE_HOST_OPCODE_QUEUE_INLINE_DISPLAY && opcode != NATIVE_HOST_OPCODE_REQUEST_IDLE) {
2759             carla_debug("CarlaPluginNative::handleDispatcher(%i, %i, " P_INTPTR ", %p, %f)",
2760                         opcode, index, value, ptr, static_cast<double>(opt));
2761         }
2762 #endif
2763
2764         switch (opcode)
2765         {
2766         case NATIVE_HOST_OPCODE_NULL:
2767             break;
2768
2769         case NATIVE_HOST_OPCODE_UPDATE_PARAMETER:
2770             // TODO
2771             pData->engine->callback(true, true, ENGINE_CALLBACK_UPDATE, pData->id, -1, 0, 0, 0.0f, nullptr);
2772             break;
2773
2774         case NATIVE_HOST_OPCODE_UPDATE_MIDI_PROGRAM:
2775             // TODO
2776             pData->engine->callback(true, true, ENGINE_CALLBACK_UPDATE, pData->id, -1, 0, 0, 0.0f, nullptr);
2777             break;
2778
2779         case NATIVE_HOST_OPCODE_RELOAD_PARAMETERS:
2780             reloadParameters(nullptr, nullptr);
2781             pData->engine->callback(true, true, ENGINE_CALLBACK_RELOAD_PARAMETERS, pData->id, -1, 0, 0, 0.0f, nullptr);
2782             break;
2783
2784         case NATIVE_HOST_OPCODE_RELOAD_MIDI_PROGRAMS:
2785             reloadPrograms(false);
2786             pData->engine->callback(true, true, ENGINE_CALLBACK_RELOAD_PROGRAMS, pData->id, -1, 0, 0, 0.0f, nullptr);
2787             break;
2788
2789         case NATIVE_HOST_OPCODE_RELOAD_ALL:
2790             reload();
2791             pData->engine->callback(true, true, ENGINE_CALLBACK_RELOAD_ALL, pData->id, -1, 0, 0, 0.0f, nullptr);
2792             break;
2793
2794         case NATIVE_HOST_OPCODE_UI_UNAVAILABLE:
2795             pData->engine->callback(true, true, ENGINE_CALLBACK_UI_STATE_CHANGED, pData->id, -1, 0, 0, 0.0f, nullptr);
2796             fIsUiAvailable = false;
2797             break;
2798
2799         case NATIVE_HOST_OPCODE_HOST_IDLE:
2800             pData->engine->callback(true, false, ENGINE_CALLBACK_IDLE, 0, 0, 0, 0, 0.0f, nullptr);
2801             break;
2802
2803         case NATIVE_HOST_OPCODE_INTERNAL_PLUGIN:
2804             return 1;
2805
2806         case NATIVE_HOST_OPCODE_QUEUE_INLINE_DISPLAY:
2807             switch (pData->engine->getProccessMode())
2808             {
2809             case ENGINE_PROCESS_MODE_MULTIPLE_CLIENTS:
2810             case ENGINE_PROCESS_MODE_PATCHBAY:
2811                 fInlineDisplayNeedsRedraw = true;
2812                 break;
2813             default:
2814                 break;
2815             }
2816             break;
2817
2818         case NATIVE_HOST_OPCODE_UI_TOUCH_PARAMETER:
2819             CARLA_SAFE_ASSERT_RETURN(index >= 0, 0);
2820             pData->engine->touchPluginParameter(pData->id, static_cast<uint32_t>(index), value != 0);
2821             break;
2822
2823         case NATIVE_HOST_OPCODE_REQUEST_IDLE:
2824             fNeedsIdle = true;
2825             break;
2826
2827         case NATIVE_HOST_OPCODE_GET_FILE_PATH:
2828             CARLA_SAFE_ASSERT_RETURN(ptr != nullptr, 0);
2829             {
2830                 const EngineOptions& opts(pData->engine->getOptions());
2831                 const char* const filetype = (const char*)ptr;
2832                 const char* ret = nullptr;
2833
2834                 if (std::strcmp(filetype, "carla") == 0)
2835                 {
2836                     ret = pData->engine->getCurrentProjectFilename();
2837
2838                     if (fLastProjectFilename != ret)
2839                     {
2840                         fLastProjectFilename = ret;
2841
2842                         bool found;
2843                         const size_t r = fLastProjectFilename.rfind(CARLA_OS_SEP, &found);
2844                         if (found)
2845                         {
2846                             fLastProjectFolder = ret;
2847                             fLastProjectFolder[r] = '\0';
2848                         }
2849                         else
2850                         {
2851                             fLastProjectFolder.clear();
2852                         }
2853                     }
2854
2855                     ret = fLastProjectFolder.buffer();
2856                 }
2857
2858                 else if (std::strcmp(filetype, "audio") == 0)
2859                     ret = opts.pathAudio;
2860                 else if (std::strcmp(filetype, "midi") == 0)
2861                     ret = opts.pathMIDI;
2862
2863                 return static_cast<intptr_t>((uintptr_t)ret);
2864             }
2865             break;
2866
2867         case NATIVE_HOST_OPCODE_UI_RESIZE:
2868         case NATIVE_HOST_OPCODE_PREVIEW_BUFFER_DATA:
2869             // unused here
2870             break;
2871         }
2872
2873         return 0;
2874
2875         // unused for now
2876         (void)opt;
2877     }
2878
2879     // -------------------------------------------------------------------
2880
2881 public:
2882     void* getNativeHandle() const noexcept override
2883     {
2884         return fHandle;
2885     }
2886
2887     const void* getNativeDescriptor() const noexcept override
2888     {
2889         return fDescriptor;
2890     }
2891
2892     // -------------------------------------------------------------------
2893
2894     bool init(const CarlaPluginPtr plugin,
2895               const char* const name, const char* const label, const uint options)
2896     {
2897         CARLA_SAFE_ASSERT_RETURN(pData->engine != nullptr, false);
2898
2899         // ---------------------------------------------------------------
2900         // first checks
2901
2902         if (pData->client != nullptr)
2903         {
2904             pData->engine->setLastError("Plugin client is already registered");
2905             return false;
2906         }
2907
2908         if (label == nullptr || label[0] == '\0')
2909         {
2910             pData->engine->setLastError("null label");
2911             return false;
2912         }
2913
2914         // ---------------------------------------------------------------
2915         // get descriptor that matches label
2916
2917         sPluginInitializer.initIfNeeded();
2918
2919         for (LinkedList<const NativePluginDescriptor*>::Itenerator it = gPluginDescriptors.begin2(); it.valid(); it.next())
2920         {
2921             fDescriptor = it.getValue(nullptr);
2922             CARLA_SAFE_ASSERT_BREAK(fDescriptor != nullptr);
2923
2924             carla_debug("Check vs \"%s\"", fDescriptor->label);
2925
2926             if (fDescriptor->label != nullptr && std::strcmp(fDescriptor->label, label) == 0)
2927                 break;
2928
2929             fDescriptor = nullptr;
2930         }
2931
2932         if (fDescriptor == nullptr)
2933         {
2934             pData->engine->setLastError("Invalid internal plugin");
2935             return false;
2936         }
2937
2938         // ---------------------------------------------------------------
2939         // set icon
2940
2941         /**/ if (std::strcmp(fDescriptor->label, "audiofile") == 0)
2942             pData->iconName = carla_strdup_safe("file");
2943         else if (std::strcmp(fDescriptor->label, "midifile") == 0)
2944             pData->iconName = carla_strdup_safe("file");
2945
2946         else if (std::strcmp(fDescriptor->label, "3bandeq") == 0)
2947             pData->iconName = carla_strdup_safe("distrho");
2948         else if (std::strcmp(fDescriptor->label, "3bandsplitter") == 0)
2949             pData->iconName = carla_strdup_safe("distrho");
2950         else if (std::strcmp(fDescriptor->label, "kars") == 0)
2951             pData->iconName = carla_strdup_safe("distrho");
2952         else if (std::strcmp(fDescriptor->label, "nekobi") == 0)
2953             pData->iconName = carla_strdup_safe("distrho");
2954         else if (std::strcmp(fDescriptor->label, "pingpongpan") == 0)
2955             pData->iconName = carla_strdup_safe("distrho");
2956
2957         // ---------------------------------------------------------------
2958         // set info
2959
2960         if (name != nullptr && name[0] != '\0')
2961             pData->name = pData->engine->getUniquePluginName(name);
2962         else if (fDescriptor->name != nullptr && fDescriptor->name[0] != '\0')
2963             pData->name = pData->engine->getUniquePluginName(fDescriptor->name);
2964         else
2965             pData->name = pData->engine->getUniquePluginName(label);
2966
2967         {
2968             CARLA_ASSERT(fHost.uiName == nullptr);
2969
2970             CarlaString uiName;
2971
2972             if (pData->uiTitle.isNotEmpty())
2973             {
2974                 uiName = pData->uiTitle;
2975             }
2976             else
2977             {
2978                 uiName  = pData->name;
2979                 uiName += " (GUI)";
2980             }
2981
2982             fHost.uiName = uiName.releaseBufferPointer();
2983         }
2984
2985         // ---------------------------------------------------------------
2986         // register client
2987
2988         pData->client = pData->engine->addClient(plugin);
2989
2990         if (pData->client == nullptr || ! pData->client->isOk())
2991         {
2992             pData->engine->setLastError("Failed to register plugin client");
2993             return false;
2994         }
2995
2996         // ---------------------------------------------------------------
2997         // initialize plugin
2998
2999         fHandle = fDescriptor->instantiate(&fHost);
3000
3001         if (fHandle == nullptr)
3002         {
3003             pData->engine->setLastError("Plugin failed to initialize");
3004             return false;
3005         }
3006
3007         // ---------------------------------------------------------------
3008         // set options
3009
3010         bool hasMidiProgs = false;
3011
3012         if (fDescriptor->get_midi_program_count != nullptr)
3013         {
3014             try {
3015                 hasMidiProgs = fDescriptor->get_midi_program_count(fHandle) > 0;
3016             } catch (...) {}
3017         }
3018
3019         pData->options = 0x0;
3020
3021         if (fDescriptor->hints & NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS)
3022             pData->options |= PLUGIN_OPTION_FIXED_BUFFERS;
3023          else if (options & PLUGIN_OPTION_FIXED_BUFFERS)
3024             pData->options |= PLUGIN_OPTION_FIXED_BUFFERS;
3025
3026         if (pData->engine->getOptions().forceStereo)
3027             pData->options |= PLUGIN_OPTION_FORCE_STEREO;
3028         else if (options & PLUGIN_OPTION_FORCE_STEREO)
3029             pData->options |= PLUGIN_OPTION_FORCE_STEREO;
3030
3031         if (fDescriptor->supports & NATIVE_PLUGIN_SUPPORTS_CONTROL_CHANGES)
3032             if (isPluginOptionEnabled(options, PLUGIN_OPTION_SEND_CONTROL_CHANGES))
3033                 pData->options |= PLUGIN_OPTION_SEND_CONTROL_CHANGES;
3034
3035         if (fDescriptor->supports & NATIVE_PLUGIN_SUPPORTS_CHANNEL_PRESSURE)
3036             if (isPluginOptionEnabled(options, PLUGIN_OPTION_SEND_CHANNEL_PRESSURE))
3037                 pData->options |= PLUGIN_OPTION_SEND_CHANNEL_PRESSURE;
3038
3039         if (fDescriptor->supports & NATIVE_PLUGIN_SUPPORTS_NOTE_AFTERTOUCH)
3040             if (isPluginOptionEnabled(options, PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH))
3041                 pData->options |= PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH;
3042
3043         if (fDescriptor->supports & NATIVE_PLUGIN_SUPPORTS_PITCHBEND)
3044             if (isPluginOptionEnabled(options, PLUGIN_OPTION_SEND_PITCHBEND))
3045                 pData->options |= PLUGIN_OPTION_SEND_PITCHBEND;
3046
3047         if (fDescriptor->supports & NATIVE_PLUGIN_SUPPORTS_ALL_SOUND_OFF)
3048             if (isPluginOptionEnabled(options, PLUGIN_OPTION_SEND_ALL_SOUND_OFF))
3049                 pData->options |= PLUGIN_OPTION_SEND_ALL_SOUND_OFF;
3050
3051         if (fDescriptor->midiIns > 0)
3052             if (isPluginOptionInverseEnabled(options, PLUGIN_OPTION_SKIP_SENDING_NOTES))
3053                 pData->options |= PLUGIN_OPTION_SKIP_SENDING_NOTES;
3054
3055         if (fDescriptor->supports & NATIVE_PLUGIN_SUPPORTS_PROGRAM_CHANGES)
3056         {
3057             if (isPluginOptionEnabled(options, PLUGIN_OPTION_SEND_PROGRAM_CHANGES))
3058                 pData->options |= PLUGIN_OPTION_SEND_PROGRAM_CHANGES;
3059
3060             // makes no sense for a plugin to set program changes supported, but it has no midi programs
3061             CARLA_SAFE_ASSERT(! hasMidiProgs);
3062         }
3063         else if (hasMidiProgs)
3064         {
3065             if (isPluginOptionEnabled(options, PLUGIN_OPTION_MAP_PROGRAM_CHANGES))
3066                 pData->options |= PLUGIN_OPTION_MAP_PROGRAM_CHANGES;
3067         }
3068
3069         return true;
3070     }
3071
3072
3073 private:
3074     NativePluginHandle   fHandle;
3075     NativePluginHandle   fHandle2;
3076     NativeHostDescriptor fHost;
3077     const NativePluginDescriptor* fDescriptor;
3078
3079     bool fIsProcessing;
3080     bool fIsOffline;
3081     bool fIsUiAvailable;
3082     bool fIsUiVisible;
3083     volatile bool fNeedsIdle;
3084
3085     bool fInlineDisplayNeedsRedraw;
3086     int64_t fInlineDisplayLastRedrawTime;
3087
3088     CarlaString fLastProjectFilename;
3089     CarlaString fLastProjectFolder;
3090
3091     float**         fAudioAndCvInBuffers;
3092     float**         fAudioAndCvOutBuffers;
3093     uint32_t        fMidiEventInCount;
3094     uint32_t        fMidiEventOutCount;
3095     NativeMidiEvent fMidiInEvents[kPluginMaxMidiEvents];
3096     NativeMidiEvent fMidiOutEvents[kPluginMaxMidiEvents];
3097
3098     int32_t  fCurMidiProgs[MAX_MIDI_CHANNELS];
3099     uint32_t fCurBufferSize;
3100     double   fCurSampleRate;
3101
3102     NativePluginMidiInData  fMidiIn;
3103     NativePluginMidiOutData fMidiOut;
3104
3105     NativeTimeInfo fTimeInfo;
3106
3107     // -------------------------------------------------------------------
3108
3109     #define handlePtr ((CarlaPluginNative*)handle)
3110
3111     static uint32_t carla_host_get_buffer_size(NativeHostHandle handle) noexcept
3112     {
3113         return handlePtr->fCurBufferSize;
3114     }
3115
3116     static double carla_host_get_sample_rate(NativeHostHandle handle) noexcept
3117     {
3118         return handlePtr->fCurSampleRate;
3119     }
3120
3121     static bool carla_host_is_offline(NativeHostHandle handle) noexcept
3122     {
3123         return handlePtr->fIsOffline;
3124     }
3125
3126     static const NativeTimeInfo* carla_host_get_time_info(NativeHostHandle handle) noexcept
3127     {
3128         return handlePtr->handleGetTimeInfo();
3129     }
3130
3131     static bool carla_host_write_midi_event(NativeHostHandle handle, const NativeMidiEvent* event)
3132     {
3133         return handlePtr->handleWriteMidiEvent(event);
3134     }
3135
3136     static void carla_host_ui_parameter_changed(NativeHostHandle handle, uint32_t index, float value)
3137     {
3138         handlePtr->handleUiParameterChanged(index, value);
3139     }
3140
3141     static void carla_host_ui_custom_data_changed(NativeHostHandle handle, const char* key, const char* value)
3142     {
3143         handlePtr->handleUiCustomDataChanged(key, value);
3144     }
3145
3146     static void carla_host_ui_closed(NativeHostHandle handle)
3147     {
3148         handlePtr->handleUiClosed();
3149     }
3150
3151     static const char* carla_host_ui_open_file(NativeHostHandle handle, bool isDir, const char* title, const char* filter)
3152     {
3153         return handlePtr->handleUiOpenFile(isDir, title, filter);
3154     }
3155
3156     static const char* carla_host_ui_save_file(NativeHostHandle handle, bool isDir, const char* title, const char* filter)
3157     {
3158         return handlePtr->handleUiSaveFile(isDir, title, filter);
3159     }
3160
3161     static intptr_t carla_host_dispatcher(NativeHostHandle handle, NativeHostDispatcherOpcode opcode, int32_t index, intptr_t value, void* ptr, float opt)
3162     {
3163         return handlePtr->handleDispatcher(opcode, index, value, ptr, opt);
3164     }
3165
3166     #undef handlePtr
3167
3168     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaPluginNative)
3169 };
3170
3171 // -----------------------------------------------------------------------
3172
3173 CarlaPluginPtr CarlaPlugin::newNative(const Initializer& init)
3174 {
3175     carla_debug("CarlaPlugin::newNative({%p, \"%s\", \"%s\", \"%s\", " P_INT64 "})",
3176                 init.engine, init.filename, init.name, init.label, init.uniqueId);
3177
3178     std::shared_ptr<CarlaPluginNative> plugin(new CarlaPluginNative(init.engine, init.id));
3179
3180     if (! plugin->init(plugin, init.name, init.label, init.options))
3181         return nullptr;
3182
3183     return plugin;
3184 }
3185
3186 // used in CarlaStandalone.cpp
3187 const void* carla_render_inline_display_internal(const CarlaPluginPtr& plugin, uint32_t width, uint32_t height);
3188
3189 const void* carla_render_inline_display_internal(const CarlaPluginPtr& plugin, uint32_t  width, uint32_t height)
3190 {
3191     const std::shared_ptr<CarlaPluginNative>& nativePlugin((const std::shared_ptr<CarlaPluginNative>&)plugin);
3192
3193     return nativePlugin->renderInlineDisplay(width, height);
3194 }
3195
3196 // -----------------------------------------------------------------------
3197
3198 CARLA_BACKEND_END_NAMESPACE