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.
865 Commits
16 Branches
229MB
Tree: 391cfa03d6
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '391cfa03d6'
${ noResults }
Carla/source/backend/plugin/VstPlugin.cpp

2567 lines
82KB
Raw Blame History 

  1. /*

  2.  * Carla VST Plugin

  3.  * Copyright (C) 2011-2013 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. 

  20. #ifdef WANT_VST

  21. 

  22. #include "CarlaPluginGui.hpp"

  23. #include "CarlaVstUtils.hpp"

  24. 

  25. //#ifdef Q_WS_X11

  26. //# include <QtGui/QX11Info>

  27. //#endif

  28. 

  29. CARLA_BACKEND_START_NAMESPACE

  30. 

  31. #if 0

  32. }

  33. #endif

  34. 

  35. /*!

  36.  * @defgroup PluginHints Plugin Hints

  37.  * @{

  38.  */

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

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

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

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

  43. /**@}*/

  44. 

  45. class VstPlugin : public CarlaPlugin,

  46.                   public CarlaPluginGui::Callback

  47. {

  48. public:

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

  50.         : CarlaPlugin(engine, id),

  51.           fUnique1(1),

  52.           fEffect(nullptr),

  53.           fLastChunk(nullptr),

  54.           fMidiEventCount(0),

  55.           fIsProcessing(false),

  56.           fNeedIdle(false),

  57.           fUnique2(2)

  58.     {

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

  60. 

  61.         carla_zeroStruct<VstMidiEvent>(fMidiEvents, MAX_MIDI_EVENTS*2);

  62.         carla_zeroStruct<VstTimeInfo_R>(fTimeInfo);

  63. 

  64.         for (unsigned short i=0; i < MAX_MIDI_EVENTS*2; ++i)

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

  66. 

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

  68. 

  69.         // make plugin valid

  70.         srand(id);

  71.         fUnique1 = fUnique2 = rand();

  72.     }

  73. 

  74.     ~VstPlugin() override

  75.     {

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

  77. 

  78.         // close UI

  79.         if (fHints & PLUGIN_HAS_GUI)

  80.         {

  81.             showGui(false);

  82. 

  83.             if (fGui.isOsc)

  84.             {

  85.                 pData->osc.thread.stopThread(pData->engine->getOptions().uiBridgesTimeout);

  86.             }

  87.         }

  88. 

  89.         pData->singleMutex.lock();

  90.         pData->masterMutex.lock();

  91. 

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

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

  94. 

  95.         CARLA_ASSERT(! fIsProcessing);

  96. 

  97.         if (pData->active)

  98.         {

  99.             deactivate();

  100.             pData->active = false;

  101.         }

  102. 

  103.         if (fEffect != nullptr)

  104.         {

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

  106.             fEffect = nullptr;

  107.         }

  108. 

  109.         // make plugin invalid

  110.         fUnique2 += 1;

  111. 

  112.         if (fLastChunk != nullptr)

  113.         {

  114.             std::free(fLastChunk);

  115.             fLastChunk = nullptr;

  116.         }

  117. 

  118.         clearBuffers();

  119.     }

  120. 

  121.     // -------------------------------------------------------------------

  122.     // Information (base)

  123. 

  124.     PluginType getType() const noexcept override

  125.     {

  126.         return PLUGIN_VST;

  127.     }

  128. 

  129.     PluginCategory getCategory() const override

  130.     {

  131.         CARLA_ASSERT(fEffect != nullptr);

  132. 

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

  134. 

  135.         switch (category)

  136.         {

  137.         case kPlugCategSynth:

  138.             return PLUGIN_CATEGORY_SYNTH;

  139.         case kPlugCategAnalysis:

  140.             return PLUGIN_CATEGORY_UTILITY;

  141.         case kPlugCategMastering:

  142.             return PLUGIN_CATEGORY_DYNAMICS;

  143.         case kPlugCategRoomFx:

  144.             return PLUGIN_CATEGORY_DELAY;

  145.         case kPlugCategRestoration:

  146.             return PLUGIN_CATEGORY_UTILITY;

  147.         case kPlugCategGenerator:

  148.             return PLUGIN_CATEGORY_SYNTH;

  149.         }

  150. 

  151.         if (fEffect->flags & effFlagsIsSynth)

  152.             return PLUGIN_CATEGORY_SYNTH;

  153. 

  154.         return getPluginCategoryFromName(fName);

  155.     }

  156. 

  157.     long getUniqueId() const override

  158.     {

  159.         CARLA_ASSERT(fEffect != nullptr);

  160. 

  161.         return fEffect->uniqueID;

  162.     }

  163. 

  164.     // -------------------------------------------------------------------

  165.     // Information (count)

  166. 

  167.     // nothing

  168. 

  169.     // -------------------------------------------------------------------

  170.     // Information (current data)

  171. 

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

  173.     {

  174.         CARLA_ASSERT(fOptions & PLUGIN_OPTION_USE_CHUNKS);

  175.         CARLA_ASSERT(fEffect != nullptr);

  176.         CARLA_ASSERT(dataPtr != nullptr);

  177. 

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

  179.     }

  180. 

  181.     // -------------------------------------------------------------------

  182.     // Information (per-plugin data)

  183. 

  184.     unsigned int getAvailableOptions() const override

  185.     {

  186.         CARLA_ASSERT(fEffect != nullptr);

  187. 

  188.         if (fEffect == nullptr)

  189.             return 0x0;

  190. 

  191.         unsigned int options = 0x0;

  192. 

  193.         options |= PLUGIN_OPTION_MAP_PROGRAM_CHANGES;

  194. 

  195.         if (getMidiInCount() == 0)

  196.             options |= PLUGIN_OPTION_FIXED_BUFFER;

  197. 

  198.         if (fEffect->flags & effFlagsProgramChunks)

  199.             options |= PLUGIN_OPTION_USE_CHUNKS;

  200. 

  201.         if (vstPluginCanDo(fEffect, "receiveVstEvents") || vstPluginCanDo(fEffect, "receiveVstMidiEvent") || (fEffect->flags & effFlagsIsSynth) > 0 || (fHints & PLUGIN_WANTS_MIDI_INPUT))

  202.         {

  203.             options |= PLUGIN_OPTION_SEND_CONTROL_CHANGES;

  204.             options |= PLUGIN_OPTION_SEND_CHANNEL_PRESSURE;

  205.             options |= PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH;

  206.             options |= PLUGIN_OPTION_SEND_PITCHBEND;

  207.             options |= PLUGIN_OPTION_SEND_ALL_SOUND_OFF;

  208.         }

  209. 

  210.         return options;

  211.     }

  212. 

  213.     float getParameterValue(const uint32_t parameterId) const override

  214.     {

  215.         CARLA_ASSERT(fEffect != nullptr);

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

  217. 

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

  219.     }

  220. 

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

  222.     {

  223.         CARLA_ASSERT(fEffect != nullptr);

  224. 

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

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

  227.     }

  228. 

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

  230.     {

  231.         CARLA_ASSERT(fEffect != nullptr);

  232. 

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

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

  235.     }

  236. 

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

  238.     {

  239.         CARLA_ASSERT(fEffect != nullptr);

  240. 

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

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

  243.     }

  244. 

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

  246.     {

  247.         CARLA_ASSERT(fEffect != nullptr);

  248. 

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

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

  251.     }

  252. 

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

  254.     {

  255.         CARLA_ASSERT(fEffect != nullptr);

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

  257. 

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

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

  260.     }

  261. 

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

  263.     {

  264.         CARLA_ASSERT(fEffect != nullptr);

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

  266. 

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

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

  269. 

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

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

  272.     }

  273. 

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

  275.     {

  276.         CARLA_ASSERT(fEffect != nullptr);

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

  278. 

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

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

  281.     }

  282. 

  283.     // -------------------------------------------------------------------

  284.     // Set data (state)

  285. 

  286.     // nothing

  287. 

  288.     // -------------------------------------------------------------------

  289.     // Set data (internal stuff)

  290. 

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

  292.     {

  293.         CarlaPlugin::setName(newName);

  294. 

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

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

  297.     }

  298. 

  299.     // -------------------------------------------------------------------

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

  301. 

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

  303.     {

  304.         CARLA_ASSERT(fEffect != nullptr);

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

  306. 

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

  308. 

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

  310. 

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

  312.     }

  313. 

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

  315.     {

  316.         CARLA_ASSERT(fOptions & PLUGIN_OPTION_USE_CHUNKS);

  317.         CARLA_ASSERT(fEffect != nullptr);

  318.         CARLA_ASSERT(stringData != nullptr);

  319. 

  320.         if (fLastChunk != nullptr)

  321.         {

  322.             std::free(fLastChunk);

  323.             fLastChunk = nullptr;

  324.         }

  325. 

  326.         QByteArray chunk(QByteArray::fromBase64(stringData));

  327. 

  328.         CARLA_ASSERT(chunk.size() > 0);

  329. 

  330.         if (chunk.size() > 0)

  331.         {

  332.             fLastChunk = std::malloc(chunk.size());

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

  334. 

  335.             {

  336.                 const ScopedSingleProcessLocker spl(this, true);

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

  338.             }

  339. 

  340.             // simulate an updateDisplay callback

  341.             handleAudioMasterCallback(audioMasterUpdateDisplay, 0, 0, nullptr, 0.0f);

  342.         }

  343.     }

  344. 

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

  346.     {

  347.         CARLA_ASSERT(fEffect != nullptr);

  348.         CARLA_ASSERT(index >= -1 && index < static_cast<int32_t>(pData->prog.count));

  349. 

  350.         if (index < -1)

  351.             index = -1;

  352.         else if (index > static_cast<int32_t>(pData->prog.count))

  353.             return;

  354. 

  355.         if (index >= 0)

  356.         {

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

  358. 

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

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

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

  362.         }

  363. 

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

  365.     }

  366. 

  367.     // -------------------------------------------------------------------

  368.     // Set gui stuff

  369. 

  370.     void showGui(const bool yesNo) override

  371.     {

  372.         if (fGui.isVisible == yesNo)

  373.             return;

  374. 

  375.         if (fGui.isOsc)

  376.         {

  377.             if (yesNo)

  378.             {

  379.                 pData->osc.thread.startThread();

  380.             }

  381.             else

  382.             {

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

  384.                 {

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

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

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

  388.                 }

  389. 

  390.                 pData->osc.thread.stopThread(pData->engine->getOptions().uiBridgesTimeout);

  391.             }

  392.         }

  393.         else

  394.         {

  395.             if (yesNo)

  396.             {

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

  398. 

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

  400.                 {

  401.                     CarlaPluginGui::Options guiOptions;

  402.                     guiOptions.parented  = true;

  403.                     guiOptions.resizable = false;

  404. 

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

  406.                 }

  407. 

  408.                 int32_t value = 0;

  409. #ifdef Q_WS_X11

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

  411. #endif

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

  413. 

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

  415.                 {

  416.                     ERect* vstRect = nullptr;

  417. 

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

  419. 

  420.                     if (vstRect != nullptr)

  421.                     {

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

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

  424. 

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

  426. 

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

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

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

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

  431.                     }

  432. 

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

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

  435.                 }

  436.                 else

  437.                 {

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

  439.                     {

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

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

  442.                         delete pData->gui;

  443.                         pData->gui = nullptr;

  444.                     }

  445. 

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

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

  448.                     return;

  449.                 }

  450.             }

  451.             else

  452.             {

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

  454. 

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

  456. 

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

  458.                 {

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

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

  461. 

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

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

  464.                     delete pData->gui;

  465.                     pData->gui = nullptr;

  466.                 }

  467.             }

  468.         }

  469. 

  470.         fGui.isVisible = yesNo;

  471.     }

  472. 

  473.     void idleGui() override

  474.     {

  475. #ifdef VESTIGE_HEADER

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

  477. #else

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

  479. #endif

  480.         {

  481.             if (fNeedIdle)

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

  483. 

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

  485.             {

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

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

  488.             }

  489.         }

  490. 

  491.         CarlaPlugin::idleGui();

  492.     }

  493. 

  494.     // -------------------------------------------------------------------

  495.     // Plugin state

  496. 

  497.     void reload() override

  498.     {

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

  500.         CARLA_ASSERT(pData->engine != nullptr);

  501.         CARLA_ASSERT(fEffect != nullptr);

  502. 

  503.         if (pData->engine == nullptr)

  504.             return;

  505.         if (fEffect == nullptr)

  506.             return;

  507. 

  508.         const ProcessMode processMode(pData->engine->getProccessMode());

  509. 

  510.         // Safely disable plugin for reload

  511.         const ScopedDisabler sd(this);

  512. 

  513.         if (pData->active)

  514.             deactivate();

  515. 

  516.         clearBuffers();

  517. 

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

  519. 

  520.         bool needsCtrlIn, needsCtrlOut;

  521.         needsCtrlIn = needsCtrlOut = false;

  522. 

  523.         aIns   = fEffect->numInputs;

  524.         aOuts  = fEffect->numOutputs;

  525.         params = fEffect->numParams;

  526. 

  527.         if (vstPluginCanDo(fEffect, "receiveVstEvents") || vstPluginCanDo(fEffect, "receiveVstMidiEvent") || (fEffect->flags & effFlagsIsSynth) > 0 || (fHints & PLUGIN_WANTS_MIDI_INPUT))

  528.         {

  529.             mIns = 1;

  530.             needsCtrlIn = true;

  531.         }

  532.         else

  533.             mIns = 0;

  534. 

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

  536.         {

  537.             mOuts = 1;

  538.             needsCtrlOut = true;

  539.         }

  540.         else

  541.             mOuts = 0;

  542. 

  543.         if (aIns > 0)

  544.         {

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

  546.         }

  547. 

  548.         if (aOuts > 0)

  549.         {

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

  551.             needsCtrlIn = true;

  552.         }

  553. 

  554.         if (params > 0)

  555.         {

  556.             pData->param.createNew(params);

  557.             needsCtrlIn = true;

  558.         }

  559. 

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

  561.         CarlaString portName;

  562. 

  563.         // Audio Ins

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

  565.         {

  566.             portName.clear();

  567. 

  568.             if (processMode == PROCESS_MODE_SINGLE_CLIENT)

  569.             {

  570.                 portName  = fName;

  571.                 portName += ":";

  572.             }

  573. 

  574.             if (aIns > 1)

  575.             {

  576.                 portName += "input_";

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

  578.             }

  579.             else

  580.                 portName += "input";

  581. 

  582.             portName.truncate(portNameSize);

  583. 

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

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

  586.         }

  587. 

  588.         // Audio Outs

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

  590.         {

  591.             portName.clear();

  592. 

  593.             if (processMode == PROCESS_MODE_SINGLE_CLIENT)

  594.             {

  595.                 portName  = fName;

  596.                 portName += ":";

  597.             }

  598. 

  599.             if (aOuts > 1)

  600.             {

  601.                 portName += "output_";

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

  603.             }

  604.             else

  605.                 portName += "output";

  606. 

  607.             portName.truncate(portNameSize);

  608. 

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

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

  611.         }

  612. 

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

  614.         {

  615.             pData->param.data[j].type   = PARAMETER_INPUT;

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

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

  618.             pData->param.data[j].hints  = 0x0;

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

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

  621. 

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

  623. 

  624.             VstParameterProperties prop;

  625.             carla_zeroStruct<VstParameterProperties>(prop);

  626. 

  627.             if (fHints & PLUGIN_HAS_COCKOS_EXTENSIONS)

  628.             {

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

  630. 

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

  632.                 {

  633.                     min = range[0];

  634.                     max = range[1];

  635. 

  636.                     if (min > max)

  637.                         max = min;

  638.                     else if (max < min)

  639.                         min = max;

  640. 

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

  642.                     {

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

  644.                         max = min + 0.1f;

  645.                     }

  646.                 }

  647.                 else

  648.                 {

  649.                     min = 0.0f;

  650.                     max = 1.0f;

  651.                 }

  652. 

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

  654.                 {

  655.                     step = 1.0f;

  656.                     stepSmall = 1.0f;

  657.                     stepLarge = 10.0f;

  658.                 }

  659.                 else

  660.                 {

  661.                     float range = max - min;

  662.                     step = range/100.0f;

  663.                     stepSmall = range/1000.0f;

  664.                     stepLarge = range/10.0f;

  665.                 }

  666.             }

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

  668.             {

  669.                 if (prop.flags & kVstParameterUsesIntegerMinMax)

  670.                 {

  671.                     min = float(prop.minInteger);

  672.                     max = float(prop.maxInteger);

  673. 

  674.                     if (min > max)

  675.                         max = min;

  676.                     else if (max < min)

  677.                         min = max;

  678. 

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

  680.                     {

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

  682.                         max = min + 0.1f;

  683.                     }

  684.                 }

  685.                 else

  686.                 {

  687.                     min = 0.0f;

  688.                     max = 1.0f;

  689.                 }

  690. 

  691.                 if (prop.flags & kVstParameterIsSwitch)

  692.                 {

  693.                     step = max - min;

  694.                     stepSmall = step;

  695.                     stepLarge = step;

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

  697.                 }

  698.                 else if (prop.flags & kVstParameterUsesIntStep)

  699.                 {

  700.                     step = float(prop.stepInteger);

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

  702.                     stepLarge = float(prop.largeStepInteger);

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

  704.                 }

  705.                 else if (prop.flags & kVstParameterUsesFloatStep)

  706.                 {

  707.                     step = prop.stepFloat;

  708.                     stepSmall = prop.smallStepFloat;

  709.                     stepLarge = prop.largeStepFloat;

  710.                 }

  711.                 else

  712.                 {

  713.                     float range = max - min;

  714.                     step = range/100.0f;

  715.                     stepSmall = range/1000.0f;

  716.                     stepLarge = range/10.0f;

  717.                 }

  718. 

  719.                 if (prop.flags & kVstParameterCanRamp)

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

  721.             }

  722.             else

  723.             {

  724.                 min = 0.0f;

  725.                 max = 1.0f;

  726.                 step = 0.001f;

  727.                 stepSmall = 0.0001f;

  728.                 stepLarge = 0.1f;

  729.             }

  730. 

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

  732. #ifndef BUILD_BRIDGE

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

  734. #endif

  735. 

  736.             if ((fHints & PLUGIN_USES_OLD_VSTSDK) != 0 || dispatcher(effCanBeAutomated, j, 0, nullptr, 0.0f) == 1)

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

  738. 

  739.             // no such thing as VST default parameters

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

  741. 

  742.             if (def < min)

  743.                 def = min;

  744.             else if (def > max)

  745.                 def = max;

  746. 

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

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

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

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

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

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

  753.         }

  754. 

  755.         if (needsCtrlIn)

  756.         {

  757.             portName.clear();

  758. 

  759.             if (processMode == PROCESS_MODE_SINGLE_CLIENT)

  760.             {

  761.                 portName  = fName;

  762.                 portName += ":";

  763.             }

  764. 

  765.             portName += "events-in";

  766.             portName.truncate(portNameSize);

  767. 

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

  769.         }

  770. 

  771.         if (needsCtrlOut)

  772.         {

  773.             portName.clear();

  774. 

  775.             if (processMode == PROCESS_MODE_SINGLE_CLIENT)

  776.             {

  777.                 portName  = fName;

  778.                 portName += ":";

  779.             }

  780. 

  781.             portName += "events-out";

  782.             portName.truncate(portNameSize);

  783. 

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

  785.         }

  786. 

  787.         // plugin hints

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

  789. 

  790.         fHints = 0x0;

  791. 

  792.         if (vstCategory == kPlugCategSynth || vstCategory == kPlugCategGenerator)

  793.             fHints |= PLUGIN_IS_SYNTH;

  794. 

  795.         if (fEffect->flags & effFlagsHasEditor)

  796.         {

  797.             fHints |= PLUGIN_HAS_GUI;

  798. 

  799.             if (! fGui.isOsc)

  800.                 fHints |= PLUGIN_HAS_SINGLE_THREAD;

  801.         }

  802. 

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

  804.             fHints |= PLUGIN_USES_OLD_VSTSDK;

  805. 

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

  807.             fHints |= PLUGIN_CAN_PROCESS_REPLACING;

  808. 

  809.         if (fEffect->flags & effFlagsHasEditor)

  810.             fHints |= PLUGIN_HAS_GUI;

  811. 

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

  813.             fHints |= PLUGIN_HAS_COCKOS_EXTENSIONS;

  814. 

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

  816.             fHints |= PLUGIN_CAN_DRYWET;

  817. 

  818.         if (aOuts > 0)

  819.             fHints |= PLUGIN_CAN_VOLUME;

  820. 

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

  822.             fHints |= PLUGIN_CAN_BALANCE;

  823. 

  824.         // extra plugin hints

  825.         pData->extraHints = 0x0;

  826. 

  827.         if (mIns > 0)

  828.             pData->extraHints |= PLUGIN_HINT_HAS_MIDI_IN;

  829. 

  830.         if (mOuts > 0)

  831.             pData->extraHints |= PLUGIN_HINT_HAS_MIDI_OUT;

  832. 

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

  834.             pData->extraHints |= PLUGIN_HINT_CAN_RUN_RACK;

  835. 

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

  837.         {

  838.             activate();

  839.             deactivate();

  840.         }

  841. 

  842.         // check latency

  843.         if (fHints & PLUGIN_CAN_DRYWET)

  844.         {

  845. #ifdef VESTIGE_HEADER

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

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

  848.             pData->latency = *initialDelayPtr;

  849. #else

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

  851. #endif

  852. 

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

  854.             pData->recreateLatencyBuffers();

  855.         }

  856. 

  857.         // special plugin fixes

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

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

  860.         {

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

  862.             getLabel(strBuf);

  863. 

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

  865.             {

  866.                 // TODO - disable threaded processing

  867.             }

  868.         }

  869. 

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

  871.         reloadPrograms(true);

  872. 

  873.         if (pData->active)

  874.             activate();

  875. 

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

  877.     }

  878. 

  879.     void reloadPrograms(const bool init) override

  880.     {

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

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

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

  884. 

  885.         // Delete old programs

  886.         pData->prog.clear();

  887. 

  888.         // Query new programs

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

  890. 

  891.         if (count > 0)

  892.         {

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

  894. 

  895.             // Update names

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

  897.             {

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

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

  900.                 {

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

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

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

  904.                 }

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

  906.             }

  907.         }

  908. 

  909. #ifndef BUILD_BRIDGE

  910.         // Update OSC Names

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

  912.         {

  913.             pData->engine->oscSend_control_set_program_count(fId, count);

  914. 

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

  916.                 pData->engine->oscSend_control_set_program_name(fId, i, pData->prog.names[i]);

  917.         }

  918. #endif

  919. 

  920.         if (init)

  921.         {

  922.             if (count > 0)

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

  924.         }

  925.         else

  926.         {

  927.             // Check if current program is invalid

  928.             bool programChanged = false;

  929. 

  930.             if (count == oldCount+1)

  931.             {

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

  933.                 pData->prog.current = oldCount;

  934.                 programChanged = true;

  935.             }

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

  937.             {

  938.                 // programs exist now, but not before

  939.                 pData->prog.current = 0;

  940.                 programChanged = true;

  941.             }

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

  943.             {

  944.                 // programs existed before, but not anymore

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

  946.                 programChanged = true;

  947.             }

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

  949.             {

  950.                 // current program > count

  951.                 pData->prog.current = 0;

  952.                 programChanged = true;

  953.             }

  954.             else

  955.             {

  956.                 // no change

  957.                 pData->prog.current = current;

  958.             }

  959. 

  960.             if (programChanged)

  961.             {

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

  963.             }

  964.             else

  965.             {

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

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

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

  969.             }

  970. 

  971.             pData->engine->callback(CALLBACK_RELOAD_PROGRAMS, fId, 0, 0, 0.0f, nullptr);

  972.         }

  973.     }

  974. 

  975.     // -------------------------------------------------------------------

  976.     // Plugin processing

  977. 

  978.     void activate() override

  979.     {

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

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

  982.     }

  983. 

  984.     void deactivate() override

  985.     {

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

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

  988.     }

  989. 

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

  991.     {

  992.         uint32_t i, k;

  993. 

  994.         // --------------------------------------------------------------------------------------------------------

  995.         // Check if active

  996. 

  997.         if (! pData->active)

  998.         {

  999.             // disable any output sound

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

  1001.                 carla_zeroFloat(outBuffer[i], frames);

  1002. 

  1003.             return;

  1004.         }

  1005. 

  1006.         fMidiEventCount = 0;

  1007.         carla_zeroStruct<VstMidiEvent>(fMidiEvents, MAX_MIDI_EVENTS*2);

  1008. 

  1009.         // --------------------------------------------------------------------------------------------------------

  1010.         // Check if needs reset

  1011. 

  1012.         if (pData->needsReset)

  1013.         {

  1014.             if (fOptions & PLUGIN_OPTION_SEND_ALL_SOUND_OFF)

  1015.             {

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

  1017.                 {

  1018.                     fMidiEvents[k].type = kVstMidiType;

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

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

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

  1022. 

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

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

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

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

  1027.                 }

  1028. 

  1029.                 fMidiEventCount = MAX_MIDI_CHANNELS*2;

  1030.             }

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

  1032.             {

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

  1034.                 {

  1035.                     fMidiEvents[k].type = kVstMidiType;

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

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

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

  1039.                 }

  1040. 

  1041.                 fMidiEventCount = MAX_MIDI_NOTE;

  1042.             }

  1043. 

  1044.             if (pData->latency > 0)

  1045.             {

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

  1047.                     carla_zeroFloat(pData->latencyBuffers[i], pData->latency);

  1048.             }

  1049. 

  1050.             pData->needsReset = false;

  1051.         }

  1052. 

  1053.         CARLA_PROCESS_CONTINUE_CHECK;

  1054. 

  1055.         // --------------------------------------------------------------------------------------------------------

  1056.         // Set TimeInfo

  1057. 

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

  1059. 

  1060.         fTimeInfo.flags = kVstTransportChanged;

  1061. 

  1062.         if (timeInfo.playing)

  1063.             fTimeInfo.flags |= kVstTransportPlaying;

  1064. 

  1065.         fTimeInfo.samplePos  = timeInfo.frame;

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

  1067. 

  1068.         if (timeInfo.usecs != 0)

  1069.         {

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

  1071.             fTimeInfo.flags |= kVstNanosValid;

  1072.         }

  1073. 

  1074.         if (timeInfo.valid & EngineTimeInfo::ValidBBT)

  1075.         {

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

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

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

  1079. 

  1080.             // PPQ Pos

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

  1082.             fTimeInfo.flags |= kVstPpqPosValid;

  1083. 

  1084.             // Tempo

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

  1086.             fTimeInfo.flags |= kVstTempoValid;

  1087. 

  1088.             // Bars

  1089.             fTimeInfo.barStartPos = ppqBar;

  1090.             fTimeInfo.flags |= kVstBarsValid;

  1091. 

  1092.             // Time Signature

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

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

  1095.             fTimeInfo.flags |= kVstTimeSigValid;

  1096.         }

  1097.         else

  1098.         {

  1099.             // Tempo

  1100.             fTimeInfo.tempo = 120.0;

  1101.             fTimeInfo.flags |= kVstTempoValid;

  1102. 

  1103.             // Time Signature

  1104.             fTimeInfo.timeSigNumerator   = 4;

  1105.             fTimeInfo.timeSigDenominator = 4;

  1106.             fTimeInfo.flags |= kVstTimeSigValid;

  1107. 

  1108.             // Missing info

  1109.             fTimeInfo.ppqPos = 0.0;

  1110.             fTimeInfo.barStartPos = 0.0;

  1111.         }

  1112. 

  1113.         CARLA_PROCESS_CONTINUE_CHECK;

  1114. 

  1115.         // --------------------------------------------------------------------------------------------------------

  1116.         // Event Input and Processing

  1117. 

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

  1119.         {

  1120.             // ----------------------------------------------------------------------------------------------------

  1121.             // MIDI Input (External)

  1122. 

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

  1124.             {

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

  1126.                 {

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

  1128. 

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

  1130. 

  1131.                     fMidiEvents[fMidiEventCount].type = kVstMidiType;

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

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

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

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

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

  1137. 

  1138.                     fMidiEventCount += 1;

  1139.                 }

  1140. 

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

  1142. 

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

  1144. 

  1145.             // ----------------------------------------------------------------------------------------------------

  1146.             // Event Input (System)

  1147. 

  1148.             bool allNotesOffSent = false;

  1149.             bool sampleAccurate  = (fOptions & PLUGIN_OPTION_FIXED_BUFFER) == 0;

  1150. 

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

  1152.             uint32_t startTime  = 0;

  1153.             uint32_t timeOffset = 0;

  1154. 

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

  1156.             {

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

  1158. 

  1159.                 time = event.time;

  1160. 

  1161.                 if (time >= frames)

  1162.                     continue;

  1163. 

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

  1165. 

  1166.                 if (time > timeOffset && sampleAccurate)

  1167.                 {

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

  1169.                     {

  1170.                         startTime  = 0;

  1171.                         timeOffset = time;

  1172. 

  1173.                         if (fMidiEventCount > 0)

  1174.                         {

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

  1176.                             fMidiEventCount = 0;

  1177.                         }

  1178.                     }

  1179.                     else

  1180.                         startTime += timeOffset;

  1181.                 }

  1182. 

  1183.                 // Control change

  1184.                 switch (event.type)

  1185.                 {

  1186.                 case kEngineEventTypeNull:

  1187.                     break;

  1188. 

  1189.                 case kEngineEventTypeControl:

  1190.                 {

  1191.                     const EngineControlEvent& ctrlEvent = event.ctrl;

  1192. 

  1193.                     switch (ctrlEvent.type)

  1194.                     {

  1195.                     case kEngineControlEventTypeNull:

  1196.                         break;

  1197. 

  1198.                     case kEngineControlEventTypeParameter:

  1199.                     {

  1200. #ifndef BUILD_BRIDGE

  1201.                         // Control backend stuff

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

  1203.                         {

  1204.                             float value;

  1205. 

  1206.                             if (MIDI_IS_CONTROL_BREATH_CONTROLLER(ctrlEvent.param) && (fHints & PLUGIN_CAN_DRYWET) > 0)

  1207.                             {

  1208.                                 value = ctrlEvent.value;

  1209.                                 setDryWet(value, false, false);

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

  1211.                             }

  1212. 

  1213.                             if (MIDI_IS_CONTROL_CHANNEL_VOLUME(ctrlEvent.param) && (fHints & PLUGIN_CAN_VOLUME) > 0)

  1214.                             {

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

  1216.                                 setVolume(value, false, false);

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

  1218.                             }

  1219. 

  1220.                             if (MIDI_IS_CONTROL_BALANCE(ctrlEvent.param) && (fHints & PLUGIN_CAN_BALANCE) > 0)

  1221.                             {

  1222.                                 float left, right;

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

  1224. 

  1225.                                 if (value < 0.0f)

  1226.                                 {

  1227.                                     left  = -1.0f;

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

  1229.                                 }

  1230.                                 else if (value > 0.0f)

  1231.                                 {

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

  1233.                                     right = 1.0f;

  1234.                                 }

  1235.                                 else

  1236.                                 {

  1237.                                     left  = -1.0f;

  1238.                                     right = 1.0f;

  1239.                                 }

  1240. 

  1241.                                 setBalanceLeft(left, false, false);

  1242.                                 setBalanceRight(right, false, false);

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

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

  1245.                             }

  1246.                         }

  1247. #endif

  1248. 

  1249.                         // Control plugin parameters

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

  1251.                         {

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

  1253.                                 continue;

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

  1255.                                 continue;

  1256.                             if (pData->param.data[k].type != PARAMETER_INPUT)

  1257.                                 continue;

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

  1259.                                 continue;

  1260. 

  1261.                             float value;

  1262. 

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

  1264.                             {

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

  1266.                             }

  1267.                             else

  1268.                             {

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

  1270. 

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

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

  1273.                             }

  1274. 

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

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

  1277.                         }

  1278. 

  1279.                         if ((fOptions & PLUGIN_OPTION_SEND_CONTROL_CHANGES) != 0 && ctrlEvent.param <= 0x5F)

  1280.                         {

  1281.                             if (fMidiEventCount >= MAX_MIDI_EVENTS*2)

  1282.                                 continue;

  1283. 

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

  1285. 

  1286.                             fMidiEvents[fMidiEventCount].type = kVstMidiType;

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

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

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

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

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

  1292. 

  1293.                             fMidiEventCount += 1;

  1294.                         }

  1295. 

  1296.                         break;

  1297.                     }

  1298. 

  1299.                     case kEngineControlEventTypeMidiBank:

  1300.                         break;

  1301. 

  1302.                     case kEngineControlEventTypeMidiProgram:

  1303.                         if (event.channel == pData->ctrlChannel && (fOptions & PLUGIN_OPTION_MAP_PROGRAM_CHANGES) != 0)

  1304.                         {

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

  1306.                             {

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

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

  1309.                                 break;

  1310.                             }

  1311.                         }

  1312.                         break;

  1313. 

  1314.                     case kEngineControlEventTypeAllSoundOff:

  1315.                         if (fOptions & PLUGIN_OPTION_SEND_ALL_SOUND_OFF)

  1316.                         {

  1317.                             if (fMidiEventCount >= MAX_MIDI_EVENTS*2)

  1318.                                 continue;

  1319. 

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

  1321. 

  1322.                             fMidiEvents[fMidiEventCount].type = kVstMidiType;

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

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

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

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

  1327. 

  1328.                             fMidiEventCount += 1;

  1329.                         }

  1330.                         break;

  1331. 

  1332.                     case kEngineControlEventTypeAllNotesOff:

  1333.                         if (fOptions & PLUGIN_OPTION_SEND_ALL_SOUND_OFF)

  1334.                         {

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

  1336.                             {

  1337.                                 allNotesOffSent = true;

  1338.                                 sendMidiAllNotesOffToCallback();

  1339.                             }

  1340. 

  1341.                             if (fMidiEventCount >= MAX_MIDI_EVENTS*2)

  1342.                                 continue;

  1343. 

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

  1345. 

  1346.                             fMidiEvents[fMidiEventCount].type = kVstMidiType;

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

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

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

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

  1351. 

  1352.                             fMidiEventCount += 1;

  1353.                         }

  1354.                         break;

  1355.                     }

  1356. 

  1357.                     break;

  1358.                 }

  1359. 

  1360.                 case kEngineEventTypeMidi:

  1361.                 {

  1362.                     if (fMidiEventCount >= MAX_MIDI_EVENTS*2)

  1363.                         continue;

  1364. 

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

  1366. 

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

  1368.                     uint8_t channel = event.channel;

  1369. 

  1370.                     if (MIDI_IS_STATUS_CHANNEL_PRESSURE(status) && (fOptions & PLUGIN_OPTION_SEND_CHANNEL_PRESSURE) == 0)

  1371.                         continue;

  1372.                     if (MIDI_IS_STATUS_CONTROL_CHANGE(status) && (fOptions & PLUGIN_OPTION_SEND_CONTROL_CHANGES) == 0)

  1373.                         continue;

  1374.                     if (MIDI_IS_STATUS_POLYPHONIC_AFTERTOUCH(status) && (fOptions & PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH) == 0)

  1375.                         continue;

  1376.                     if (MIDI_IS_STATUS_PITCH_WHEEL_CONTROL(status) && (fOptions & PLUGIN_OPTION_SEND_PITCHBEND) == 0)

  1377.                         continue;

  1378. 

  1379.                     // Fix bad note-off

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

  1381.                         status -= 0x10;

  1382. 

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

  1384. 

  1385.                     fMidiEvents[fMidiEventCount].type = kVstMidiType;

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

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

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

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

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

  1391. 

  1392.                     fMidiEventCount += 1;

  1393. 

  1394.                     if (status == MIDI_STATUS_NOTE_ON)

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

  1396.                     else if (status == MIDI_STATUS_NOTE_OFF)

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

  1398. 

  1399.                     break;

  1400.                 }

  1401.                 }

  1402.             }

  1403. 

  1404.             pData->postRtEvents.trySplice();

  1405. 

  1406.             if (frames > timeOffset)

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

  1408. 

  1409.         } // End of Event Input and Processing

  1410. 

  1411.         // --------------------------------------------------------------------------------------------------------

  1412.         // Plugin processing (no events)

  1413. 

  1414.         else

  1415.         {

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

  1417. 

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

  1419. 

  1420.         CARLA_PROCESS_CONTINUE_CHECK;

  1421. 

  1422.         // --------------------------------------------------------------------------------------------------------

  1423.         // MIDI Output

  1424. 

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

  1426.         {

  1427.             // reverse lookup MIDI events

  1428.             for (k = (MAX_MIDI_EVENTS*2)-1; k >= fMidiEventCount; --k)

  1429.             {

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

  1431.                     break;

  1432. 

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

  1434. 

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

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

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

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

  1439. 

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

  1441.             }

  1442. 

  1443.         } // End of Control and MIDI Output

  1444.     }

  1445. 

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

  1447.     {

  1448.         CARLA_ASSERT(frames > 0);

  1449. 

  1450.         if (frames == 0)

  1451.             return false;

  1452. 

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

  1454.         {

  1455.             CARLA_ASSERT(inBuffer != nullptr);

  1456.             if (inBuffer == nullptr)

  1457.                 return false;

  1458.         }

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

  1460.         {

  1461.             CARLA_ASSERT(outBuffer != nullptr);

  1462.             if (outBuffer == nullptr)

  1463.                 return false;

  1464.         }

  1465. 

  1466.         uint32_t i, k;

  1467. 

  1468.         // --------------------------------------------------------------------------------------------------------

  1469.         // Try lock, silence otherwise

  1470. 

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

  1472.         {

  1473.             pData->singleMutex.lock();

  1474.         }

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

  1476.         {

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

  1478.             {

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

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

  1481.             }

  1482. 

  1483.             return false;

  1484.         }

  1485. 

  1486.         // --------------------------------------------------------------------------------------------------------

  1487.         // Set audio buffers

  1488. 

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

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

  1491. 

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

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

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

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

  1496. 

  1497.         // --------------------------------------------------------------------------------------------------------

  1498.         // Set MIDI events

  1499. 

  1500.         if (fMidiEventCount > 0)

  1501.         {

  1502.             fEvents.numEvents = fMidiEventCount;

  1503.             fEvents.reserved  = 0;

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

  1505.         }

  1506. 

  1507.         // --------------------------------------------------------------------------------------------------------

  1508.         // Run plugin

  1509. 

  1510.         fIsProcessing = true;

  1511. 

  1512.         if (fHints & PLUGIN_CAN_PROCESS_REPLACING)

  1513.         {

  1514.             fEffect->processReplacing(fEffect,

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

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

  1517.                                       frames);

  1518.         }

  1519.         else

  1520.         {

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

  1522.                 carla_zeroFloat(vstOutBuffer[i], frames);

  1523. 

  1524. #if ! VST_FORCE_DEPRECATED

  1525.             fEffect->process(fEffect,

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

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

  1528.                              frames);

  1529. #endif

  1530.         }

  1531. 

  1532.         fIsProcessing = false;

  1533.         fTimeInfo.samplePos += frames;

  1534. 

  1535. #ifndef BUILD_BRIDGE

  1536.         // --------------------------------------------------------------------------------------------------------

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

  1538. 

  1539.         {

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

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

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

  1543. 

  1544.             bool isPair;

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

  1546. 

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

  1548.             {

  1549.                 // Dry/Wet

  1550.                 if (doDryWet)

  1551.                 {

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

  1553.                     {

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

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

  1556.                     }

  1557.                 }

  1558. 

  1559.                 // Balance

  1560.                 if (doBalance)

  1561.                 {

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

  1563. 

  1564.                     if (isPair)

  1565.                     {

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

  1567.                         carla_copyFloat(oldBufLeft, outBuffer[i]+timeOffset, frames);

  1568.                     }

  1569. 

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

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

  1572. 

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

  1574.                     {

  1575.                         if (isPair)

  1576.                         {

  1577.                             // left

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

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

  1580.                         }

  1581.                         else

  1582.                         {

  1583.                             // right

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

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

  1586.                         }

  1587.                     }

  1588.                 }

  1589. 

  1590.                 // Volume

  1591.                 if (doVolume)

  1592.                 {

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

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

  1595.                 }

  1596.             }

  1597. 

  1598.         } // End of Post-processing

  1599. #endif

  1600. 

  1601.         // --------------------------------------------------------------------------------------------------------

  1602. 

  1603.         pData->singleMutex.unlock();

  1604.         return true;

  1605.     }

  1606. 

  1607.     void bufferSizeChanged(const uint32_t newBufferSize) override

  1608.     {

  1609.         CARLA_ASSERT_INT(newBufferSize > 0, newBufferSize);

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

  1611. 

  1612.         if (pData->active)

  1613.             deactivate();

  1614. 

  1615. #if ! VST_FORCE_DEPRECATED

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

  1617. #endif

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

  1619. 

  1620.         if (pData->active)

  1621.             activate();

  1622.     }

  1623. 

  1624.     void sampleRateChanged(const double newSampleRate) override

  1625.     {

  1626.         CARLA_ASSERT_INT(newSampleRate > 0.0, newSampleRate);

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

  1628. 

  1629.         if (pData->active)

  1630.             deactivate();

  1631. 

  1632. #if ! VST_FORCE_DEPRECATED

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

  1634. #endif

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

  1636. 

  1637.         if (pData->active)

  1638.             activate();

  1639.     }

  1640. 

  1641.     // -------------------------------------------------------------------

  1642.     // Plugin buffers

  1643. 

  1644.     // nothing

  1645. 

  1646.     // -------------------------------------------------------------------

  1647.     // Post-poned UI Stuff

  1648. 

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

  1650.     {

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

  1652. 

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

  1654.             return;

  1655.         if (! fGui.isOsc)

  1656.             return;

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

  1658.             return;

  1659. 

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

  1661.     }

  1662. 

  1663.     void uiProgramChange(const uint32_t index) override

  1664.     {

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

  1666. 

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

  1668.             return;

  1669.         if (! fGui.isOsc)

  1670.             return;

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

  1672.             return;

  1673. 

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

  1675.     }

  1676. 

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

  1678.     {

  1679.         CARLA_ASSERT(channel < MAX_MIDI_CHANNELS);

  1680.         CARLA_ASSERT(note < MAX_MIDI_NOTE);

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

  1682. 

  1683.         if (channel >= MAX_MIDI_CHANNELS)

  1684.             return;

  1685.         if (note >= MAX_MIDI_NOTE)

  1686.             return;

  1687.         if (velo >= MAX_MIDI_VALUE)

  1688.             return;

  1689.         if (! fGui.isOsc)

  1690.             return;

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

  1692.             return;

  1693. 

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

  1695.         midiData[1] = MIDI_STATUS_NOTE_ON + channel;

  1696.         midiData[2] = note;

  1697.         midiData[3] = velo;

  1698. 

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

  1700.     }

  1701. 

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

  1703.     {

  1704.         CARLA_ASSERT(channel < MAX_MIDI_CHANNELS);

  1705.         CARLA_ASSERT(note < MAX_MIDI_NOTE);

  1706. 

  1707.         if (channel >= MAX_MIDI_CHANNELS)

  1708.             return;

  1709.         if (note >= MAX_MIDI_NOTE)

  1710.             return;

  1711.         if (! fGui.isOsc)

  1712.             return;

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

  1714.             return;

  1715. 

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

  1717.         midiData[1] = MIDI_STATUS_NOTE_OFF + channel;

  1718.         midiData[2] = note;

  1719. 

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

  1721.     }

  1722. 

  1723.     // -------------------------------------------------------------------

  1724. 

  1725. protected:

  1726.     void guiClosedCallback() override

  1727.     {

  1728.         showGui(false);

  1729.         pData->engine->callback(CALLBACK_SHOW_GUI, fId, 0, 0, 0.0f, nullptr);

  1730.     }

  1731. 

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

  1733.     {

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

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

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

  1737. #endif

  1738.         CARLA_ASSERT(fEffect != nullptr);

  1739. 

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

  1741.     }

  1742. 

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

  1744.     {

  1745. #if 0

  1746.         // Cockos VST extensions

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

  1748.         {

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

  1750. 

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

  1752.                 return 0;

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

  1754.                 return 0;

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

  1756.                 return 0;

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

  1758.                 return 0;

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

  1760.                 return 0;

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

  1762.                 return 0;

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

  1764.                 return 0;

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

  1766.                 return 0;

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

  1768.                 return 0;

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

  1770.                 return 0;

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

  1772.                 return 0;

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

  1774.                 return 0;

  1775.         }

  1776. #endif

  1777. 

  1778.         intptr_t ret = 0;

  1779. 

  1780.         switch (opcode)

  1781.         {

  1782.         case audioMasterAutomate:

  1783.             if (! fEnabled)

  1784.                 break;

  1785. 

  1786.             // plugins should never do this:

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

  1788. 

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

  1790.                 break;

  1791. 

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

  1793.             {

  1794.                 // Called from GUI

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

  1796.             }

  1797.             else if (fIsProcessing)

  1798.             {

  1799.                 // Called from engine

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

  1801. 

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

  1803.                 {

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

  1805.                 }

  1806.                 else

  1807.                 {

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

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

  1810.                 }

  1811.             }

  1812.             else

  1813.             {

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

  1815.             }

  1816.             break;

  1817. 

  1818.         case audioMasterCurrentId:

  1819.             // TODO

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

  1821.             break;

  1822. 

  1823.         case audioMasterIdle:

  1824.             if (fGui.isVisible)

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

  1826.             break;

  1827. 

  1828. #if ! VST_FORCE_DEPRECATED

  1829.         case audioMasterPinConnected:

  1830.             // Deprecated in VST SDK 2.4

  1831.             // TODO

  1832.             break;

  1833. 

  1834.         case audioMasterWantMidi:

  1835.             // Deprecated in VST SDK 2.4

  1836.             fHints |= PLUGIN_WANTS_MIDI_INPUT;

  1837.             break;

  1838. #endif

  1839. 

  1840.         case audioMasterGetTime:

  1841. #ifdef VESTIGE_HEADER

  1842.             ret = getAddressFromPointer(&fTimeInfo);

  1843. #else

  1844.             ret = ToVstPtr<VstTimeInfo_R>(&fTimeInfo);

  1845. #endif

  1846.             break;

  1847. 

  1848.         case audioMasterProcessEvents:

  1849.             CARLA_ASSERT(fEnabled);

  1850.             CARLA_ASSERT(fIsProcessing);

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

  1852.             CARLA_ASSERT(ptr != nullptr);

  1853. 

  1854.             if (! fEnabled)

  1855.                 return 0;

  1856.             if (! fIsProcessing)

  1857.                 return 0;

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

  1859.                 return 0;

  1860.             if (ptr == nullptr)

  1861.                 return 0;

  1862.             if (! fIsProcessing)

  1863.             {

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

  1865.                 return 0;

  1866.             }

  1867. 

  1868.             if (fMidiEventCount >= MAX_MIDI_EVENTS*2)

  1869.                 return 0;

  1870. 

  1871. 

  1872.         {

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

  1874. 

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

  1876.             {

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

  1878.                     break;

  1879. 

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

  1881. 

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

  1883.                     continue;

  1884. 

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

  1886.                 for (uint32_t j=(MAX_MIDI_EVENTS*2)-1; j >= fMidiEventCount; --j)

  1887.                 {

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

  1889.                     {

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

  1891.                         break;

  1892.                     }

  1893.                 }

  1894.             }

  1895.         }

  1896. 

  1897.             ret = 1;

  1898.             break;

  1899. 

  1900. #if ! VST_FORCE_DEPRECATED

  1901.         case audioMasterSetTime:

  1902.             // Deprecated in VST SDK 2.4

  1903.             break;

  1904. 

  1905.         case audioMasterTempoAt:

  1906.             // Deprecated in VST SDK 2.4

  1907.             CARLA_ASSERT(fIsProcessing);

  1908.             ret = fTimeInfo.tempo * 10000;

  1909.             break;

  1910. 

  1911.         case audioMasterGetNumAutomatableParameters:

  1912.             // Deprecated in VST SDK 2.4

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

  1914.             break;

  1915. 

  1916.         case audioMasterGetParameterQuantization:

  1917.             // Deprecated in VST SDK 2.4

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

  1919.             break;

  1920. #endif

  1921. 

  1922. #if 0

  1923.         case audioMasterIOChanged:

  1924.             CARLA_ASSERT(fEnabled);

  1925. 

  1926.             // TESTING

  1927. 

  1928.             if (! fEnabled)

  1929.             {

  1930.                 ret = 1;

  1931.                 break;

  1932.             }

  1933. 

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

  1935.             {

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

  1937.                 return 0;

  1938.             }

  1939. 

  1940.             engineProcessLock();

  1941.             m_enabled = false;

  1942.             engineProcessUnlock();

  1943. 

  1944.             if (m_active)

  1945.             {

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

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

  1948.             }

  1949. 

  1950.             reload();

  1951. 

  1952.             if (m_active)

  1953.             {

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

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

  1956.             }

  1957. 

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

  1959. 

  1960.             ret = 1;

  1961.             break;

  1962. #endif

  1963. 

  1964.         case audioMasterNeedIdle:

  1965.             // Deprecated in VST SDK 2.4

  1966.             fNeedIdle = true;

  1967.             ret = 1;

  1968.             break;

  1969. 

  1970.         case audioMasterSizeWindow:

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

  1972.             {

  1973.                 CARLA_SAFE_ASSERT(fGui.isVisible);

  1974.                 if (fGui.isVisible)

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

  1976.                 ret = 1;

  1977.             }

  1978.             break;

  1979. 

  1980.         case audioMasterGetSampleRate:

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

  1982.             break;

  1983. 

  1984.         case audioMasterGetBlockSize:

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

  1986.             break;

  1987. 

  1988.         case audioMasterGetInputLatency:

  1989.             ret = 0;

  1990.             break;

  1991. 

  1992.         case audioMasterGetOutputLatency:

  1993.             ret = 0;

  1994.             break;

  1995. 

  1996. #if ! VST_FORCE_DEPRECATED

  1997.         case audioMasterGetPreviousPlug:

  1998.             // Deprecated in VST SDK 2.4

  1999.             // TODO

  2000.             break;

  2001. 

  2002.         case audioMasterGetNextPlug:

  2003.             // Deprecated in VST SDK 2.4

  2004.             // TODO

  2005.             break;

  2006. 

  2007.         case audioMasterWillReplaceOrAccumulate:

  2008.             // Deprecated in VST SDK 2.4

  2009.             ret = 1; // replace

  2010.             break;

  2011. #endif

  2012. 

  2013.         case audioMasterGetCurrentProcessLevel:

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

  2015.                 ret = kVstProcessLevelOffline;

  2016.             else if (fIsProcessing)

  2017.                 ret = kVstProcessLevelRealtime;

  2018.             else

  2019.                 ret = kVstProcessLevelUser;

  2020.             break;

  2021. 

  2022.         case audioMasterGetAutomationState:

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

  2024.             break;

  2025. 

  2026.         case audioMasterOfflineStart:

  2027.         case audioMasterOfflineRead:

  2028.         case audioMasterOfflineWrite:

  2029.         case audioMasterOfflineGetCurrentPass:

  2030.         case audioMasterOfflineGetCurrentMetaPass:

  2031.             // TODO

  2032.             break;

  2033. 

  2034. #if ! VST_FORCE_DEPRECATED

  2035.         case audioMasterSetOutputSampleRate:

  2036.             // Deprecated in VST SDK 2.4

  2037.             break;

  2038. 

  2039.         case audioMasterGetOutputSpeakerArrangement:

  2040.             // Deprecated in VST SDK 2.4

  2041.             // TODO

  2042.             break;

  2043. #endif

  2044. 

  2045.         case audioMasterVendorSpecific:

  2046.             // TODO - cockos extensions

  2047.             break;

  2048. 

  2049. #if ! VST_FORCE_DEPRECATED

  2050.         case audioMasterSetIcon:

  2051.             // Deprecated in VST SDK 2.4

  2052.             break;

  2053. #endif

  2054. 

  2055. #if ! VST_FORCE_DEPRECATED

  2056.         case audioMasterOpenWindow:

  2057.         case audioMasterCloseWindow:

  2058.             // Deprecated in VST SDK 2.4

  2059.             // TODO

  2060.             break;

  2061. #endif

  2062. 

  2063.         case audioMasterGetDirectory:

  2064.             // TODO

  2065.             break;

  2066. 

  2067.         case audioMasterUpdateDisplay:

  2068.             // Idle UI if visible

  2069.             if (fGui.isVisible)

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

  2071. 

  2072.             // Update current program

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

  2074.             {

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

  2076. 

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

  2078.                 {

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

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

  2081. 

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

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

  2084. 

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

  2086. 

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

  2088.                     {

  2089.                         pData->prog.current = current;

  2090.                         pData->engine->callback(CALLBACK_PROGRAM_CHANGED, fId, current, 0, 0.0f, nullptr);

  2091.                     }

  2092.                 }

  2093.             }

  2094. 

  2095.             pData->engine->callback(CALLBACK_UPDATE, fId, 0, 0, 0.0f, nullptr);

  2096.             ret = 1;

  2097.             break;

  2098. 

  2099.         case audioMasterBeginEdit:

  2100.         case audioMasterEndEdit:

  2101.             // TODO

  2102.             break;

  2103. 

  2104.         case audioMasterOpenFileSelector:

  2105.         case audioMasterCloseFileSelector:

  2106.             // TODO

  2107.             break;

  2108. 

  2109. #if ! VST_FORCE_DEPRECATED

  2110.         case audioMasterEditFile:

  2111.             // Deprecated in VST SDK 2.4

  2112.             // TODO

  2113.             break;

  2114. 

  2115.         case audioMasterGetChunkFile:

  2116.             // Deprecated in VST SDK 2.4

  2117.             // TODO

  2118.             break;

  2119. 

  2120.         case audioMasterGetInputSpeakerArrangement:

  2121.             // Deprecated in VST SDK 2.4

  2122.             // TODO

  2123.             break;

  2124. #endif

  2125. 

  2126.         default:

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

  2128.             break;

  2129.         }

  2130. 

  2131.         return ret;

  2132.     }

  2133. 

  2134.     // -------------------------------------------------------------------

  2135. 

  2136. public:

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

  2138.     {

  2139.         CARLA_ASSERT(pData->engine != nullptr);

  2140.         CARLA_ASSERT(pData->client == nullptr);

  2141.         CARLA_ASSERT(filename != nullptr);

  2142. 

  2143.         // ---------------------------------------------------------------

  2144.         // first checks

  2145. 

  2146.         if (pData->engine == nullptr)

  2147.         {

  2148.             return false;

  2149.         }

  2150. 

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

  2152.         {

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

  2154.             return false;

  2155.         }

  2156. 

  2157.         if (filename == nullptr)

  2158.         {

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

  2160.             return false;

  2161.         }

  2162. 

  2163.         // ---------------------------------------------------------------

  2164.         // open DLL

  2165. 

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

  2167.         {

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

  2169.             return false;

  2170.         }

  2171. 

  2172.         // ---------------------------------------------------------------

  2173.         // get DLL main entry

  2174. 

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

  2176. 

  2177.         if (vstFn == nullptr)

  2178.         {

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

  2180. 

  2181.             if (vstFn == nullptr)

  2182.             {

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

  2184.                 return false;

  2185.             }

  2186.         }

  2187. 

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

  2189.         // initialize plugin (part 1)

  2190. 

  2191.         sLastVstPlugin = this;

  2192.         fEffect = vstFn(carla_vst_audioMasterCallback);

  2193.         sLastVstPlugin = nullptr;

  2194. 

  2195.         if (fEffect == nullptr)

  2196.         {

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

  2198.             return false;

  2199.         }

  2200. 

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

  2202.         {

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

  2204.             return false;

  2205.         }

  2206. 

  2207. #ifdef VESTIGE_HEADER

  2208.         fEffect->ptr1 = this;

  2209. #else

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

  2211. #endif

  2212. 

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

  2214. 

  2215.         // ---------------------------------------------------------------

  2216.         // get info

  2217. 

  2218.         if (name != nullptr)

  2219.         {

  2220.             fName = pData->engine->getUniquePluginName(name);

  2221.         }

  2222.         else

  2223.         {

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

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

  2226. 

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

  2228.             {

  2229.                 fName = pData->engine->getUniquePluginName(strBuf);

  2230.             }

  2231.             else

  2232.             {

  2233.                 const char* const label = std::strrchr(filename, OS_SEP)+1;

  2234.                 fName = pData->engine->getUniquePluginName(label);

  2235.             }

  2236.         }

  2237. 

  2238.         fFilename = filename;

  2239. 

  2240.         // ---------------------------------------------------------------

  2241.         // register client

  2242. 

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

  2244. 

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

  2246.         {

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

  2248.             return false;

  2249.         }

  2250. 

  2251.         // ---------------------------------------------------------------

  2252.         // initialize plugin (part 2)

  2253. 

  2254. #if ! VST_FORCE_DEPRECATED

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

  2256. #endif

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

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

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

  2260. 

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

  2262.             fHints |= PLUGIN_USES_OLD_VSTSDK;

  2263. 

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

  2265.             fHints |= PLUGIN_HAS_COCKOS_EXTENSIONS;

  2266. 

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

  2268.         // gui stuff

  2269. 

  2270.         if (fEffect->flags & effFlagsHasEditor)

  2271.         {

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

  2273. 

  2274. #if defined(Q_WS_X11)

  2275.             CarlaString uiBridgeBinary(engineOptions.bridge_vstX11);

  2276. #elif defined(CARLA_OS_MAC)

  2277.             CarlaString uiBridgeBinary(engineOptions.bridge_vstCocoa);

  2278. #elif defined(CARLA_OS_WIN)

  2279.             CarlaString uiBridgeBinary(engineOptions.bridge_vstHWND);

  2280. #else

  2281.             CarlaString uiBridgeBinary;

  2282. #endif

  2283. 

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

  2285.             {

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

  2287.                 fGui.isOsc = true;

  2288.             }

  2289.         }

  2290. 

  2291.         // ---------------------------------------------------------------

  2292.         // load plugin settings

  2293. 

  2294.         {

  2295.             // set default options

  2296.             fOptions = 0x0;

  2297. 

  2298.             fOptions |= PLUGIN_OPTION_MAP_PROGRAM_CHANGES;

  2299. 

  2300.             if (getMidiInCount() > 0)

  2301.                 fOptions |= PLUGIN_OPTION_FIXED_BUFFER;

  2302. 

  2303.             if (fEffect->flags & effFlagsProgramChunks)

  2304.                 fOptions |= PLUGIN_OPTION_USE_CHUNKS;

  2305. 

  2306.             if (vstPluginCanDo(fEffect, "receiveVstEvents") || vstPluginCanDo(fEffect, "receiveVstMidiEvent") || (fEffect->flags & effFlagsIsSynth) > 0 || (fHints & PLUGIN_WANTS_MIDI_INPUT))

  2307.             {

  2308.                 fOptions |= PLUGIN_OPTION_SEND_CHANNEL_PRESSURE;

  2309.                 fOptions |= PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH;

  2310.                 fOptions |= PLUGIN_OPTION_SEND_PITCHBEND;

  2311.                 fOptions |= PLUGIN_OPTION_SEND_ALL_SOUND_OFF;

  2312.             }

  2313. 

  2314.             // load settings

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

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

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

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

  2319.             fOptions = pData->loadSettings(fOptions, getAvailableOptions());

  2320. 

  2321.             // ignore settings, we need this anyway

  2322.             if (getMidiInCount() > 0)

  2323.                 fOptions |= PLUGIN_OPTION_FIXED_BUFFER;

  2324.         }

  2325. 

  2326.         return true;

  2327.     }

  2328. 

  2329. private:

  2330.     int fUnique1;

  2331.     AEffect* fEffect;

  2332. 

  2333.     void*         fLastChunk;

  2334.     uint32_t      fMidiEventCount;

  2335.     VstMidiEvent  fMidiEvents[MAX_MIDI_EVENTS*2];

  2336.     VstTimeInfo_R fTimeInfo;

  2337. 

  2338.     struct FixedVstEvents {

  2339.         int32_t numEvents;

  2340.         intptr_t reserved;

  2341.         VstEvent* data[MAX_MIDI_EVENTS*2];

  2342. 

  2343.         FixedVstEvents()

  2344.             : numEvents(0),

  2345. #ifdef CARLA_PROPER_CPP11_SUPPORT

  2346.               reserved(0),

  2347.               data{nullptr} {}

  2348. #else

  2349.               reserved(0)

  2350.         {

  2351.             carla_fill<VstEvent*>(data, MAX_MIDI_EVENTS*2, nullptr);

  2352.         }

  2353. #endif

  2354.     } fEvents;

  2355. 

  2356.     struct GuiInfo {

  2357.         bool isOsc;

  2358.         bool isVisible;

  2359.         int  lastWidth;

  2360.         int  lastHeight;

  2361. 

  2362.         GuiInfo()

  2363.             : isOsc(false),

  2364.               isVisible(false),

  2365.               lastWidth(0),

  2366.               lastHeight(0) {}

  2367.     } fGui;

  2368. 

  2369.     bool fIsProcessing;

  2370.     bool fNeedIdle;

  2371.     int  fUnique2;

  2372. 

  2373.     static VstPlugin* sLastVstPlugin;

  2374. 

  2375.     // -------------------------------------------------------------------

  2376. 

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

  2378.     {

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

  2380. 

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

  2382.             return 1;

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

  2384.             return 1;

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

  2386.             return 1;

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

  2388.             return 1;

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

  2390.             return 1;

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

  2392.             return 1;

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

  2394.             return 1;

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

  2396.             return -1;

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

  2398.             return -1;

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

  2400.             return 1;

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

  2402.             return 1;

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

  2404.             return -1;

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

  2406.             return -1;

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

  2408.             return -1;

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

  2410.             return 1;

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

  2412.             return -1;

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

  2414.             return -1;

  2415. 

  2416.         // unimplemented

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

  2418.         return 0;

  2419.     }

  2420. 

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

  2422.     {

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

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

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

  2426. #endif

  2427. 

  2428.         switch (opcode)

  2429.         {

  2430.         case audioMasterVersion:

  2431.             return kVstVersion;

  2432. 

  2433.         case audioMasterGetVendorString:

  2434.             CARLA_ASSERT(ptr != nullptr);

  2435. 

  2436.             if (ptr != nullptr)

  2437.             {

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

  2439.                 return 1;

  2440.             }

  2441.             else

  2442.             {

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

  2444.                 return 0;

  2445.             }

  2446. 

  2447.         case audioMasterGetProductString:

  2448.             CARLA_ASSERT(ptr != nullptr);

  2449. 

  2450.             if (ptr != nullptr)

  2451.             {

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

  2453.                 return 1;

  2454.             }

  2455.             else

  2456.             {

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

  2458.                 return 0;

  2459.             }

  2460. 

  2461.         case audioMasterGetVendorVersion:

  2462.             return 0x110; // 1.1.0

  2463. 

  2464.         case audioMasterCanDo:

  2465.             CARLA_ASSERT(ptr != nullptr);

  2466. 

  2467.             if (ptr != nullptr)

  2468.             {

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

  2470.             }

  2471.             else

  2472.             {

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

  2474.                 return 0;

  2475.             }

  2476. 

  2477.         case audioMasterGetLanguage:

  2478.             return kVstLangEnglish;

  2479.         }

  2480. 

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

  2482.         VstPlugin* self = nullptr;

  2483. 

  2484.         if (effect != nullptr)

  2485.         {

  2486. #ifdef VESTIGE_HEADER

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

  2488.             {

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

  2490. #else

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

  2492.             {

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

  2494. #endif

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

  2496.                     self = nullptr;

  2497.             }

  2498. 

  2499.             if (self != nullptr)

  2500.             {

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

  2502.                     self->fEffect = effect;

  2503. 

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

  2505.                 {

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

  2507.                     self = nullptr;

  2508.                 }

  2509.             }

  2510.             else if (sLastVstPlugin != nullptr)

  2511.             {

  2512. #ifdef VESTIGE_HEADER

  2513.                 effect->ptr1 = sLastVstPlugin;

  2514. #else

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

  2516. #endif

  2517.                 self = sLastVstPlugin;

  2518.             }

  2519.         }

  2520. 

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

  2522.     }

  2523. 

  2524.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(VstPlugin)

  2525. };

  2526. 

  2527. VstPlugin* VstPlugin::sLastVstPlugin = nullptr;

  2528. 

  2529. CARLA_BACKEND_END_NAMESPACE

  2530. 

  2531. #else // WANT_VST

  2532. # warning Building without VST support

  2533. #endif

  2534. 

  2535. CARLA_BACKEND_START_NAMESPACE

  2536. 

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

  2538. {

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

  2540. 

  2541. #ifdef WANT_VST

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

  2543. 

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

  2545.     {

  2546.         delete plugin;

  2547.         return nullptr;

  2548.     }

  2549. 

  2550.     plugin->reload();

  2551. 

  2552.     if (init.engine->getProccessMode() == PROCESS_MODE_CONTINUOUS_RACK && ! plugin->canRunInRack())

  2553.     {

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

  2555.         delete plugin;

  2556.         return nullptr;

  2557.     }

  2558. 

  2559.     return plugin;

  2560. #else

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

  2562.     return nullptr;

  2563. #endif

  2564. }

  2565. 

  2566. CARLA_BACKEND_END_NAMESPACE