falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 42 Activity
Audio plugin host https://kx.studio/carla
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1238 Commits
16 Branches
222MB
Tree: f0dcea3da9
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'f0dcea3da9'
${ noResults }
Carla/source/backend/plugin/VstPlugin.cpp

2545 lines
83KB
Raw Blame History 

  1. /*

  2.  * Carla VST Plugin

  3.  * Copyright (C) 2011-2014 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. #ifdef WANT_VST

  22. 

  23. #include "CarlaVstUtils.hpp"

  24. #include "CarlaMathUtils.hpp"

  25. 

  26. CARLA_BACKEND_START_NAMESPACE

  27. 

  28. #if 0

  29. }

  30. #endif

  31. 

  32. /*!

  33.  * @defgroup PluginHints Plugin Hints

  34.  * @{

  35.  */

  36. const unsigned int PLUGIN_CAN_PROCESS_REPLACING = 0x1000; //!< VST Plugin cas use processReplacing()

  37. const unsigned int PLUGIN_HAS_COCKOS_EXTENSIONS = 0x2000; //!< VST Plugin has Cockos extensions

  38. const unsigned int PLUGIN_USES_OLD_VSTSDK       = 0x4000; //!< VST Plugin uses an old VST SDK

  39. const unsigned int PLUGIN_WANTS_MIDI_INPUT      = 0x8000; //!< VST Plugin wants MIDI input

  40. /**@}*/

  41. 

  42. class VstPlugin : public CarlaPlugin/*,

  43.                   public CarlaPluginGui::Callback*/

  44. {

  45. public:

  46.     VstPlugin(CarlaEngine* const engine, const unsigned int id)

  47.         : CarlaPlugin(engine, id),

  48.           fUnique1(1),

  49.           fEffect(nullptr),

  50.           fLastChunk(nullptr),

  51.           fMidiEventCount(0),

  52.           fIsProcessing(false),

  53.           fNeedIdle(false),

  54.           fUnique2(2)

  55.     {

  56.         carla_debug("VstPlugin::VstPlugin(%p, %i)", engine, id);

  57. 

  58.         carla_zeroStruct<VstMidiEvent>(fMidiEvents, kPluginMaxMidiEvents*2);

  59.         carla_zeroStruct<VstTimeInfo_R>(fTimeInfo);

  60. 

  61.         for (unsigned short i=0; i < kPluginMaxMidiEvents*2; ++i)

  62.             fEvents.data[i] = (VstEvent*)&fMidiEvents[i];

  63. 

  64.         pData->osc.thread.setMode(CarlaPluginThread::PLUGIN_THREAD_VST_GUI);

  65. 

  66.         // make plugin valid

  67.         srand(id);

  68.         fUnique1 = fUnique2 = rand();

  69.     }

  70. 

  71.     ~VstPlugin() override

  72.     {

  73.         carla_debug("VstPlugin::~VstPlugin()");

  74. 

  75.         // close UI

  76.         if (pData->hints & PLUGIN_HAS_CUSTOM_UI)

  77.         {

  78.             showCustomUI(false);

  79. 

  80.             if (fGui.isOsc)

  81.             {

  82.                 pData->osc.thread.stop(pData->engine->getOptions().uiBridgesTimeout);

  83.             }

  84.         }

  85. 

  86.         pData->singleMutex.lock();

  87.         pData->masterMutex.lock();

  88. 

  89.         if (pData->client != nullptr && pData->client->isActive())

  90.             pData->client->deactivate();

  91. 

  92.         CARLA_ASSERT(! fIsProcessing);

  93. 

  94.         if (pData->active)

  95.         {

  96.             deactivate();

  97.             pData->active = false;

  98.         }

  99. 

  100.         if (fEffect != nullptr)

  101.         {

  102.             dispatcher(effClose, 0, 0, nullptr, 0.0f);

  103.             fEffect = nullptr;

  104.         }

  105. 

  106.         // make plugin invalid

  107.         fUnique2 += 1;

  108. 

  109.         if (fLastChunk != nullptr)

  110.         {

  111.             std::free(fLastChunk);

  112.             fLastChunk = nullptr;

  113.         }

  114. 

  115.         clearBuffers();

  116.     }

  117. 

  118.     // -------------------------------------------------------------------

  119.     // Information (base)

  120. 

  121.     PluginType getType() const noexcept override

  122.     {

  123.         return PLUGIN_VST;

  124.     }

  125. 

  126.     PluginCategory getCategory() const override

  127.     {

  128.         CARLA_ASSERT(fEffect != nullptr);

  129. 

  130.         const intptr_t category(dispatcher(effGetPlugCategory, 0, 0, nullptr, 0.0f));

  131. 

  132.         switch (category)

  133.         {

  134.         case kPlugCategSynth:

  135.             return PLUGIN_CATEGORY_SYNTH;

  136.         case kPlugCategAnalysis:

  137.             return PLUGIN_CATEGORY_UTILITY;

  138.         case kPlugCategMastering:

  139.             return PLUGIN_CATEGORY_DYNAMICS;

  140.         case kPlugCategRoomFx:

  141.             return PLUGIN_CATEGORY_DELAY;

  142.         case kPlugCategRestoration:

  143.             return PLUGIN_CATEGORY_UTILITY;

  144.         case kPlugCategGenerator:

  145.             return PLUGIN_CATEGORY_SYNTH;

  146.         }

  147. 

  148.         if (fEffect->flags & effFlagsIsSynth)

  149.             return PLUGIN_CATEGORY_SYNTH;

  150. 

  151.         return getPluginCategoryFromName(pData->name);

  152.     }

  153. 

  154.     long getUniqueId() const override

  155.     {

  156.         CARLA_ASSERT(fEffect != nullptr);

  157. 

  158.         return fEffect->uniqueID;

  159.     }

  160. 

  161.     // -------------------------------------------------------------------

  162.     // Information (count)

  163. 

  164.     // nothing

  165. 

  166.     // -------------------------------------------------------------------

  167.     // Information (current data)

  168. 

  169.     int32_t getChunkData(void** const dataPtr) const override

  170.     {

  171.         CARLA_ASSERT(pData->options & PLUGIN_OPTION_USE_CHUNKS);

  172.         CARLA_ASSERT(fEffect != nullptr);

  173.         CARLA_ASSERT(dataPtr != nullptr);

  174. 

  175.         return dispatcher(effGetChunk, 0 /* bank */, 0, dataPtr, 0.0f);

  176.     }

  177. 

  178.     // -------------------------------------------------------------------

  179.     // Information (per-plugin data)

  180. 

  181.     unsigned int getOptionsAvailable() const override

  182.     {

  183.         CARLA_ASSERT(fEffect != nullptr);

  184. 

  185.         if (fEffect == nullptr)

  186.             return 0x0;

  187. 

  188.         unsigned int options = 0x0;

  189. 

  190.         options |= PLUGIN_OPTION_MAP_PROGRAM_CHANGES;

  191. 

  192.         if (getMidiInCount() == 0)

  193.             options |= PLUGIN_OPTION_FIXED_BUFFERS;

  194. 

  195.         if (fEffect->flags & effFlagsProgramChunks)

  196.             options |= PLUGIN_OPTION_USE_CHUNKS;

  197. 

  198.         if (vstPluginCanDo(fEffect, "receiveVstEvents") || vstPluginCanDo(fEffect, "receiveVstMidiEvent") || (fEffect->flags & effFlagsIsSynth) > 0 || (pData->hints & PLUGIN_WANTS_MIDI_INPUT))

  199.         {

  200.             options |= PLUGIN_OPTION_SEND_CONTROL_CHANGES;

  201.             options |= PLUGIN_OPTION_SEND_CHANNEL_PRESSURE;

  202.             options |= PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH;

  203.             options |= PLUGIN_OPTION_SEND_PITCHBEND;

  204.             options |= PLUGIN_OPTION_SEND_ALL_SOUND_OFF;

  205.         }

  206. 

  207.         return options;

  208.     }

  209. 

  210.     float getParameterValue(const uint32_t parameterId) const override

  211.     {

  212.         CARLA_ASSERT(fEffect != nullptr);

  213.         CARLA_ASSERT(parameterId < pData->param.count);

  214. 

  215.         return fEffect->getParameter(fEffect, parameterId);

  216.     }

  217. 

  218.     void getLabel(char* const strBuf) const override

  219.     {

  220.         CARLA_ASSERT(fEffect != nullptr);

  221. 

  222.         strBuf[0] = '\0';

  223.         dispatcher(effGetProductString, 0, 0, strBuf, 0.0f);

  224.     }

  225. 

  226.     void getMaker(char* const strBuf) const override

  227.     {

  228.         CARLA_ASSERT(fEffect != nullptr);

  229. 

  230.         strBuf[0] = '\0';

  231.         dispatcher(effGetVendorString, 0, 0, strBuf, 0.0f);

  232.     }

  233. 

  234.     void getCopyright(char* const strBuf) const override

  235.     {

  236.         CARLA_ASSERT(fEffect != nullptr);

  237. 

  238.         strBuf[0] = '\0';

  239.         dispatcher(effGetVendorString, 0, 0, strBuf, 0.0f);

  240.     }

  241. 

  242.     void getRealName(char* const strBuf) const override

  243.     {

  244.         CARLA_ASSERT(fEffect != nullptr);

  245. 

  246.         strBuf[0] = '\0';

  247.         dispatcher(effGetEffectName, 0, 0, strBuf, 0.0f);

  248.     }

  249. 

  250.     void getParameterName(const uint32_t parameterId, char* const strBuf) const override

  251.     {

  252.         CARLA_ASSERT(fEffect != nullptr);

  253.         CARLA_ASSERT(parameterId < pData->param.count);

  254. 

  255.         strBuf[0] = '\0';

  256.         dispatcher(effGetParamName, parameterId, 0, strBuf, 0.0f);

  257.     }

  258. 

  259.     void getParameterText(const uint32_t parameterId, char* const strBuf) const override

  260.     {

  261.         CARLA_ASSERT(fEffect != nullptr);

  262.         CARLA_ASSERT(parameterId < pData->param.count);

  263. 

  264.         strBuf[0] = '\0';

  265.         dispatcher(effGetParamDisplay, parameterId, 0, strBuf, 0.0f);

  266. 

  267.         if (strBuf[0] == '\0')

  268.             std::snprintf(strBuf, STR_MAX, "%f", getParameterValue(parameterId));

  269.     }

  270. 

  271.     void getParameterUnit(const uint32_t parameterId, char* const strBuf) const override

  272.     {

  273.         CARLA_ASSERT(fEffect != nullptr);

  274.         CARLA_ASSERT(parameterId < pData->param.count);

  275. 

  276.         strBuf[0] = '\0';

  277.         dispatcher(effGetParamLabel, parameterId, 0, strBuf, 0.0f);

  278.     }

  279. 

  280.     // -------------------------------------------------------------------

  281.     // Set data (state)

  282. 

  283.     // nothing

  284. 

  285.     // -------------------------------------------------------------------

  286.     // Set data (internal stuff)

  287. 

  288.     void setName(const char* const newName) override

  289.     {

  290.         CarlaPlugin::setName(newName);

  291. 

  292.         //if (pData->gui != nullptr)

  293.         //    pData->gui->setWindowTitle(QString("%1 (GUI)").arg((const char*)pData->name));

  294.     }

  295. 

  296.     // -------------------------------------------------------------------

  297.     // Set data (plugin-specific stuff)

  298. 

  299.     void setParameterValue(const uint32_t parameterId, const float value, const bool sendGui, const bool sendOsc, const bool sendCallback) override

  300.     {

  301.         CARLA_ASSERT(fEffect != nullptr);

  302.         CARLA_ASSERT(parameterId < pData->param.count);

  303. 

  304.         const float fixedValue(pData->param.getFixedValue(parameterId, value));

  305. 

  306.         fEffect->setParameter(fEffect, parameterId, fixedValue);

  307. 

  308.         CarlaPlugin::setParameterValue(parameterId, fixedValue, sendGui, sendOsc, sendCallback);

  309.     }

  310. 

  311.     void setChunkData(const char* const stringData) override

  312.     {

  313.         CARLA_ASSERT(pData->options & PLUGIN_OPTION_USE_CHUNKS);

  314.         CARLA_ASSERT(fEffect != nullptr);

  315.         CARLA_ASSERT(stringData != nullptr);

  316. 

  317.         if (fLastChunk != nullptr)

  318.         {

  319.             std::free(fLastChunk);

  320.             fLastChunk = nullptr;

  321.         }

  322. 

  323. //         QByteArray chunk(QByteArray::fromBase64(stringData));

  324. //

  325. //         CARLA_ASSERT(chunk.size() > 0);

  326. //

  327. //         if (chunk.size() > 0)

  328. //         {

  329. //             fLastChunk = std::malloc(chunk.size());

  330. //             std::memcpy(fLastChunk, chunk.constData(), chunk.size());

  331. //

  332. //             {

  333. //                 const ScopedSingleProcessLocker spl(this, true);

  334. //                 dispatcher(effSetChunk, 0 /* bank */, chunk.size(), fLastChunk, 0.0f);

  335. //             }

  336. //

  337. //             // simulate an updateDisplay callback

  338. //             handleAudioMasterCallback(audioMasterUpdateDisplay, 0, 0, nullptr, 0.0f);

  339. //         }

  340.     }

  341. 

  342.     void setProgram(const int32_t index, const bool sendGui, const bool sendOsc, const bool sendCallback) override

  343.     {

  344.         CARLA_SAFE_ASSERT_RETURN(fEffect != nullptr,);

  345.         CARLA_SAFE_ASSERT_RETURN(index >= -1 && index < static_cast<int32_t>(pData->prog.count),);

  346. 

  347.         if (index >= 0)

  348.         {

  349.             const ScopedSingleProcessLocker spl(this, (sendGui || sendOsc || sendCallback));

  350. 

  351.             dispatcher(effBeginSetProgram, 0, 0, nullptr, 0.0f);

  352.             dispatcher(effSetProgram, 0, index, nullptr, 0.0f);

  353.             dispatcher(effEndSetProgram, 0, 0, nullptr, 0.0f);

  354.         }

  355. 

  356.         CarlaPlugin::setProgram(index, sendGui, sendOsc, sendCallback);

  357.     }

  358. 

  359.     // -------------------------------------------------------------------

  360.     // Set ui stuff

  361. 

  362.     void showCustomUI(const bool yesNo) override

  363.     {

  364.         if (fGui.isVisible == yesNo)

  365.             return;

  366. 

  367.         if (fGui.isOsc)

  368.         {

  369.             if (yesNo)

  370.             {

  371.                 pData->osc.thread.start();

  372.             }

  373.             else

  374.             {

  375.                 if (pData->osc.data.target != nullptr)

  376.                 {

  377.                     osc_send_hide(pData->osc.data);

  378.                     osc_send_quit(pData->osc.data);

  379.                     pData->osc.data.free();

  380.                 }

  381. 

  382.                 pData->osc.thread.stop(pData->engine->getOptions().uiBridgesTimeout);

  383.             }

  384.         }

  385.         else

  386.         {

  387. #if 0

  388.             if (yesNo)

  389.             {

  390.                 CARLA_ASSERT(pData->gui == nullptr);

  391. 

  392.                 if (pData->gui == nullptr)

  393.                 {

  394.                     CarlaPluginGui::Options guiOptions;

  395.                     guiOptions.parented  = true;

  396.                     guiOptions.resizable = false;

  397. 

  398.                     pData->gui = new CarlaPluginGui(pData->engine, this, guiOptions, pData->guiGeometry);

  399.                 }

  400. 

  401.                 int32_t value = 0;

  402. #ifdef Q_WS_X11

  403.                 //value = (intptr_t)QX11Info::display();

  404. #endif

  405.                 void* const ptr = pData->gui->getContainerWinId();

  406. 

  407.                 if (dispatcher(effEditOpen, 0, value, ptr, 0.0f) != 0)

  408.                 {

  409.                     ERect* vstRect = nullptr;

  410. 

  411.                     dispatcher(effEditGetRect, 0, 0, &vstRect, 0.0f);

  412. 

  413.                     if (vstRect != nullptr)

  414.                     {

  415.                         const int16_t width(vstRect->right  - vstRect->left);

  416.                         const int16_t height(vstRect->bottom - vstRect->top);

  417. 

  418.                         CARLA_SAFE_ASSERT_INT2(width > 1 && height > 1, width, height);

  419. 

  420.                         if (width > 1 && height > 1)

  421.                             pData->gui->setSize(width, height);

  422.                         else if (fGui.lastWidth > 1 && fGui.lastHeight > 1)

  423.                             pData->gui->setSize(fGui.lastWidth, fGui.lastHeight);

  424.                     }

  425. 

  426.                     pData->gui->setWindowTitle(QString("%1 (GUI)").arg((const char*)pData->name));

  427.                     pData->gui->show();

  428.                 }

  429.                 else

  430.                 {

  431.                     if (pData->gui != nullptr)

  432.                     {

  433.                         pData->guiGeometry = pData->gui->saveGeometry();

  434.                         pData->gui->close();

  435.                         delete pData->gui;

  436.                         pData->gui = nullptr;

  437.                     }

  438. 

  439.                     pData->engine->callback(CALLBACK_ERROR, pData->id, 0, 0, 0.0f, "Plugin refused to open its own UI");

  440.                     pData->engine->callback(CALLBACK_SHOW_GUI, pData->id, -1, 0, 0.0f, nullptr);

  441.                     return;

  442.                 }

  443.             }

  444.             else

  445.             {

  446.                 CARLA_ASSERT(pData->gui != nullptr);

  447. 

  448.                 dispatcher(effEditClose, 0, 0, nullptr, 0.0f);

  449. 

  450.                 if (pData->gui != nullptr)

  451.                 {

  452.                     fGui.lastWidth  = pData->gui->width();

  453.                     fGui.lastHeight = pData->gui->height();

  454. 

  455.                     pData->guiGeometry = pData->gui->saveGeometry();

  456.                     pData->gui->close();

  457.                     delete pData->gui;

  458.                     pData->gui = nullptr;

  459.                 }

  460.             }

  461. #endif

  462.         }

  463. 

  464.         fGui.isVisible = yesNo;

  465.     }

  466. 

  467.     void idle() override

  468.     {

  469. #ifdef VESTIGE_HEADER

  470.         if (fEffect != nullptr /*&& effect->ptr1*/)

  471. #else

  472.         if (fEffect != nullptr /*&& effect->resvd1*/)

  473. #endif

  474.         {

  475.             if (fNeedIdle)

  476.                 dispatcher(effIdle, 0, 0, nullptr, 0.0f);

  477. 

  478.             if (fGui.isVisible && ! fGui.isOsc)

  479.             {

  480.                 dispatcher(effEditIdle, 0, 0, nullptr, 0.0f);

  481.                 //pData->gui->idle();

  482.             }

  483.         }

  484. 

  485.         CarlaPlugin::idle();

  486.     }

  487. 

  488.     // -------------------------------------------------------------------

  489.     // Plugin state

  490. 

  491.     void reload() override

  492.     {

  493.         CARLA_SAFE_ASSERT_RETURN(pData->engine != nullptr,);

  494.         CARLA_SAFE_ASSERT_RETURN(fEffect != nullptr,);

  495.         carla_debug("VstPlugin::reload() - start");

  496. 

  497.         const EngineProcessMode processMode(pData->engine->getProccessMode());

  498. 

  499.         // Safely disable plugin for reload

  500.         const ScopedDisabler sd(this);

  501. 

  502.         if (pData->active)

  503.             deactivate();

  504. 

  505.         clearBuffers();

  506. 

  507.         uint32_t aIns, aOuts, mIns, mOuts, params, j;

  508. 

  509.         bool needsCtrlIn, needsCtrlOut;

  510.         needsCtrlIn = needsCtrlOut = false;

  511. 

  512.         aIns   = fEffect->numInputs;

  513.         aOuts  = fEffect->numOutputs;

  514.         params = fEffect->numParams;

  515. 

  516.         if (vstPluginCanDo(fEffect, "receiveVstEvents") || vstPluginCanDo(fEffect, "receiveVstMidiEvent") || (fEffect->flags & effFlagsIsSynth) > 0 || (pData->hints & PLUGIN_WANTS_MIDI_INPUT))

  517.         {

  518.             mIns = 1;

  519.             needsCtrlIn = true;

  520.         }

  521.         else

  522.             mIns = 0;

  523. 

  524.         if (vstPluginCanDo(fEffect, "sendVstEvents") || vstPluginCanDo(fEffect, "sendVstMidiEvent"))

  525.         {

  526.             mOuts = 1;

  527.             needsCtrlOut = true;

  528.         }

  529.         else

  530.             mOuts = 0;

  531. 

  532.         if (aIns > 0)

  533.         {

  534.             pData->audioIn.createNew(aIns);

  535.         }

  536. 

  537.         if (aOuts > 0)

  538.         {

  539.             pData->audioOut.createNew(aOuts);

  540.             needsCtrlIn = true;

  541.         }

  542. 

  543.         if (params > 0)

  544.         {

  545.             pData->param.createNew(params, true);

  546.             needsCtrlIn = true;

  547.         }

  548. 

  549.         const uint portNameSize(pData->engine->getMaxPortNameSize());

  550.         CarlaString portName;

  551. 

  552.         // Audio Ins

  553.         for (j=0; j < aIns; ++j)

  554.         {

  555.             portName.clear();

  556. 

  557.             if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  558.             {

  559.                 portName  = pData->name;

  560.                 portName += ":";

  561.             }

  562. 

  563.             if (aIns > 1)

  564.             {

  565.                 portName += "input_";

  566.                 portName += CarlaString(j+1);

  567.             }

  568.             else

  569.                 portName += "input";

  570. 

  571.             portName.truncate(portNameSize);

  572. 

  573.             pData->audioIn.ports[j].port   = (CarlaEngineAudioPort*)pData->client->addPort(kEnginePortTypeAudio, portName, true);

  574.             pData->audioIn.ports[j].rindex = j;

  575.         }

  576. 

  577.         // Audio Outs

  578.         for (j=0; j < aOuts; ++j)

  579.         {

  580.             portName.clear();

  581. 

  582.             if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  583.             {

  584.                 portName  = pData->name;

  585.                 portName += ":";

  586.             }

  587. 

  588.             if (aOuts > 1)

  589.             {

  590.                 portName += "output_";

  591.                 portName += CarlaString(j+1);

  592.             }

  593.             else

  594.                 portName += "output";

  595. 

  596.             portName.truncate(portNameSize);

  597. 

  598.             pData->audioOut.ports[j].port   = (CarlaEngineAudioPort*)pData->client->addPort(kEnginePortTypeAudio, portName, false);

  599.             pData->audioOut.ports[j].rindex = j;

  600.         }

  601. 

  602.         for (j=0; j < params; ++j)

  603.         {

  604.             pData->param.data[j].index  = j;

  605.             pData->param.data[j].rindex = j;

  606.             pData->param.data[j].hints  = PARAMETER_IS_INPUT;

  607.             pData->param.data[j].midiChannel = 0;

  608.             pData->param.data[j].midiCC = -1;

  609. 

  610.             float min, max, def, step, stepSmall, stepLarge;

  611. 

  612.             VstParameterProperties prop;

  613.             carla_zeroStruct<VstParameterProperties>(prop);

  614. 

  615.             if (pData->hints & PLUGIN_HAS_COCKOS_EXTENSIONS)

  616.             {

  617.                 double range[2] = { 0.0, 1.0 };

  618. 

  619.                 if (dispatcher(effVendorSpecific, 0xdeadbef0, j, range, 0.0f) >= 0xbeef)

  620.                 {

  621.                     min = range[0];

  622.                     max = range[1];

  623. 

  624.                     if (min > max)

  625.                         max = min;

  626.                     else if (max < min)

  627.                         min = max;

  628. 

  629.                     if (max - min == 0.0f)

  630.                     {

  631.                         carla_stderr2("WARNING - Broken plugin parameter: max - min == 0.0f (with cockos extensions)");

  632.                         max = min + 0.1f;

  633.                     }

  634.                 }

  635.                 else

  636.                 {

  637.                     min = 0.0f;

  638.                     max = 1.0f;

  639.                 }

  640. 

  641.                 if (dispatcher(effVendorSpecific, kVstParameterUsesIntStep, j, nullptr, 0.0f) >= 0xbeef)

  642.                 {

  643.                     step = 1.0f;

  644.                     stepSmall = 1.0f;

  645.                     stepLarge = 10.0f;

  646.                 }

  647.                 else

  648.                 {

  649.                     float range = max - min;

  650.                     step = range/100.0f;

  651.                     stepSmall = range/1000.0f;

  652.                     stepLarge = range/10.0f;

  653.                 }

  654.             }

  655.             else if (dispatcher(effGetParameterProperties, j, 0, &prop, 0) == 1)

  656.             {

  657.                 if (prop.flags & kVstParameterUsesIntegerMinMax)

  658.                 {

  659.                     min = float(prop.minInteger);

  660.                     max = float(prop.maxInteger);

  661. 

  662.                     if (min > max)

  663.                         max = min;

  664.                     else if (max < min)

  665.                         min = max;

  666. 

  667.                     if (max - min == 0.0f)

  668.                     {

  669.                         carla_stderr2("WARNING - Broken plugin parameter: max - min == 0.0f");

  670.                         max = min + 0.1f;

  671.                     }

  672.                 }

  673.                 else

  674.                 {

  675.                     min = 0.0f;

  676.                     max = 1.0f;

  677.                 }

  678. 

  679.                 if (prop.flags & kVstParameterIsSwitch)

  680.                 {

  681.                     step = max - min;

  682.                     stepSmall = step;

  683.                     stepLarge = step;

  684.                     pData->param.data[j].hints |= PARAMETER_IS_BOOLEAN;

  685.                 }

  686.                 else if (prop.flags & kVstParameterUsesIntStep)

  687.                 {

  688.                     step = float(prop.stepInteger);

  689.                     stepSmall = float(prop.stepInteger)/10;

  690.                     stepLarge = float(prop.largeStepInteger);

  691.                     pData->param.data[j].hints |= PARAMETER_IS_INTEGER;

  692.                 }

  693.                 else if (prop.flags & kVstParameterUsesFloatStep)

  694.                 {

  695.                     step = prop.stepFloat;

  696.                     stepSmall = prop.smallStepFloat;

  697.                     stepLarge = prop.largeStepFloat;

  698.                 }

  699.                 else

  700.                 {

  701.                     float range = max - min;

  702.                     step = range/100.0f;

  703.                     stepSmall = range/1000.0f;

  704.                     stepLarge = range/10.0f;

  705.                 }

  706. 

  707.                 if (prop.flags & kVstParameterCanRamp)

  708.                     pData->param.data[j].hints |= PARAMETER_IS_LOGARITHMIC;

  709.             }

  710.             else

  711.             {

  712.                 min = 0.0f;

  713.                 max = 1.0f;

  714.                 step = 0.001f;

  715.                 stepSmall = 0.0001f;

  716.                 stepLarge = 0.1f;

  717.             }

  718. 

  719.             pData->param.data[j].hints |= PARAMETER_IS_ENABLED;

  720. #ifndef BUILD_BRIDGE

  721.             pData->param.data[j].hints |= PARAMETER_USES_CUSTOM_TEXT;

  722. #endif

  723. 

  724.             if ((pData->hints & PLUGIN_USES_OLD_VSTSDK) != 0 || dispatcher(effCanBeAutomated, j, 0, nullptr, 0.0f) == 1)

  725.                 pData->param.data[j].hints |= PARAMETER_IS_AUTOMABLE;

  726. 

  727.             // no such thing as VST default parameters

  728.             def = fEffect->getParameter(fEffect, j);

  729. 

  730.             if (def < min)

  731.                 def = min;

  732.             else if (def > max)

  733.                 def = max;

  734. 

  735.             pData->param.ranges[j].min = min;

  736.             pData->param.ranges[j].max = max;

  737.             pData->param.ranges[j].def = def;

  738.             pData->param.ranges[j].step = step;

  739.             pData->param.ranges[j].stepSmall = stepSmall;

  740.             pData->param.ranges[j].stepLarge = stepLarge;

  741.         }

  742. 

  743.         if (needsCtrlIn)

  744.         {

  745.             portName.clear();

  746. 

  747.             if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  748.             {

  749.                 portName  = pData->name;

  750.                 portName += ":";

  751.             }

  752. 

  753.             portName += "events-in";

  754.             portName.truncate(portNameSize);

  755. 

  756.             pData->event.portIn = (CarlaEngineEventPort*)pData->client->addPort(kEnginePortTypeEvent, portName, true);

  757.         }

  758. 

  759.         if (needsCtrlOut)

  760.         {

  761.             portName.clear();

  762. 

  763.             if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  764.             {

  765.                 portName  = pData->name;

  766.                 portName += ":";

  767.             }

  768. 

  769.             portName += "events-out";

  770.             portName.truncate(portNameSize);

  771. 

  772.             pData->event.portOut = (CarlaEngineEventPort*)pData->client->addPort(kEnginePortTypeEvent, portName, false);

  773.         }

  774. 

  775.         // plugin hints

  776.         const intptr_t vstCategory = dispatcher(effGetPlugCategory, 0, 0, nullptr, 0.0f);

  777. 

  778.         pData->hints = 0x0;

  779. 

  780.         //if (vstCategory == kPlugCategSynth || vstCategory == kPlugCategGenerator)

  781.         //    pData->hints |= PLUGIN_IS_SYNTH;

  782. 

  783.         if (fEffect->flags & effFlagsHasEditor)

  784.         {

  785.             pData->hints |= PLUGIN_HAS_CUSTOM_UI;

  786. 

  787.             if (! fGui.isOsc)

  788.                 pData->hints |= PLUGIN_NEEDS_SINGLE_THREAD;

  789.         }

  790. 

  791.         if (dispatcher(effGetVstVersion, 0, 0, nullptr, 0.0f) < kVstVersion)

  792.             pData->hints |= PLUGIN_USES_OLD_VSTSDK;

  793. 

  794.         if ((fEffect->flags & effFlagsCanReplacing) != 0 && fEffect->processReplacing != fEffect->process)

  795.             pData->hints |= PLUGIN_CAN_PROCESS_REPLACING;

  796. 

  797.         if (static_cast<uintptr_t>(dispatcher(effCanDo, 0, 0, (void*)"hasCockosExtensions", 0.0f)) == 0xbeef0000)

  798.             pData->hints |= PLUGIN_HAS_COCKOS_EXTENSIONS;

  799. 

  800.         if (aOuts > 0 && (aIns == aOuts || aIns == 1))

  801.             pData->hints |= PLUGIN_CAN_DRYWET;

  802. 

  803.         if (aOuts > 0)

  804.             pData->hints |= PLUGIN_CAN_VOLUME;

  805. 

  806.         if (aOuts >= 2 && aOuts % 2 == 0)

  807.             pData->hints |= PLUGIN_CAN_BALANCE;

  808. 

  809.         // extra plugin hints

  810.         pData->extraHints = 0x0;

  811. 

  812.         if (mIns > 0)

  813.             pData->extraHints |= PLUGIN_EXTRA_HINT_HAS_MIDI_IN;

  814. 

  815.         if (mOuts > 0)

  816.             pData->extraHints |= PLUGIN_EXTRA_HINT_HAS_MIDI_OUT;

  817. 

  818.         if (aIns <= 2 && aOuts <= 2 && (aIns == aOuts || aIns == 0 || aOuts == 0))

  819.             pData->extraHints |= PLUGIN_EXTRA_HINT_CAN_RUN_RACK;

  820. 

  821.         // dummy pre-start to get latency and wantEvents() on old plugins

  822.         {

  823.             activate();

  824.             deactivate();

  825.         }

  826. 

  827.         // check latency

  828.         if (pData->hints & PLUGIN_CAN_DRYWET)

  829.         {

  830. #ifdef VESTIGE_HEADER

  831.             char* const empty3Ptr = &fEffect->empty3[0];

  832.             int32_t* initialDelayPtr = (int32_t*)empty3Ptr;

  833.             pData->latency = *initialDelayPtr;

  834. #else

  835.             pData->latency = fEffect->initialDelay;

  836. #endif

  837. 

  838.             pData->client->setLatency(pData->latency);

  839.             pData->recreateLatencyBuffers();

  840.         }

  841. 

  842.         // special plugin fixes

  843.         // 1. IL Harmless - disable threaded processing

  844.         if (fEffect->uniqueID == 1229484653)

  845.         {

  846.             char strBuf[STR_MAX+1] = { '\0' };

  847.             getLabel(strBuf);

  848. 

  849.             if (std::strcmp(strBuf, "IL Harmless") == 0)

  850.             {

  851.                 // TODO - disable threaded processing

  852.             }

  853.         }

  854. 

  855.         bufferSizeChanged(pData->engine->getBufferSize());

  856.         reloadPrograms(true);

  857. 

  858.         if (pData->active)

  859.             activate();

  860. 

  861.         carla_debug("VstPlugin::reload() - end");

  862.     }

  863. 

  864.     void reloadPrograms(const bool init) override

  865.     {

  866.         carla_debug("VstPlugin::reloadPrograms(%s)", bool2str(init));

  867.         uint32_t i, oldCount  = pData->prog.count;

  868.         const int32_t current = pData->prog.current;

  869. 

  870.         // Delete old programs

  871.         pData->prog.clear();

  872. 

  873.         // Query new programs

  874.         uint32_t count = static_cast<uint32_t>(fEffect->numPrograms);

  875. 

  876.         if (count > 0)

  877.         {

  878.             pData->prog.createNew(count);

  879. 

  880.             // Update names

  881.             for (i=0; i < count; ++i)

  882.             {

  883.                 char strBuf[STR_MAX+1] = { '\0' };

  884.                 if (dispatcher(effGetProgramNameIndexed, i, 0, strBuf, 0.0f) != 1)

  885.                 {

  886.                     // program will be [re-]changed later

  887.                     dispatcher(effSetProgram, 0, i, nullptr, 0.0f);

  888.                     dispatcher(effGetProgramName, 0, 0, strBuf, 0.0f);

  889.                 }

  890.                 pData->prog.names[i] = strdup(strBuf);

  891.             }

  892.         }

  893. 

  894. #ifndef BUILD_BRIDGE

  895.         // Update OSC Names

  896.         if (pData->engine->isOscControlRegistered())

  897.         {

  898.             pData->engine->oscSend_control_set_program_count(pData->id, count);

  899. 

  900.             for (i=0; i < count; ++i)

  901.                 pData->engine->oscSend_control_set_program_name(pData->id, i, pData->prog.names[i]);

  902.         }

  903. #endif

  904. 

  905.         if (init)

  906.         {

  907.             if (count > 0)

  908.                 setProgram(0, false, false, false);

  909.         }

  910.         else

  911.         {

  912.             // Check if current program is invalid

  913.             bool programChanged = false;

  914. 

  915.             if (count == oldCount+1)

  916.             {

  917.                 // one program added, probably created by user

  918.                 pData->prog.current = oldCount;

  919.                 programChanged = true;

  920.             }

  921.             else if (current < 0 && count > 0)

  922.             {

  923.                 // programs exist now, but not before

  924.                 pData->prog.current = 0;

  925.                 programChanged = true;

  926.             }

  927.             else if (current >= 0 && count == 0)

  928.             {

  929.                 // programs existed before, but not anymore

  930.                 pData->prog.current = -1;

  931.                 programChanged = true;

  932.             }

  933.             else if (current >= static_cast<int32_t>(count))

  934.             {

  935.                 // current program > count

  936.                 pData->prog.current = 0;

  937.                 programChanged = true;

  938.             }

  939.             else

  940.             {

  941.                 // no change

  942.                 pData->prog.current = current;

  943.             }

  944. 

  945.             if (programChanged)

  946.             {

  947.                 setProgram(pData->prog.current, true, true, true);

  948.             }

  949.             else

  950.             {

  951.                 // Program was changed during update, re-set it

  952.                 if (pData->prog.current >= 0)

  953.                     dispatcher(effSetProgram, 0, pData->prog.current, nullptr, 0.0f);

  954.             }

  955. 

  956.             pData->engine->callback(ENGINE_CALLBACK_RELOAD_PROGRAMS, pData->id, 0, 0, 0.0f, nullptr);

  957.         }

  958.     }

  959. 

  960.     // -------------------------------------------------------------------

  961.     // Plugin processing

  962. 

  963.     void activate() override

  964.     {

  965.         dispatcher(effMainsChanged, 0, 1, nullptr, 0.0f);

  966.         dispatcher(effStartProcess, 0, 0, nullptr, 0.0f);

  967.     }

  968. 

  969.     void deactivate() override

  970.     {

  971.         dispatcher(effStopProcess, 0, 0, nullptr, 0.0f);

  972.         dispatcher(effMainsChanged, 0, 0, nullptr, 0.0f);

  973.     }

  974. 

  975.     void process(float** const inBuffer, float** const outBuffer, const uint32_t frames) override

  976.     {

  977.         uint32_t i, k;

  978. 

  979.         // --------------------------------------------------------------------------------------------------------

  980.         // Check if active

  981. 

  982.         if (! pData->active)

  983.         {

  984.             // disable any output sound

  985.             for (i=0; i < pData->audioOut.count; ++i)

  986.                 FLOAT_CLEAR(outBuffer[i], frames);

  987.             return;

  988.         }

  989. 

  990.         fMidiEventCount = 0;

  991.         carla_zeroStruct<VstMidiEvent>(fMidiEvents, kPluginMaxMidiEvents*2);

  992. 

  993.         // --------------------------------------------------------------------------------------------------------

  994.         // Check if needs reset

  995. 

  996.         if (pData->needsReset)

  997.         {

  998.             if (pData->options & PLUGIN_OPTION_SEND_ALL_SOUND_OFF)

  999.             {

  1000.                 for (k=0, i=MAX_MIDI_CHANNELS; k < MAX_MIDI_CHANNELS; ++k)

  1001.                 {

  1002.                     fMidiEvents[k].type = kVstMidiType;

  1003.                     fMidiEvents[k].byteSize = sizeof(VstMidiEvent);

  1004.                     fMidiEvents[k].midiData[0] = MIDI_STATUS_CONTROL_CHANGE + k;

  1005.                     fMidiEvents[k].midiData[1] = MIDI_CONTROL_ALL_NOTES_OFF;

  1006. 

  1007.                     fMidiEvents[k+i].type = kVstMidiType;

  1008.                     fMidiEvents[k+i].byteSize = sizeof(VstMidiEvent);

  1009.                     fMidiEvents[k+i].midiData[0] = MIDI_STATUS_CONTROL_CHANGE + k;

  1010.                     fMidiEvents[k+i].midiData[1] = MIDI_CONTROL_ALL_SOUND_OFF;

  1011.                 }

  1012. 

  1013.                 fMidiEventCount = MAX_MIDI_CHANNELS*2;

  1014.             }

  1015.             else if (pData->ctrlChannel >= 0 && pData->ctrlChannel < MAX_MIDI_CHANNELS)

  1016.             {

  1017.                 for (k=0; k < MAX_MIDI_NOTE; ++k)

  1018.                 {

  1019.                     fMidiEvents[k].type = kVstMidiType;

  1020.                     fMidiEvents[k].byteSize = sizeof(VstMidiEvent);

  1021.                     fMidiEvents[k].midiData[0] = MIDI_STATUS_NOTE_OFF + pData->ctrlChannel;

  1022.                     fMidiEvents[k].midiData[1] = k;

  1023.                 }

  1024. 

  1025.                 fMidiEventCount = MAX_MIDI_NOTE;

  1026.             }

  1027. 

  1028.             if (pData->latency > 0)

  1029.             {

  1030.                 for (i=0; i < pData->audioIn.count; ++i)

  1031.                     FLOAT_CLEAR(pData->latencyBuffers[i], pData->latency);

  1032.             }

  1033. 

  1034.             pData->needsReset = false;

  1035.         }

  1036. 

  1037.         CARLA_PROCESS_CONTINUE_CHECK;

  1038. 

  1039.         // --------------------------------------------------------------------------------------------------------

  1040.         // Set TimeInfo

  1041. 

  1042.         const EngineTimeInfo& timeInfo(pData->engine->getTimeInfo());

  1043. 

  1044.         fTimeInfo.flags = kVstTransportChanged;

  1045. 

  1046.         if (timeInfo.playing)

  1047.             fTimeInfo.flags |= kVstTransportPlaying;

  1048. 

  1049.         fTimeInfo.samplePos  = timeInfo.frame;

  1050.         fTimeInfo.sampleRate = pData->engine->getSampleRate();

  1051. 

  1052.         if (timeInfo.usecs != 0)

  1053.         {

  1054.             fTimeInfo.nanoSeconds = timeInfo.usecs/1000;

  1055.             fTimeInfo.flags |= kVstNanosValid;

  1056.         }

  1057. 

  1058.         if (timeInfo.valid & EngineTimeInfo::kValidBBT)

  1059.         {

  1060.             double ppqBar  = double(timeInfo.bbt.bar - 1) * timeInfo.bbt.beatsPerBar;

  1061.             double ppqBeat = double(timeInfo.bbt.beat - 1);

  1062.             double ppqTick = double(timeInfo.bbt.tick) / timeInfo.bbt.ticksPerBeat;

  1063. 

  1064.             // PPQ Pos

  1065.             fTimeInfo.ppqPos = ppqBar + ppqBeat + ppqTick;

  1066.             fTimeInfo.flags |= kVstPpqPosValid;

  1067. 

  1068.             // Tempo

  1069.             fTimeInfo.tempo  = timeInfo.bbt.beatsPerMinute;

  1070.             fTimeInfo.flags |= kVstTempoValid;

  1071. 

  1072.             // Bars

  1073.             fTimeInfo.barStartPos = ppqBar;

  1074.             fTimeInfo.flags |= kVstBarsValid;

  1075. 

  1076.             // Time Signature

  1077.             fTimeInfo.timeSigNumerator   = timeInfo.bbt.beatsPerBar;

  1078.             fTimeInfo.timeSigDenominator = timeInfo.bbt.beatType;

  1079.             fTimeInfo.flags |= kVstTimeSigValid;

  1080.         }

  1081.         else

  1082.         {

  1083.             // Tempo

  1084.             fTimeInfo.tempo = 120.0;

  1085.             fTimeInfo.flags |= kVstTempoValid;

  1086. 

  1087.             // Time Signature

  1088.             fTimeInfo.timeSigNumerator   = 4;

  1089.             fTimeInfo.timeSigDenominator = 4;

  1090.             fTimeInfo.flags |= kVstTimeSigValid;

  1091. 

  1092.             // Missing info

  1093.             fTimeInfo.ppqPos = 0.0;

  1094.             fTimeInfo.barStartPos = 0.0;

  1095.         }

  1096. 

  1097.         CARLA_PROCESS_CONTINUE_CHECK;

  1098. 

  1099.         // --------------------------------------------------------------------------------------------------------

  1100.         // Event Input and Processing

  1101. 

  1102.         if (pData->event.portIn != nullptr)

  1103.         {

  1104.             // ----------------------------------------------------------------------------------------------------

  1105.             // MIDI Input (External)

  1106. 

  1107.             if (pData->extNotes.mutex.tryLock())

  1108.             {

  1109.                 while (fMidiEventCount < kPluginMaxMidiEvents*2 && ! pData->extNotes.data.isEmpty())

  1110.                 {

  1111.                     const ExternalMidiNote& note(pData->extNotes.data.getFirst(true));

  1112. 

  1113.                     CARLA_ASSERT(note.channel >= 0 && note.channel < MAX_MIDI_CHANNELS);

  1114. 

  1115.                     fMidiEvents[fMidiEventCount].type = kVstMidiType;

  1116.                     fMidiEvents[fMidiEventCount].byteSize = sizeof(VstMidiEvent);

  1117.                     fMidiEvents[fMidiEventCount].midiData[0]  = (note.velo > 0) ? MIDI_STATUS_NOTE_ON : MIDI_STATUS_NOTE_OFF;

  1118.                     fMidiEvents[fMidiEventCount].midiData[0] += note.channel;

  1119.                     fMidiEvents[fMidiEventCount].midiData[1]  = note.note;

  1120.                     fMidiEvents[fMidiEventCount].midiData[2]  = note.velo;

  1121. 

  1122.                     fMidiEventCount += 1;

  1123.                 }

  1124. 

  1125.                 pData->extNotes.mutex.unlock();

  1126. 

  1127.             } // End of MIDI Input (External)

  1128. 

  1129.             // ----------------------------------------------------------------------------------------------------

  1130.             // Event Input (System)

  1131. 

  1132.             bool allNotesOffSent = false;

  1133.             bool sampleAccurate  = (pData->options & PLUGIN_OPTION_FIXED_BUFFERS) == 0;

  1134. 

  1135.             uint32_t time, nEvents = pData->event.portIn->getEventCount();

  1136.             uint32_t startTime  = 0;

  1137.             uint32_t timeOffset = 0;

  1138. 

  1139.             for (i=0; i < nEvents; ++i)

  1140.             {

  1141.                 const EngineEvent& event(pData->event.portIn->getEvent(i));

  1142. 

  1143.                 time = event.time;

  1144. 

  1145.                 if (time >= frames)

  1146.                     continue;

  1147. 

  1148.                 CARLA_ASSERT_INT2(time >= timeOffset, time, timeOffset);

  1149. 

  1150.                 if (time > timeOffset && sampleAccurate)

  1151.                 {

  1152.                     if (processSingle(inBuffer, outBuffer, time - timeOffset, timeOffset))

  1153.                     {

  1154.                         startTime  = 0;

  1155.                         timeOffset = time;

  1156. 

  1157.                         if (fMidiEventCount > 0)

  1158.                         {

  1159.                             carla_zeroStruct<VstMidiEvent>(fMidiEvents, fMidiEventCount);

  1160.                             fMidiEventCount = 0;

  1161.                         }

  1162.                     }

  1163.                     else

  1164.                         startTime += timeOffset;

  1165.                 }

  1166. 

  1167.                 // Control change

  1168.                 switch (event.type)

  1169.                 {

  1170.                 case kEngineEventTypeNull:

  1171.                     break;

  1172. 

  1173.                 case kEngineEventTypeControl:

  1174.                 {

  1175.                     const EngineControlEvent& ctrlEvent = event.ctrl;

  1176. 

  1177.                     switch (ctrlEvent.type)

  1178.                     {

  1179.                     case kEngineControlEventTypeNull:

  1180.                         break;

  1181. 

  1182.                     case kEngineControlEventTypeParameter:

  1183.                     {

  1184. #ifndef BUILD_BRIDGE

  1185.                         // Control backend stuff

  1186.                         if (event.channel == pData->ctrlChannel)

  1187.                         {

  1188.                             float value;

  1189. 

  1190.                             if (MIDI_IS_CONTROL_BREATH_CONTROLLER(ctrlEvent.param) && (pData->hints & PLUGIN_CAN_DRYWET) > 0)

  1191.                             {

  1192.                                 value = ctrlEvent.value;

  1193.                                 setDryWet(value, false, false);

  1194.                                 pData->postponeRtEvent(kPluginPostRtEventParameterChange, PARAMETER_DRYWET, 0, value);

  1195.                             }

  1196. 

  1197.                             if (MIDI_IS_CONTROL_CHANNEL_VOLUME(ctrlEvent.param) && (pData->hints & PLUGIN_CAN_VOLUME) > 0)

  1198.                             {

  1199.                                 value = ctrlEvent.value*127.0f/100.0f;

  1200.                                 setVolume(value, false, false);

  1201.                                 pData->postponeRtEvent(kPluginPostRtEventParameterChange, PARAMETER_VOLUME, 0, value);

  1202.                             }

  1203. 

  1204.                             if (MIDI_IS_CONTROL_BALANCE(ctrlEvent.param) && (pData->hints & PLUGIN_CAN_BALANCE) > 0)

  1205.                             {

  1206.                                 float left, right;

  1207.                                 value = ctrlEvent.value/0.5f - 1.0f;

  1208. 

  1209.                                 if (value < 0.0f)

  1210.                                 {

  1211.                                     left  = -1.0f;

  1212.                                     right = (value*2.0f)+1.0f;

  1213.                                 }

  1214.                                 else if (value > 0.0f)

  1215.                                 {

  1216.                                     left  = (value*2.0f)-1.0f;

  1217.                                     right = 1.0f;

  1218.                                 }

  1219.                                 else

  1220.                                 {

  1221.                                     left  = -1.0f;

  1222.                                     right = 1.0f;

  1223.                                 }

  1224. 

  1225.                                 setBalanceLeft(left, false, false);

  1226.                                 setBalanceRight(right, false, false);

  1227.                                 pData->postponeRtEvent(kPluginPostRtEventParameterChange, PARAMETER_BALANCE_LEFT, 0, left);

  1228.                                 pData->postponeRtEvent(kPluginPostRtEventParameterChange, PARAMETER_BALANCE_RIGHT, 0, right);

  1229.                             }

  1230.                         }

  1231. #endif

  1232. 

  1233.                         // Control plugin parameters

  1234.                         for (k=0; k < pData->param.count; ++k)

  1235.                         {

  1236.                             if (pData->param.data[k].midiChannel != event.channel)

  1237.                                 continue;

  1238.                             if (pData->param.data[k].midiCC != ctrlEvent.param)

  1239.                                 continue;

  1240.                             if ((pData->param.data[k].hints & PARAMETER_IS_INPUT) == 0)

  1241.                                 continue;

  1242.                             if ((pData->param.data[k].hints & PARAMETER_IS_AUTOMABLE) == 0)

  1243.                                 continue;

  1244. 

  1245.                             float value;

  1246. 

  1247.                             if (pData->param.data[k].hints & PARAMETER_IS_BOOLEAN)

  1248.                             {

  1249.                                 value = (ctrlEvent.value < 0.5f) ? pData->param.ranges[k].min : pData->param.ranges[k].max;

  1250.                             }

  1251.                             else

  1252.                             {

  1253.                                 value = pData->param.ranges[k].getUnnormalizedValue(ctrlEvent.value);

  1254. 

  1255.                                 if (pData->param.data[k].hints & PARAMETER_IS_INTEGER)

  1256.                                     value = std::rint(value);

  1257.                             }

  1258. 

  1259.                             setParameterValue(k, value, false, false, false);

  1260.                             pData->postponeRtEvent(kPluginPostRtEventParameterChange, static_cast<int32_t>(k), 0, value);

  1261.                         }

  1262. 

  1263.                         if ((pData->options & PLUGIN_OPTION_SEND_CONTROL_CHANGES) != 0 && ctrlEvent.param <= 0x5F)

  1264.                         {

  1265.                             if (fMidiEventCount >= kPluginMaxMidiEvents*2)

  1266.                                 continue;

  1267. 

  1268.                             carla_zeroStruct<VstMidiEvent>(fMidiEvents[fMidiEventCount]);

  1269. 

  1270.                             fMidiEvents[fMidiEventCount].type = kVstMidiType;

  1271.                             fMidiEvents[fMidiEventCount].byteSize = sizeof(VstMidiEvent);

  1272.                             fMidiEvents[fMidiEventCount].midiData[0] = MIDI_STATUS_CONTROL_CHANGE + event.channel;

  1273.                             fMidiEvents[fMidiEventCount].midiData[1] = ctrlEvent.param;

  1274.                             fMidiEvents[fMidiEventCount].midiData[2] = ctrlEvent.value*127.0f;

  1275.                             fMidiEvents[fMidiEventCount].deltaFrames = sampleAccurate ? startTime : time;

  1276. 

  1277.                             fMidiEventCount += 1;

  1278.                         }

  1279. 

  1280.                         break;

  1281.                     }

  1282. 

  1283.                     case kEngineControlEventTypeMidiBank:

  1284.                         break;

  1285. 

  1286.                     case kEngineControlEventTypeMidiProgram:

  1287.                         if (event.channel == pData->ctrlChannel && (pData->options & PLUGIN_OPTION_MAP_PROGRAM_CHANGES) != 0)

  1288.                         {

  1289.                             if (ctrlEvent.param < pData->prog.count)

  1290.                             {

  1291.                                 setProgram(ctrlEvent.param, false, false, false);

  1292.                                 pData->postponeRtEvent(kPluginPostRtEventProgramChange, ctrlEvent.param, 0, 0.0f);

  1293.                                 break;

  1294.                             }

  1295.                         }

  1296.                         break;

  1297. 

  1298.                     case kEngineControlEventTypeAllSoundOff:

  1299.                         if (pData->options & PLUGIN_OPTION_SEND_ALL_SOUND_OFF)

  1300.                         {

  1301.                             if (fMidiEventCount >= kPluginMaxMidiEvents*2)

  1302.                                 continue;

  1303. 

  1304.                             carla_zeroStruct<VstMidiEvent>(fMidiEvents[fMidiEventCount]);

  1305. 

  1306.                             fMidiEvents[fMidiEventCount].type = kVstMidiType;

  1307.                             fMidiEvents[fMidiEventCount].byteSize = sizeof(VstMidiEvent);

  1308.                             fMidiEvents[fMidiEventCount].midiData[0] = MIDI_STATUS_CONTROL_CHANGE + event.channel;

  1309.                             fMidiEvents[fMidiEventCount].midiData[1] = MIDI_CONTROL_ALL_SOUND_OFF;

  1310.                             fMidiEvents[fMidiEventCount].deltaFrames = sampleAccurate ? startTime : time;

  1311. 

  1312.                             fMidiEventCount += 1;

  1313.                         }

  1314.                         break;

  1315. 

  1316.                     case kEngineControlEventTypeAllNotesOff:

  1317.                         if (pData->options & PLUGIN_OPTION_SEND_ALL_SOUND_OFF)

  1318.                         {

  1319.                             if (event.channel == pData->ctrlChannel && ! allNotesOffSent)

  1320.                             {

  1321.                                 allNotesOffSent = true;

  1322.                                 sendMidiAllNotesOffToCallback();

  1323.                             }

  1324. 

  1325.                             if (fMidiEventCount >= kPluginMaxMidiEvents*2)

  1326.                                 continue;

  1327. 

  1328.                             carla_zeroStruct<VstMidiEvent>(fMidiEvents[fMidiEventCount]);

  1329. 

  1330.                             fMidiEvents[fMidiEventCount].type = kVstMidiType;

  1331.                             fMidiEvents[fMidiEventCount].byteSize = sizeof(VstMidiEvent);

  1332.                             fMidiEvents[fMidiEventCount].midiData[0] = MIDI_STATUS_CONTROL_CHANGE + event.channel;

  1333.                             fMidiEvents[fMidiEventCount].midiData[1] = MIDI_CONTROL_ALL_NOTES_OFF;

  1334.                             fMidiEvents[fMidiEventCount].deltaFrames = sampleAccurate ? startTime : time;

  1335. 

  1336.                             fMidiEventCount += 1;

  1337.                         }

  1338.                         break;

  1339.                     }

  1340. 

  1341.                     break;

  1342.                 }

  1343. 

  1344.                 case kEngineEventTypeMidi:

  1345.                 {

  1346.                     if (fMidiEventCount >= kPluginMaxMidiEvents*2)

  1347.                         continue;

  1348. 

  1349.                     const EngineMidiEvent& midiEvent(event.midi);

  1350. 

  1351.                     uint8_t status  = MIDI_GET_STATUS_FROM_DATA(midiEvent.data);

  1352.                     uint8_t channel = event.channel;

  1353. 

  1354.                     if (MIDI_IS_STATUS_CHANNEL_PRESSURE(status) && (pData->options & PLUGIN_OPTION_SEND_CHANNEL_PRESSURE) == 0)

  1355.                         continue;

  1356.                     if (MIDI_IS_STATUS_CONTROL_CHANGE(status) && (pData->options & PLUGIN_OPTION_SEND_CONTROL_CHANGES) == 0)

  1357.                         continue;

  1358.                     if (MIDI_IS_STATUS_POLYPHONIC_AFTERTOUCH(status) && (pData->options & PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH) == 0)

  1359.                         continue;

  1360.                     if (MIDI_IS_STATUS_PITCH_WHEEL_CONTROL(status) && (pData->options & PLUGIN_OPTION_SEND_PITCHBEND) == 0)

  1361.                         continue;

  1362. 

  1363.                     // Fix bad note-off

  1364.                     if (status == MIDI_STATUS_NOTE_ON && midiEvent.data[2] == 0)

  1365.                         status -= 0x10;

  1366. 

  1367.                     carla_zeroStruct<VstMidiEvent>(fMidiEvents[fMidiEventCount]);

  1368. 

  1369.                     fMidiEvents[fMidiEventCount].type = kVstMidiType;

  1370.                     fMidiEvents[fMidiEventCount].byteSize = sizeof(VstMidiEvent);

  1371.                     fMidiEvents[fMidiEventCount].midiData[0] = status + channel;

  1372.                     fMidiEvents[fMidiEventCount].midiData[1] = midiEvent.data[1];

  1373.                     fMidiEvents[fMidiEventCount].midiData[2] = midiEvent.data[2];

  1374.                     fMidiEvents[fMidiEventCount].deltaFrames = sampleAccurate ? startTime : time;

  1375. 

  1376.                     fMidiEventCount += 1;

  1377. 

  1378.                     if (status == MIDI_STATUS_NOTE_ON)

  1379.                         pData->postponeRtEvent(kPluginPostRtEventNoteOn, channel, midiEvent.data[1], midiEvent.data[2]);

  1380.                     else if (status == MIDI_STATUS_NOTE_OFF)

  1381.                         pData->postponeRtEvent(kPluginPostRtEventNoteOff, channel, midiEvent.data[1], 0.0f);

  1382. 

  1383.                     break;

  1384.                 }

  1385.                 }

  1386.             }

  1387. 

  1388.             pData->postRtEvents.trySplice();

  1389. 

  1390.             if (frames > timeOffset)

  1391.                 processSingle(inBuffer, outBuffer, frames - timeOffset, timeOffset);

  1392. 

  1393.         } // End of Event Input and Processing

  1394. 

  1395.         // --------------------------------------------------------------------------------------------------------

  1396.         // Plugin processing (no events)

  1397. 

  1398.         else

  1399.         {

  1400.             processSingle(inBuffer, outBuffer, frames, 0);

  1401. 

  1402.         } // End of Plugin processing (no events)

  1403. 

  1404.         CARLA_PROCESS_CONTINUE_CHECK;

  1405. 

  1406.         // --------------------------------------------------------------------------------------------------------

  1407.         // MIDI Output

  1408. 

  1409.         if (pData->event.portOut != nullptr)

  1410.         {

  1411.             // reverse lookup MIDI events

  1412.             for (k = (kPluginMaxMidiEvents*2)-1; k >= fMidiEventCount; --k)

  1413.             {

  1414.                 if (fMidiEvents[k].type == 0)

  1415.                     break;

  1416. 

  1417.                 const uint8_t channel = MIDI_GET_CHANNEL_FROM_DATA(fMidiEvents[k].midiData);

  1418. 

  1419.                 uint8_t midiData[3] = { 0 };

  1420.                 midiData[0] = fMidiEvents[k].midiData[0];

  1421.                 midiData[1] = fMidiEvents[k].midiData[1];

  1422.                 midiData[2] = fMidiEvents[k].midiData[2];

  1423. 

  1424.                 pData->event.portOut->writeMidiEvent(fMidiEvents[k].deltaFrames, channel, 0, 3, midiData);

  1425.             }

  1426. 

  1427.         } // End of Control and MIDI Output

  1428.     }

  1429. 

  1430.     bool processSingle(float** const inBuffer, float** const outBuffer, const uint32_t frames, const uint32_t timeOffset)

  1431.     {

  1432.         CARLA_ASSERT(frames > 0);

  1433. 

  1434.         if (frames == 0)

  1435.             return false;

  1436. 

  1437.         if (pData->audioIn.count > 0)

  1438.         {

  1439.             CARLA_ASSERT(inBuffer != nullptr);

  1440.             if (inBuffer == nullptr)

  1441.                 return false;

  1442.         }

  1443.         if (pData->audioOut.count > 0)

  1444.         {

  1445.             CARLA_ASSERT(outBuffer != nullptr);

  1446.             if (outBuffer == nullptr)

  1447.                 return false;

  1448.         }

  1449. 

  1450.         uint32_t i, k;

  1451. 

  1452.         // --------------------------------------------------------------------------------------------------------

  1453.         // Try lock, silence otherwise

  1454. 

  1455.         if (pData->engine->isOffline())

  1456.         {

  1457.             pData->singleMutex.lock();

  1458.         }

  1459.         else if (! pData->singleMutex.tryLock())

  1460.         {

  1461.             for (i=0; i < pData->audioOut.count; ++i)

  1462.             {

  1463.                 for (k=0; k < frames; ++k)

  1464.                     outBuffer[i][k+timeOffset] = 0.0f;

  1465.             }

  1466. 

  1467.             return false;

  1468.         }

  1469. 

  1470.         // --------------------------------------------------------------------------------------------------------

  1471.         // Set audio buffers

  1472. 

  1473.         float* vstInBuffer[pData->audioIn.count];

  1474.         float* vstOutBuffer[pData->audioOut.count];

  1475. 

  1476.         for (i=0; i < pData->audioIn.count; ++i)

  1477.             vstInBuffer[i] = inBuffer[i]+timeOffset;

  1478.         for (i=0; i < pData->audioOut.count; ++i)

  1479.             vstOutBuffer[i] = outBuffer[i]+timeOffset;

  1480. 

  1481.         // --------------------------------------------------------------------------------------------------------

  1482.         // Set MIDI events

  1483. 

  1484.         if (fMidiEventCount > 0)

  1485.         {

  1486.             fEvents.numEvents = fMidiEventCount;

  1487.             fEvents.reserved  = 0;

  1488.             dispatcher(effProcessEvents, 0, 0, &fEvents, 0.0f);

  1489.         }

  1490. 

  1491.         // --------------------------------------------------------------------------------------------------------

  1492.         // Run plugin

  1493. 

  1494.         fIsProcessing = true;

  1495. 

  1496.         if (pData->hints & PLUGIN_CAN_PROCESS_REPLACING)

  1497.         {

  1498.             fEffect->processReplacing(fEffect,

  1499.                                       (pData->audioIn.count > 0) ? vstInBuffer : nullptr,

  1500.                                       (pData->audioOut.count > 0) ? vstOutBuffer : nullptr,

  1501.                                       frames);

  1502.         }

  1503.         else

  1504.         {

  1505.             for (i=0; i < pData->audioOut.count; ++i)

  1506.                 FLOAT_CLEAR(vstOutBuffer[i], frames);

  1507. 

  1508. #if ! VST_FORCE_DEPRECATED

  1509.             fEffect->process(fEffect,

  1510.                              (pData->audioIn.count > 0) ? vstInBuffer : nullptr,

  1511.                              (pData->audioOut.count > 0) ? vstOutBuffer : nullptr,

  1512.                              frames);

  1513. #endif

  1514.         }

  1515. 

  1516.         fIsProcessing = false;

  1517.         fTimeInfo.samplePos += frames;

  1518. 

  1519. #ifndef BUILD_BRIDGE

  1520.         // --------------------------------------------------------------------------------------------------------

  1521.         // Post-processing (dry/wet, volume and balance)

  1522. 

  1523.         {

  1524.             const bool doVolume  = (pData->hints & PLUGIN_CAN_VOLUME) != 0 && pData->postProc.volume != 1.0f;

  1525.             const bool doDryWet  = (pData->hints & PLUGIN_CAN_DRYWET) != 0 && pData->postProc.dryWet != 1.0f;

  1526.             const bool doBalance = (pData->hints & PLUGIN_CAN_BALANCE) != 0 && (pData->postProc.balanceLeft != -1.0f || pData->postProc.balanceRight != 1.0f);

  1527. 

  1528.             bool isPair;

  1529.             float bufValue, oldBufLeft[doBalance ? frames : 1];

  1530. 

  1531.             for (i=0; i < pData->audioOut.count; ++i)

  1532.             {

  1533.                 // Dry/Wet

  1534.                 if (doDryWet)

  1535.                 {

  1536.                     for (k=0; k < frames; ++k)

  1537.                     {

  1538.                         bufValue = inBuffer[(pData->audioIn.count == 1) ? 0 : i][k+timeOffset];

  1539.                         outBuffer[i][k+timeOffset] = (outBuffer[i][k+timeOffset] * pData->postProc.dryWet) + (bufValue * (1.0f - pData->postProc.dryWet));

  1540.                     }

  1541.                 }

  1542. 

  1543.                 // Balance

  1544.                 if (doBalance)

  1545.                 {

  1546.                     isPair = (i % 2 == 0);

  1547. 

  1548.                     if (isPair)

  1549.                     {

  1550.                         CARLA_ASSERT(i+1 < pData->audioOut.count);

  1551.                         FLOAT_COPY(oldBufLeft, outBuffer[i]+timeOffset, frames);

  1552.                     }

  1553. 

  1554.                     float balRangeL = (pData->postProc.balanceLeft  + 1.0f)/2.0f;

  1555.                     float balRangeR = (pData->postProc.balanceRight + 1.0f)/2.0f;

  1556. 

  1557.                     for (k=0; k < frames; ++k)

  1558.                     {

  1559.                         if (isPair)

  1560.                         {

  1561.                             // left

  1562.                             outBuffer[i][k+timeOffset]  = oldBufLeft[k]                * (1.0f - balRangeL);

  1563.                             outBuffer[i][k+timeOffset] += outBuffer[i+1][k+timeOffset] * (1.0f - balRangeR);

  1564.                         }

  1565.                         else

  1566.                         {

  1567.                             // right

  1568.                             outBuffer[i][k+timeOffset]  = outBuffer[i][k+timeOffset] * balRangeR;

  1569.                             outBuffer[i][k+timeOffset] += oldBufLeft[k]              * balRangeL;

  1570.                         }

  1571.                     }

  1572.                 }

  1573. 

  1574.                 // Volume

  1575.                 if (doVolume)

  1576.                 {

  1577.                     for (k=0; k < frames; ++k)

  1578.                         outBuffer[i][k+timeOffset] *= pData->postProc.volume;

  1579.                 }

  1580.             }

  1581. 

  1582.         } // End of Post-processing

  1583. #endif

  1584. 

  1585.         // --------------------------------------------------------------------------------------------------------

  1586. 

  1587.         pData->singleMutex.unlock();

  1588.         return true;

  1589.     }

  1590. 

  1591.     void bufferSizeChanged(const uint32_t newBufferSize) override

  1592.     {

  1593.         CARLA_ASSERT_INT(newBufferSize > 0, newBufferSize);

  1594.         carla_debug("VstPlugin::bufferSizeChanged(%i)", newBufferSize);

  1595. 

  1596.         if (pData->active)

  1597.             deactivate();

  1598. 

  1599. #if ! VST_FORCE_DEPRECATED

  1600.         dispatcher(effSetBlockSizeAndSampleRate, 0, newBufferSize, nullptr, pData->engine->getSampleRate());

  1601. #endif

  1602.         dispatcher(effSetBlockSize, 0, newBufferSize, nullptr, 0.0f);

  1603. 

  1604.         if (pData->active)

  1605.             activate();

  1606.     }

  1607. 

  1608.     void sampleRateChanged(const double newSampleRate) override

  1609.     {

  1610.         CARLA_ASSERT_INT(newSampleRate > 0.0, newSampleRate);

  1611.         carla_debug("VstPlugin::sampleRateChanged(%g)", newSampleRate);

  1612. 

  1613.         if (pData->active)

  1614.             deactivate();

  1615. 

  1616. #if ! VST_FORCE_DEPRECATED

  1617.         dispatcher(effSetBlockSizeAndSampleRate, 0, pData->engine->getBufferSize(), nullptr, newSampleRate);

  1618. #endif

  1619.         dispatcher(effSetSampleRate, 0, 0, nullptr, newSampleRate);

  1620. 

  1621.         if (pData->active)

  1622.             activate();

  1623.     }

  1624. 

  1625.     // -------------------------------------------------------------------

  1626.     // Plugin buffers

  1627. 

  1628.     // nothing

  1629. 

  1630.     // -------------------------------------------------------------------

  1631.     // Post-poned UI Stuff

  1632. 

  1633.     void uiParameterChange(const uint32_t index, const float value) override

  1634.     {

  1635.         CARLA_ASSERT(index < pData->param.count);

  1636. 

  1637.         if (index >= pData->param.count)

  1638.             return;

  1639.         if (! fGui.isOsc)

  1640.             return;

  1641.         if (pData->osc.data.target == nullptr)

  1642.             return;

  1643. 

  1644.         osc_send_control(pData->osc.data, pData->param.data[index].rindex, value);

  1645.     }

  1646. 

  1647.     void uiProgramChange(const uint32_t index) override

  1648.     {

  1649.         CARLA_ASSERT(index < pData->prog.count);

  1650. 

  1651.         if (index >= pData->prog.count)

  1652.             return;

  1653.         if (! fGui.isOsc)

  1654.             return;

  1655.         if (pData->osc.data.target == nullptr)

  1656.             return;

  1657. 

  1658.         osc_send_program(pData->osc.data, index);

  1659.     }

  1660. 

  1661.     void uiNoteOn(const uint8_t channel, const uint8_t note, const uint8_t velo) override

  1662.     {

  1663.         CARLA_ASSERT(channel < MAX_MIDI_CHANNELS);

  1664.         CARLA_ASSERT(note < MAX_MIDI_NOTE);

  1665.         CARLA_ASSERT(velo > 0 && velo < MAX_MIDI_VALUE);

  1666. 

  1667.         if (channel >= MAX_MIDI_CHANNELS)

  1668.             return;

  1669.         if (note >= MAX_MIDI_NOTE)

  1670.             return;

  1671.         if (velo >= MAX_MIDI_VALUE)

  1672.             return;

  1673.         if (! fGui.isOsc)

  1674.             return;

  1675.         if (pData->osc.data.target == nullptr)

  1676.             return;

  1677. 

  1678.         uint8_t midiData[4] = { 0 };

  1679.         midiData[1] = MIDI_STATUS_NOTE_ON + channel;

  1680.         midiData[2] = note;

  1681.         midiData[3] = velo;

  1682. 

  1683.         osc_send_midi(pData->osc.data, midiData);

  1684.     }

  1685. 

  1686.     void uiNoteOff(const uint8_t channel, const uint8_t note) override

  1687.     {

  1688.         CARLA_ASSERT(channel < MAX_MIDI_CHANNELS);

  1689.         CARLA_ASSERT(note < MAX_MIDI_NOTE);

  1690. 

  1691.         if (channel >= MAX_MIDI_CHANNELS)

  1692.             return;

  1693.         if (note >= MAX_MIDI_NOTE)

  1694.             return;

  1695.         if (! fGui.isOsc)

  1696.             return;

  1697.         if (pData->osc.data.target == nullptr)

  1698.             return;

  1699. 

  1700.         uint8_t midiData[4] = { 0 };

  1701.         midiData[1] = MIDI_STATUS_NOTE_OFF + channel;

  1702.         midiData[2] = note;

  1703. 

  1704.         osc_send_midi(pData->osc.data, midiData);

  1705.     }

  1706. 

  1707.     // -------------------------------------------------------------------

  1708. 

  1709. protected:

  1710. //     void guiClosedCallback() override

  1711. //     {

  1712. //         showGui(false);

  1713. //         pData->engine->callback(CALLBACK_SHOW_GUI, pData->id, 0, 0, 0.0f, nullptr);

  1714. //     }

  1715. 

  1716.     intptr_t dispatcher(int32_t opcode, int32_t index, intptr_t value, void* ptr, float opt) const

  1717.     {

  1718. #if defined(DEBUG) && ! defined(CARLA_OS_WIN)

  1719.         if (opcode != effEditIdle && opcode != effProcessEvents)

  1720.             carla_debug("VstPlugin::dispatcher(%02i:%s, %i, " P_INTPTR ", %p, %f)", opcode, vstEffectOpcode2str(opcode), index, value, ptr, opt);

  1721. #endif

  1722.         CARLA_ASSERT(fEffect != nullptr);

  1723. 

  1724.         return (fEffect != nullptr) ? fEffect->dispatcher(fEffect, opcode, index, value, ptr, opt) : 0;

  1725.     }

  1726. 

  1727.     intptr_t handleAudioMasterCallback(const int32_t opcode, const int32_t index, const intptr_t value, void* const ptr, const float opt)

  1728.     {

  1729. #if 0

  1730.         // Cockos VST extensions

  1731.         if (ptr != nullptr && static_cast<uint32_t>(opcode) == 0xdeadbeef && static_cast<uint32_t>(index) == 0xdeadf00d)

  1732.         {

  1733.             const char* const func = (char*)ptr;

  1734. 

  1735.             if (std::strcmp(func, "GetPlayPosition") == 0)

  1736.                 return 0;

  1737.             if (std::strcmp(func, "GetPlayPosition2") == 0)

  1738.                 return 0;

  1739.             if (std::strcmp(func, "GetCursorPosition") == 0)

  1740.                 return 0;

  1741.             if (std::strcmp(func, "GetPlayState") == 0)

  1742.                 return 0;

  1743.             if (std::strcmp(func, "SetEditCurPos") == 0)

  1744.                 return 0;

  1745.             if (std::strcmp(func, "GetSetRepeat") == 0)

  1746.                 return 0;

  1747.             if (std::strcmp(func, "GetProjectPath") == 0)

  1748.                 return 0;

  1749.             if (std::strcmp(func, "OnPlayButton") == 0)

  1750.                 return 0;

  1751.             if (std::strcmp(func, "OnStopButton") == 0)

  1752.                 return 0;

  1753.             if (std::strcmp(func, "OnPauseButton") == 0)

  1754.                 return 0;

  1755.             if (std::strcmp(func, "IsInRealTimeAudio") == 0)

  1756.                 return 0;

  1757.             if (std::strcmp(func, "Audio_IsRunning") == 0)

  1758.                 return 0;

  1759.         }

  1760. #endif

  1761. 

  1762.         intptr_t ret = 0;

  1763. 

  1764.         switch (opcode)

  1765.         {

  1766.         case audioMasterAutomate:

  1767.             if (! pData->enabled)

  1768.                 break;

  1769. 

  1770.             // plugins should never do this:

  1771.             CARLA_SAFE_ASSERT_INT(index < static_cast<int32_t>(pData->param.count), index);

  1772. 

  1773.             if (index < 0 || index >= static_cast<int32_t>(pData->param.count))

  1774.                 break;

  1775. 

  1776.             if (fGui.isVisible && ! fIsProcessing)

  1777.             {

  1778.                 // Called from GUI

  1779.                 setParameterValue(index, opt, false, true, true);

  1780.             }

  1781.             else if (fIsProcessing)

  1782.             {

  1783.                 // Called from engine

  1784.                 const float fixedValue(pData->param.getFixedValue(index, opt));

  1785. 

  1786.                 if (pData->engine->isOffline())

  1787.                 {

  1788.                     CarlaPlugin::setParameterValue(index, fixedValue, true, true, true);

  1789.                 }

  1790.                 else

  1791.                 {

  1792.                     CarlaPlugin::setParameterValue(index, fixedValue, false, false, false);

  1793.                     pData->postponeRtEvent(kPluginPostRtEventParameterChange, index, 0, fixedValue);

  1794.                 }

  1795.             }

  1796.             else

  1797.             {

  1798.                 carla_stdout("audioMasterAutomate called from unknown source");

  1799.             }

  1800.             break;

  1801. 

  1802.         case audioMasterCurrentId:

  1803.             // TODO

  1804.             // if using old sdk, return effect->uniqueID

  1805.             break;

  1806. 

  1807.         case audioMasterIdle:

  1808.             if (fGui.isVisible)

  1809.                 dispatcher(effEditIdle, 0, 0, nullptr, 0.0f);

  1810.             break;

  1811. 

  1812. #if ! VST_FORCE_DEPRECATED

  1813.         case audioMasterPinConnected:

  1814.             // Deprecated in VST SDK 2.4

  1815.             // TODO

  1816.             break;

  1817. 

  1818.         case audioMasterWantMidi:

  1819.             // Deprecated in VST SDK 2.4

  1820.             pData->hints |= PLUGIN_WANTS_MIDI_INPUT;

  1821.             break;

  1822. #endif

  1823. 

  1824.         case audioMasterGetTime:

  1825.             ret = (intptr_t)&fTimeInfo;

  1826.             break;

  1827. 

  1828.         case audioMasterProcessEvents:

  1829.             CARLA_ASSERT(pData->enabled);

  1830.             CARLA_ASSERT(fIsProcessing);

  1831.             CARLA_ASSERT(pData->event.portOut != nullptr);

  1832.             CARLA_ASSERT(ptr != nullptr);

  1833. 

  1834.             if (! pData->enabled)

  1835.                 return 0;

  1836.             if (! fIsProcessing)

  1837.                 return 0;

  1838.             if (pData->event.portOut == nullptr)

  1839.                 return 0;

  1840.             if (ptr == nullptr)

  1841.                 return 0;

  1842.             if (! fIsProcessing)

  1843.             {

  1844.                 carla_stderr2("audioMasterProcessEvents(%p) - received MIDI out events outside audio thread, ignoring", ptr);

  1845.                 return 0;

  1846.             }

  1847. 

  1848.             if (fMidiEventCount >= kPluginMaxMidiEvents*2)

  1849.                 return 0;

  1850. 

  1851. 

  1852.         {

  1853.             const VstEvents* const vstEvents((const VstEvents*)ptr);

  1854. 

  1855.             for (int32_t i=0; i < vstEvents->numEvents && i < kPluginMaxMidiEvents*2; ++i)

  1856.             {

  1857.                 if (vstEvents->events[i] == nullptr)

  1858.                     break;

  1859. 

  1860.                 const VstMidiEvent* const vstMidiEvent = (const VstMidiEvent*)vstEvents->events[i];

  1861. 

  1862.                 if (vstMidiEvent->type != kVstMidiType)

  1863.                     continue;

  1864. 

  1865.                 // reverse-find first free event, and put it there

  1866.                 for (uint32_t j=(kPluginMaxMidiEvents*2)-1; j >= fMidiEventCount; --j)

  1867.                 {

  1868.                     if (fMidiEvents[j].type == 0)

  1869.                     {

  1870.                         std::memcpy(&fMidiEvents[j], vstMidiEvent, sizeof(VstMidiEvent));

  1871.                         break;

  1872.                     }

  1873.                 }

  1874.             }

  1875.         }

  1876. 

  1877.             ret = 1;

  1878.             break;

  1879. 

  1880. #if ! VST_FORCE_DEPRECATED

  1881.         case audioMasterSetTime:

  1882.             // Deprecated in VST SDK 2.4

  1883.             break;

  1884. 

  1885.         case audioMasterTempoAt:

  1886.             // Deprecated in VST SDK 2.4

  1887.             CARLA_ASSERT(fIsProcessing);

  1888.             ret = fTimeInfo.tempo * 10000;

  1889.             break;

  1890. 

  1891.         case audioMasterGetNumAutomatableParameters:

  1892.             // Deprecated in VST SDK 2.4

  1893.             ret = carla_min<intptr_t>(0, fEffect->numParams, pData->engine->getOptions().maxParameters);

  1894.             break;

  1895. 

  1896.         case audioMasterGetParameterQuantization:

  1897.             // Deprecated in VST SDK 2.4

  1898.             ret = 1; // full single float precision

  1899.             break;

  1900. #endif

  1901. 

  1902. #if 0

  1903.         case audioMasterIOChanged:

  1904.             CARLA_ASSERT(pData->enabled);

  1905. 

  1906.             // TESTING

  1907. 

  1908.             if (! pData->enabled)

  1909.             {

  1910.                 ret = 1;

  1911.                 break;

  1912.             }

  1913. 

  1914.             if (x_engine->getOptions().processMode == PROCESS_MODE_CONTINUOUS_RACK)

  1915.             {

  1916.                 carla_stderr2("VstPlugin::handleAudioMasterIOChanged() - plugin asked IO change, but it's not supported in rack mode");

  1917.                 return 0;

  1918.             }

  1919. 

  1920.             engineProcessLock();

  1921.             m_enabled = false;

  1922.             engineProcessUnlock();

  1923. 

  1924.             if (m_active)

  1925.             {

  1926.                 effect->dispatcher(effect, effStopProcess, 0, 0, nullptr, 0.0f);

  1927.                 effect->dispatcher(effect, effMainsChanged, 0, 0, nullptr, 0.0f);

  1928.             }

  1929. 

  1930.             reload();

  1931. 

  1932.             if (m_active)

  1933.             {

  1934.                 effect->dispatcher(effect, effMainsChanged, 0, 1, nullptr, 0.0f);

  1935.                 effect->dispatcher(effect, effStartProcess, 0, 0, nullptr, 0.0f);

  1936.             }

  1937. 

  1938.             x_engine->callback(CALLBACK_RELOAD_ALL, m_id, 0, 0, 0.0, nullptr);

  1939. 

  1940.             ret = 1;

  1941.             break;

  1942. #endif

  1943. 

  1944.         case audioMasterNeedIdle:

  1945.             // Deprecated in VST SDK 2.4

  1946.             fNeedIdle = true;

  1947.             ret = 1;

  1948.             break;

  1949. 

  1950.         case audioMasterSizeWindow:

  1951.             //if (pData->gui != nullptr)

  1952.             {

  1953.                 CARLA_SAFE_ASSERT(fGui.isVisible);

  1954.                 //if (fGui.isVisible)

  1955.                 //    pData->gui->setSize(index, value);

  1956.                 ret = 1;

  1957.             }

  1958.             break;

  1959. 

  1960.         case audioMasterGetSampleRate:

  1961.             ret = pData->engine->getSampleRate();

  1962.             break;

  1963. 

  1964.         case audioMasterGetBlockSize:

  1965.             ret = pData->engine->getBufferSize();

  1966.             break;

  1967. 

  1968.         case audioMasterGetInputLatency:

  1969.             ret = 0;

  1970.             break;

  1971. 

  1972.         case audioMasterGetOutputLatency:

  1973.             ret = 0;

  1974.             break;

  1975. 

  1976. #if ! VST_FORCE_DEPRECATED

  1977.         case audioMasterGetPreviousPlug:

  1978.             // Deprecated in VST SDK 2.4

  1979.             // TODO

  1980.             break;

  1981. 

  1982.         case audioMasterGetNextPlug:

  1983.             // Deprecated in VST SDK 2.4

  1984.             // TODO

  1985.             break;

  1986. 

  1987.         case audioMasterWillReplaceOrAccumulate:

  1988.             // Deprecated in VST SDK 2.4

  1989.             ret = 1; // replace

  1990.             break;

  1991. #endif

  1992. 

  1993.         case audioMasterGetCurrentProcessLevel:

  1994.             if (pData->engine->isOffline())

  1995.                 ret = kVstProcessLevelOffline;

  1996.             else if (fIsProcessing)

  1997.                 ret = kVstProcessLevelRealtime;

  1998.             else

  1999.                 ret = kVstProcessLevelUser;

  2000.             break;

  2001. 

  2002.         case audioMasterGetAutomationState:

  2003.             ret = pData->active ? kVstAutomationReadWrite : kVstAutomationOff;

  2004.             break;

  2005. 

  2006.         case audioMasterOfflineStart:

  2007.         case audioMasterOfflineRead:

  2008.         case audioMasterOfflineWrite:

  2009.         case audioMasterOfflineGetCurrentPass:

  2010.         case audioMasterOfflineGetCurrentMetaPass:

  2011.             // TODO

  2012.             break;

  2013. 

  2014. #if ! VST_FORCE_DEPRECATED

  2015.         case audioMasterSetOutputSampleRate:

  2016.             // Deprecated in VST SDK 2.4

  2017.             break;

  2018. 

  2019.         case audioMasterGetOutputSpeakerArrangement:

  2020.             // Deprecated in VST SDK 2.4

  2021.             // TODO

  2022.             break;

  2023. #endif

  2024. 

  2025.         case audioMasterVendorSpecific:

  2026.             // TODO - cockos extensions

  2027.             break;

  2028. 

  2029. #if ! VST_FORCE_DEPRECATED

  2030.         case audioMasterSetIcon:

  2031.             // Deprecated in VST SDK 2.4

  2032.             break;

  2033. #endif

  2034. 

  2035. #if ! VST_FORCE_DEPRECATED

  2036.         case audioMasterOpenWindow:

  2037.         case audioMasterCloseWindow:

  2038.             // Deprecated in VST SDK 2.4

  2039.             // TODO

  2040.             break;

  2041. #endif

  2042. 

  2043.         case audioMasterGetDirectory:

  2044.             // TODO

  2045.             break;

  2046. 

  2047.         case audioMasterUpdateDisplay:

  2048.             // Idle UI if visible

  2049.             if (fGui.isVisible)

  2050.                 dispatcher(effEditIdle, 0, 0, nullptr, 0.0f);

  2051. 

  2052.             // Update current program

  2053.             if (pData->prog.count > 0)

  2054.             {

  2055.                 const int32_t current = dispatcher(effGetProgram, 0, 0, nullptr, 0.0f);

  2056. 

  2057.                 if (current >= 0 && current < static_cast<int32_t>(pData->prog.count))

  2058.                 {

  2059.                     char strBuf[STR_MAX+1]  = { '\0' };

  2060.                     dispatcher(effGetProgramName, 0, 0, strBuf, 0.0f);

  2061. 

  2062.                     if (pData->prog.names[current] != nullptr)

  2063.                         delete[] pData->prog.names[current];

  2064. 

  2065.                     pData->prog.names[current] = carla_strdup(strBuf);

  2066. 

  2067.                     if (pData->prog.current != current)

  2068.                     {

  2069.                         pData->prog.current = current;

  2070.                         pData->engine->callback(ENGINE_CALLBACK_PROGRAM_CHANGED, pData->id, current, 0, 0.0f, nullptr);

  2071.                     }

  2072.                 }

  2073.             }

  2074. 

  2075.             pData->engine->callback(ENGINE_CALLBACK_UPDATE, pData->id, 0, 0, 0.0f, nullptr);

  2076.             ret = 1;

  2077.             break;

  2078. 

  2079.         case audioMasterBeginEdit:

  2080.         case audioMasterEndEdit:

  2081.             // TODO

  2082.             break;

  2083. 

  2084.         case audioMasterOpenFileSelector:

  2085.         case audioMasterCloseFileSelector:

  2086.             // TODO

  2087.             break;

  2088. 

  2089. #if ! VST_FORCE_DEPRECATED

  2090.         case audioMasterEditFile:

  2091.             // Deprecated in VST SDK 2.4

  2092.             // TODO

  2093.             break;

  2094. 

  2095.         case audioMasterGetChunkFile:

  2096.             // Deprecated in VST SDK 2.4

  2097.             // TODO

  2098.             break;

  2099. 

  2100.         case audioMasterGetInputSpeakerArrangement:

  2101.             // Deprecated in VST SDK 2.4

  2102.             // TODO

  2103.             break;

  2104. #endif

  2105. 

  2106.         default:

  2107.             carla_debug("VstPlugin::handleAudioMasterCallback(%02i:%s, %i, " P_INTPTR ", %p, %f)", opcode, vstMasterOpcode2str(opcode), index, value, ptr, opt);

  2108.             break;

  2109.         }

  2110. 

  2111.         return ret;

  2112.     }

  2113. 

  2114.     // -------------------------------------------------------------------

  2115. 

  2116. public:

  2117.     bool init(const char* const filename, const char* const name)

  2118.     {

  2119.         CARLA_SAFE_ASSERT_RETURN(pData->engine != nullptr, false);

  2120. 

  2121.         // ---------------------------------------------------------------

  2122.         // first checks

  2123. 

  2124.         if (pData->client != nullptr)

  2125.         {

  2126.             pData->engine->setLastError("Plugin client is already registered");

  2127.             return false;

  2128.         }

  2129. 

  2130.         if (filename == nullptr || filename[0] == '\0')

  2131.         {

  2132.             pData->engine->setLastError("null filename");

  2133.             return false;

  2134.         }

  2135. 

  2136.         // ---------------------------------------------------------------

  2137.         // open DLL

  2138. 

  2139.         if (! pData->libOpen(filename))

  2140.         {

  2141.             pData->engine->setLastError(pData->libError(filename));

  2142.             return false;

  2143.         }

  2144. 

  2145.         // ---------------------------------------------------------------

  2146.         // get DLL main entry

  2147. 

  2148.         VST_Function vstFn = (VST_Function)pData->libSymbol("VSTPluginMain");

  2149. 

  2150.         if (vstFn == nullptr)

  2151.         {

  2152.             vstFn = (VST_Function)pData->libSymbol("main");

  2153. 

  2154.             if (vstFn == nullptr)

  2155.             {

  2156.                 pData->engine->setLastError("Could not find the VST main entry in the plugin library");

  2157.                 return false;

  2158.             }

  2159.         }

  2160. 

  2161.         // ---------------------------------------------------------------

  2162.         // initialize plugin (part 1)

  2163. 

  2164.         sLastVstPlugin = this;

  2165.         fEffect = vstFn(carla_vst_audioMasterCallback);

  2166.         sLastVstPlugin = nullptr;

  2167. 

  2168.         if (fEffect == nullptr)

  2169.         {

  2170.             pData->engine->setLastError("Plugin failed to initialize");

  2171.             return false;

  2172.         }

  2173. 

  2174.         if (fEffect->magic != kEffectMagic)

  2175.         {

  2176.             pData->engine->setLastError("Plugin is not valid (wrong vst effect magic code)");

  2177.             return false;

  2178.         }

  2179. 

  2180. #ifdef VESTIGE_HEADER

  2181.         fEffect->ptr1 = this;

  2182. #else

  2183.         fEffect->resvd1 = ToVstPtr<VstPlugin>(this);

  2184. #endif

  2185. 

  2186.         dispatcher(effOpen, 0, 0, nullptr, 0.0f);

  2187. 

  2188.         // ---------------------------------------------------------------

  2189.         // get info

  2190. 

  2191.         if (name != nullptr && name[0] != '\0')

  2192.         {

  2193.             pData->name = pData->engine->getUniquePluginName(name);

  2194.         }

  2195.         else

  2196.         {

  2197.             char strBuf[STR_MAX+1] = { '\0' };

  2198.             dispatcher(effGetEffectName, 0, 0, strBuf, 0.0f);

  2199. 

  2200.             if (strBuf[0] != '\0')

  2201.             {

  2202.                 pData->name = pData->engine->getUniquePluginName(strBuf);

  2203.             }

  2204.             else if (const char* const shortname = std::strrchr(filename, OS_SEP))

  2205.             {

  2206.                 pData->name = pData->engine->getUniquePluginName(shortname+1);

  2207.             }

  2208.             else

  2209.             {

  2210.                 pData->name = pData->engine->getUniquePluginName("unknown");

  2211.             }

  2212.         }

  2213. 

  2214.         pData->filename = filename;

  2215. 

  2216.         // ---------------------------------------------------------------

  2217.         // register client

  2218. 

  2219.         pData->client = pData->engine->addClient(this);

  2220. 

  2221.         if (pData->client == nullptr || ! pData->client->isOk())

  2222.         {

  2223.             pData->engine->setLastError("Failed to register plugin client");

  2224.             return false;

  2225.         }

  2226. 

  2227.         // ---------------------------------------------------------------

  2228.         // initialize plugin (part 2)

  2229. 

  2230. #if ! VST_FORCE_DEPRECATED

  2231.         dispatcher(effSetBlockSizeAndSampleRate, 0, pData->engine->getBufferSize(), nullptr, pData->engine->getSampleRate());

  2232. #endif

  2233.         dispatcher(effSetSampleRate, 0, 0, nullptr, pData->engine->getSampleRate());

  2234.         dispatcher(effSetBlockSize, 0, pData->engine->getBufferSize(), nullptr, 0.0f);

  2235.         dispatcher(effSetProcessPrecision, 0, kVstProcessPrecision32, nullptr, 0.0f);

  2236. 

  2237.         if (dispatcher(effGetVstVersion, 0, 0, nullptr, 0.0f) < kVstVersion)

  2238.             pData->hints |= PLUGIN_USES_OLD_VSTSDK;

  2239. 

  2240.         if (static_cast<uintptr_t>(dispatcher(effCanDo, 0, 0, (void*)"hasCockosExtensions", 0.0f)) == 0xbeef0000)

  2241.             pData->hints |= PLUGIN_HAS_COCKOS_EXTENSIONS;

  2242. 

  2243.         // ---------------------------------------------------------------

  2244.         // gui stuff

  2245. 

  2246.         if (fEffect->flags & effFlagsHasEditor)

  2247.         {

  2248.             const EngineOptions& engineOptions(pData->engine->getOptions());

  2249. 

  2250. // #if defined(Q_WS_X11)

  2251. //             CarlaString uiBridgeBinary(engineOptions.bridge_vstX11);

  2252. // #elif defined(CARLA_OS_MAC)

  2253. //             CarlaString uiBridgeBinary(engineOptions.bridge_vstMac);

  2254. // #elif defined(CARLA_OS_WIN)

  2255. //             CarlaString uiBridgeBinary(engineOptions.bridge_vstHWND);

  2256. // #else

  2257.             CarlaString uiBridgeBinary;

  2258. // #endif

  2259. 

  2260.             if (engineOptions.preferUiBridges && uiBridgeBinary.isNotEmpty() && (fEffect->flags & effFlagsProgramChunks) == 0)

  2261.             {

  2262.                 pData->osc.thread.setOscData(uiBridgeBinary, nullptr);

  2263.                 fGui.isOsc = true;

  2264.             }

  2265.         }

  2266. 

  2267.         // ---------------------------------------------------------------

  2268.         // load plugin settings

  2269. 

  2270.         {

  2271.             // set default options

  2272.             pData->options = 0x0;

  2273. 

  2274.             pData->options |= PLUGIN_OPTION_MAP_PROGRAM_CHANGES;

  2275. 

  2276.             if (getMidiInCount() > 0)

  2277.                 pData->options |= PLUGIN_OPTION_FIXED_BUFFERS;

  2278. 

  2279.             if (fEffect->flags & effFlagsProgramChunks)

  2280.                 pData->options |= PLUGIN_OPTION_USE_CHUNKS;

  2281. 

  2282.             if (vstPluginCanDo(fEffect, "receiveVstEvents") || vstPluginCanDo(fEffect, "receiveVstMidiEvent") || (fEffect->flags & effFlagsIsSynth) > 0 || (pData->hints & PLUGIN_WANTS_MIDI_INPUT))

  2283.             {

  2284.                 pData->options |= PLUGIN_OPTION_SEND_CHANNEL_PRESSURE;

  2285.                 pData->options |= PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH;

  2286.                 pData->options |= PLUGIN_OPTION_SEND_PITCHBEND;

  2287.                 pData->options |= PLUGIN_OPTION_SEND_ALL_SOUND_OFF;

  2288.             }

  2289. 

  2290.             // load settings

  2291.             pData->idStr  = "VST/";

  2292.             //pData->idStr += std::strrchr(filename, OS_SEP)+1; // FIXME!

  2293.             //pData->idStr += "/";

  2294.             pData->idStr += CarlaString(getUniqueId());

  2295.             pData->options = pData->loadSettings(pData->options, getOptionsAvailable());

  2296. 

  2297.             // ignore settings, we need this anyway

  2298.             if (getMidiInCount() > 0)

  2299.                 pData->options |= PLUGIN_OPTION_FIXED_BUFFERS;

  2300.         }

  2301. 

  2302.         return true;

  2303.     }

  2304. 

  2305. private:

  2306.     int fUnique1;

  2307.     AEffect* fEffect;

  2308. 

  2309.     void*         fLastChunk;

  2310.     uint32_t      fMidiEventCount;

  2311.     VstMidiEvent  fMidiEvents[kPluginMaxMidiEvents*2];

  2312.     VstTimeInfo_R fTimeInfo;

  2313. 

  2314.     struct FixedVstEvents {

  2315.         int32_t numEvents;

  2316.         intptr_t reserved;

  2317.         VstEvent* data[kPluginMaxMidiEvents*2];

  2318. 

  2319.         FixedVstEvents()

  2320.             : numEvents(0),

  2321. #ifdef CARLA_PROPER_CPP11_SUPPORT

  2322.               reserved(0),

  2323.               data{nullptr} {}

  2324. #else

  2325.               reserved(0)

  2326.         {

  2327.             carla_fill<VstEvent*>(data, kPluginMaxMidiEvents*2, nullptr);

  2328.         }

  2329. #endif

  2330.     } fEvents;

  2331. 

  2332.     struct GuiInfo {

  2333.         bool isOsc;

  2334.         bool isVisible;

  2335.         int  lastWidth;

  2336.         int  lastHeight;

  2337. 

  2338.         GuiInfo()

  2339.             : isOsc(false),

  2340.               isVisible(false),

  2341.               lastWidth(0),

  2342.               lastHeight(0) {}

  2343.     } fGui;

  2344. 

  2345.     bool fIsProcessing;

  2346.     bool fNeedIdle;

  2347.     int  fUnique2;

  2348. 

  2349.     static VstPlugin* sLastVstPlugin;

  2350. 

  2351.     // -------------------------------------------------------------------

  2352. 

  2353.     static intptr_t carla_vst_hostCanDo(const char* const feature)

  2354.     {

  2355.         carla_debug("carla_vst_hostCanDo(\"%s\")", feature);

  2356. 

  2357.         if (std::strcmp(feature, "supplyIdle") == 0)

  2358.             return 1;

  2359.         if (std::strcmp(feature, "sendVstEvents") == 0)

  2360.             return 1;

  2361.         if (std::strcmp(feature, "sendVstMidiEvent") == 0)

  2362.             return 1;

  2363.         if (std::strcmp(feature, "sendVstMidiEventFlagIsRealtime") == 0)

  2364.             return 1;

  2365.         if (std::strcmp(feature, "sendVstTimeInfo") == 0)

  2366.             return 1;

  2367.         if (std::strcmp(feature, "receiveVstEvents") == 0)

  2368.             return 1;

  2369.         if (std::strcmp(feature, "receiveVstMidiEvent") == 0)

  2370.             return 1;

  2371.         if (std::strcmp(feature, "receiveVstTimeInfo") == 0)

  2372.             return -1;

  2373.         if (std::strcmp(feature, "reportConnectionChanges") == 0)

  2374.             return -1;

  2375.         if (std::strcmp(feature, "acceptIOChanges") == 0)

  2376.             return 1;

  2377.         if (std::strcmp(feature, "sizeWindow") == 0)

  2378.             return 1;

  2379.         if (std::strcmp(feature, "offline") == 0)

  2380.             return -1;

  2381.         if (std::strcmp(feature, "openFileSelector") == 0)

  2382.             return -1;

  2383.         if (std::strcmp(feature, "closeFileSelector") == 0)

  2384.             return -1;

  2385.         if (std::strcmp(feature, "startStopProcess") == 0)

  2386.             return 1;

  2387.         if (std::strcmp(feature, "supportShell") == 0)

  2388.             return -1;

  2389.         if (std::strcmp(feature, "shellCategory") == 0)

  2390.             return -1;

  2391. 

  2392.         // unimplemented

  2393.         carla_stderr("carla_vst_hostCanDo(\"%s\") - unknown feature", feature);

  2394.         return 0;

  2395.     }

  2396. 

  2397.     static intptr_t VSTCALLBACK carla_vst_audioMasterCallback(AEffect* effect, int32_t opcode, int32_t index, intptr_t value, void* ptr, float opt)

  2398.     {

  2399. #if defined(DEBUG) && ! defined(CARLA_OS_WIN)

  2400.         if (opcode != audioMasterGetTime && opcode != audioMasterProcessEvents && opcode != audioMasterGetCurrentProcessLevel && opcode != audioMasterGetOutputLatency)

  2401.             carla_debug("carla_vst_audioMasterCallback(%p, %02i:%s, %i, " P_INTPTR ", %p, %f)", effect, opcode, vstMasterOpcode2str(opcode), index, value, ptr, opt);

  2402. #endif

  2403. 

  2404.         switch (opcode)

  2405.         {

  2406.         case audioMasterVersion:

  2407.             return kVstVersion;

  2408. 

  2409.         case audioMasterGetVendorString:

  2410.             CARLA_ASSERT(ptr != nullptr);

  2411. 

  2412.             if (ptr != nullptr)

  2413.             {

  2414.                 std::strcpy((char*)ptr, "falkTX");

  2415.                 return 1;

  2416.             }

  2417.             else

  2418.             {

  2419.                 carla_stderr("carla_vst_audioMasterCallback() - audioMasterGetVendorString called with invalid pointer");

  2420.                 return 0;

  2421.             }

  2422. 

  2423.         case audioMasterGetProductString:

  2424.             CARLA_ASSERT(ptr != nullptr);

  2425. 

  2426.             if (ptr != nullptr)

  2427.             {

  2428.                 std::strcpy((char*)ptr, "Carla");

  2429.                 return 1;

  2430.             }

  2431.             else

  2432.             {

  2433.                 carla_stderr("carla_vst_audioMasterCallback() - audioMasterGetProductString called with invalid pointer");

  2434.                 return 0;

  2435.             }

  2436. 

  2437.         case audioMasterGetVendorVersion:

  2438.             return 0x110; // 1.1.0

  2439. 

  2440.         case audioMasterCanDo:

  2441.             CARLA_ASSERT(ptr != nullptr);

  2442. 

  2443.             if (ptr != nullptr)

  2444.             {

  2445.                 return carla_vst_hostCanDo((const char*)ptr);

  2446.             }

  2447.             else

  2448.             {

  2449.                 carla_stderr("carla_vst_audioMasterCallback() - audioMasterCanDo called with invalid pointer");

  2450.                 return 0;

  2451.             }

  2452. 

  2453.         case audioMasterGetLanguage:

  2454.             return kVstLangEnglish;

  2455.         }

  2456. 

  2457.         // Check if 'resvd1' points to us, otherwise register ourselfs if possible

  2458.         VstPlugin* self = nullptr;

  2459. 

  2460.         if (effect != nullptr)

  2461.         {

  2462. #ifdef VESTIGE_HEADER

  2463.             if (effect->ptr1 != nullptr)

  2464.             {

  2465.                 self = (VstPlugin*)effect->ptr1;

  2466. #else

  2467.             if (effect->resvd1 != 0)

  2468.             {

  2469.                 self = FromVstPtr<VstPlugin>(effect->resvd1);

  2470. #endif

  2471.                 if (self->fUnique1 != self->fUnique2)

  2472.                     self = nullptr;

  2473.             }

  2474. 

  2475.             if (self != nullptr)

  2476.             {

  2477.                 if (self->fEffect == nullptr)

  2478.                     self->fEffect = effect;

  2479. 

  2480.                 if (self->fEffect != effect)

  2481.                 {

  2482.                     carla_stderr2("carla_vst_audioMasterCallback() - host pointer mismatch: %p != %p", self->fEffect, effect);

  2483.                     self = nullptr;

  2484.                 }

  2485.             }

  2486.             else if (sLastVstPlugin != nullptr)

  2487.             {

  2488. #ifdef VESTIGE_HEADER

  2489.                 effect->ptr1 = sLastVstPlugin;

  2490. #else

  2491.                 effect->resvd1 = ToVstPtr<VstPlugin>(sLastVstPlugin);

  2492. #endif

  2493.                 self = sLastVstPlugin;

  2494.             }

  2495.         }

  2496. 

  2497.         return (self != nullptr) ? self->handleAudioMasterCallback(opcode, index, value, ptr, opt) : 0;

  2498.     }

  2499. 

  2500.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(VstPlugin)

  2501. };

  2502. 

  2503. VstPlugin* VstPlugin::sLastVstPlugin = nullptr;

  2504. 

  2505. CARLA_BACKEND_END_NAMESPACE

  2506. 

  2507. #endif // WANT_VST

  2508. 

  2509. CARLA_BACKEND_START_NAMESPACE

  2510. 

  2511. CarlaPlugin* CarlaPlugin::newVST(const Initializer& init)

  2512. {

  2513.     carla_debug("CarlaPlugin::newVST({%p, \"%s\", \"%s\"})", init.engine, init.filename, init.name);

  2514. 

  2515. #ifdef WANT_VST

  2516. # if defined(HAVE_JUCE) && ! defined(VESTIGE_HEADER)

  2517.     return newJuce(init, "VST");

  2518. # else

  2519.     VstPlugin* const plugin(new VstPlugin(init.engine, init.id));

  2520. 

  2521.     if (! plugin->init(init.filename, init.name))

  2522.     {

  2523.         delete plugin;

  2524.         return nullptr;

  2525.     }

  2526. 

  2527.     plugin->reload();

  2528. 

  2529.     if (init.engine->getProccessMode() == ENGINE_PROCESS_MODE_CONTINUOUS_RACK && ! plugin->canRunInRack())

  2530.     {

  2531.         init.engine->setLastError("Carla's rack mode can only work with Stereo VST plugins, sorry!");

  2532.         delete plugin;

  2533.         return nullptr;

  2534.     }

  2535. 

  2536.     return plugin;

  2537. # endif

  2538. #else

  2539.     init.engine->setLastError("VST support not available");

  2540.     return nullptr;

  2541. #endif

  2542. }

  2543. 

  2544. CARLA_BACKEND_END_NAMESPACE