falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 43 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.
751 Commits
17 Branches
625MB
Tree: 99b895bd1e
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '99b895bd1e'
${ noResults }
Carla/source/backend/plugin/VstPlugin.cpp

2574 lines
83KB
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 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.         kData->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.                 // Wait a bit first, then force kill

  86.                 if (kData->osc.thread.isRunning() && ! kData->osc.thread.wait(kData->engine->getOptions().oscUiTimeout))

  87.                 {

  88.                     carla_stderr("VST OSC-GUI thread still running, forcing termination now");

  89.                     kData->osc.thread.terminate();

  90.                 }

  91.             }

  92.         }

  93. 

  94.         kData->singleMutex.lock();

  95.         kData->masterMutex.lock();

  96. 

  97.         if (kData->client != nullptr && kData->client->isActive())

  98.             kData->client->deactivate();

  99. 

  100.         CARLA_ASSERT(! fIsProcessing);

  101. 

  102.         if (kData->active)

  103.         {

  104.             deactivate();

  105.             kData->active = false;

  106.         }

  107. 

  108.         if (fEffect != nullptr)

  109.         {

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

  111.             fEffect = nullptr;

  112.         }

  113. 

  114.         // make plugin invalid

  115.         fUnique2 += 1;

  116. 

  117.         if (fLastChunk != nullptr)

  118.         {

  119.             std::free(fLastChunk);

  120.             fLastChunk = nullptr;

  121.         }

  122. 

  123.         clearBuffers();

  124.     }

  125. 

  126.     // -------------------------------------------------------------------

  127.     // Information (base)

  128. 

  129.     PluginType type() const override

  130.     {

  131.         return PLUGIN_VST;

  132.     }

  133. 

  134.     PluginCategory category() override

  135.     {

  136.         CARLA_ASSERT(fEffect != nullptr);

  137. 

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

  139. 

  140.         switch (category)

  141.         {

  142.         case kPlugCategSynth:

  143.             return PLUGIN_CATEGORY_SYNTH;

  144.         case kPlugCategAnalysis:

  145.             return PLUGIN_CATEGORY_UTILITY;

  146.         case kPlugCategMastering:

  147.             return PLUGIN_CATEGORY_DYNAMICS;

  148.         case kPlugCategRoomFx:

  149.             return PLUGIN_CATEGORY_DELAY;

  150.         case kPlugCategRestoration:

  151.             return PLUGIN_CATEGORY_UTILITY;

  152.         case kPlugCategGenerator:

  153.             return PLUGIN_CATEGORY_SYNTH;

  154.         }

  155. 

  156.         if (fEffect->flags & effFlagsIsSynth)

  157.             return PLUGIN_CATEGORY_SYNTH;

  158. 

  159.         return getPluginCategoryFromName(fName);

  160.     }

  161. 

  162.     long uniqueId() const override

  163.     {

  164.         CARLA_ASSERT(fEffect != nullptr);

  165. 

  166.         return fEffect->uniqueID;

  167.     }

  168. 

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

  170.     // Information (count)

  171. 

  172.     // nothing

  173. 

  174.     // -------------------------------------------------------------------

  175.     // Information (current data)

  176. 

  177.     int32_t chunkData(void** const dataPtr) override

  178.     {

  179.         CARLA_ASSERT(fOptions & PLUGIN_OPTION_USE_CHUNKS);

  180.         CARLA_ASSERT(fEffect != nullptr);

  181.         CARLA_ASSERT(dataPtr != nullptr);

  182. 

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

  184.     }

  185. 

  186.     // -------------------------------------------------------------------

  187.     // Information (per-plugin data)

  188. 

  189.     unsigned int availableOptions() override

  190.     {

  191.         CARLA_ASSERT(fEffect != nullptr);

  192. 

  193.         if (fEffect == nullptr)

  194.             return 0x0;

  195. 

  196.         unsigned int options = 0x0;

  197. 

  198.         options |= PLUGIN_OPTION_MAP_PROGRAM_CHANGES;

  199. 

  200.         if (midiInCount() == 0)

  201.             options |= PLUGIN_OPTION_FIXED_BUFFER;

  202. 

  203.         if (fEffect->flags & effFlagsProgramChunks)

  204.             options |= PLUGIN_OPTION_USE_CHUNKS;

  205. 

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

  207.         {

  208.             options |= PLUGIN_OPTION_SEND_CONTROL_CHANGES;

  209.             options |= PLUGIN_OPTION_SEND_CHANNEL_PRESSURE;

  210.             options |= PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH;

  211.             options |= PLUGIN_OPTION_SEND_PITCHBEND;

  212.             options |= PLUGIN_OPTION_SEND_ALL_SOUND_OFF;

  213.         }

  214. 

  215.         return options;

  216.     }

  217. 

  218.     float getParameterValue(const uint32_t parameterId) override

  219.     {

  220.         CARLA_ASSERT(fEffect != nullptr);

  221.         CARLA_ASSERT(parameterId < kData->param.count);

  222. 

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

  224.     }

  225. 

  226.     void getLabel(char* const strBuf) override

  227.     {

  228.         CARLA_ASSERT(fEffect != nullptr);

  229. 

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

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

  232.     }

  233. 

  234.     void getMaker(char* const strBuf) override

  235.     {

  236.         CARLA_ASSERT(fEffect != nullptr);

  237. 

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

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

  240.     }

  241. 

  242.     void getCopyright(char* const strBuf) override

  243.     {

  244.         CARLA_ASSERT(fEffect != nullptr);

  245. 

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

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

  248.     }

  249. 

  250.     void getRealName(char* const strBuf) override

  251.     {

  252.         CARLA_ASSERT(fEffect != nullptr);

  253. 

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

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

  256.     }

  257. 

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

  259.     {

  260.         CARLA_ASSERT(fEffect != nullptr);

  261.         CARLA_ASSERT(parameterId < kData->param.count);

  262. 

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

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

  265.     }

  266. 

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

  268.     {

  269.         CARLA_ASSERT(fEffect != nullptr);

  270.         CARLA_ASSERT(parameterId < kData->param.count);

  271. 

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

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

  274. 

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

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

  277.     }

  278. 

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

  280.     {

  281.         CARLA_ASSERT(fEffect != nullptr);

  282.         CARLA_ASSERT(parameterId < kData->param.count);

  283. 

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

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

  286.     }

  287. 

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

  289.     // Set data (state)

  290. 

  291.     // nothing

  292. 

  293.     // -------------------------------------------------------------------

  294.     // Set data (internal stuff)

  295. 

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

  297.     {

  298.         CarlaPlugin::setName(newName);

  299. 

  300.         if (kData->gui != nullptr)

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

  302.     }

  303. 

  304.     // -------------------------------------------------------------------

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

  306. 

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

  308.     {

  309.         CARLA_ASSERT(fEffect != nullptr);

  310.         CARLA_ASSERT(parameterId < kData->param.count);

  311. 

  312.         const float fixedValue(kData->param.fixValue(parameterId, value));

  313. 

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

  315. 

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

  317.     }

  318. 

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

  320.     {

  321.         CARLA_ASSERT(fOptions & PLUGIN_OPTION_USE_CHUNKS);

  322.         CARLA_ASSERT(fEffect != nullptr);

  323.         CARLA_ASSERT(stringData != nullptr);

  324. 

  325.         if (fLastChunk != nullptr)

  326.         {

  327.             std::free(fLastChunk);

  328.             fLastChunk = nullptr;

  329.         }

  330. 

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

  332. 

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

  334. 

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

  336.         {

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

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

  339. 

  340.             {

  341.                 const ScopedSingleProcessLocker spl(this, true);

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

  343.             }

  344. 

  345.             // simulate an updateDisplay callback

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

  347.         }

  348.     }

  349. 

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

  351.     {

  352.         CARLA_ASSERT(fEffect != nullptr);

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

  354. 

  355.         if (index < -1)

  356.             index = -1;

  357.         else if (index > static_cast<int32_t>(kData->prog.count))

  358.             return;

  359. 

  360.         if (index >= 0)

  361.         {

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

  363. 

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

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

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

  367.         }

  368. 

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

  370.     }

  371. 

  372.     // -------------------------------------------------------------------

  373.     // Set gui stuff

  374. 

  375.     void showGui(const bool yesNo) override

  376.     {

  377.         if (fGui.isVisible == yesNo)

  378.             return;

  379. 

  380.         if (fGui.isOsc)

  381.         {

  382.             if (yesNo)

  383.             {

  384.                 kData->osc.data.free();

  385.                 kData->osc.thread.start();

  386.             }

  387.             else

  388.             {

  389.                 if (kData->osc.data.target != nullptr)

  390.                 {

  391.                     osc_send_hide(&kData->osc.data);

  392.                     osc_send_quit(&kData->osc.data);

  393.                     kData->osc.data.free();

  394.                 }

  395. 

  396.                 if (kData->osc.thread.isRunning() && ! kData->osc.thread.wait(kData->engine->getOptions().oscUiTimeout))

  397.                     kData->osc.thread.terminate();

  398.             }

  399.         }

  400.         else

  401.         {

  402.             if (yesNo)

  403.             {

  404.                 CARLA_ASSERT(kData->gui == nullptr);

  405. 

  406.                 if (kData->gui == nullptr)

  407.                 {

  408.                     CarlaPluginGui::Options guiOptions;

  409.                     guiOptions.parented  = true;

  410.                     guiOptions.resizable = false;

  411. 

  412.                     kData->gui = new CarlaPluginGui(kData->engine, this, guiOptions, kData->guiGeometry);

  413.                 }

  414. 

  415.                 int32_t value = 0;

  416. #ifdef Q_WS_X11

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

  418. #endif

  419.                 void* const ptr = kData->gui->getContainerWinId();

  420. 

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

  422.                 {

  423.                     ERect* vstRect = nullptr;

  424. 

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

  426. 

  427.                     if (vstRect != nullptr)

  428.                     {

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

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

  431. 

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

  433. 

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

  435.                             kData->gui->setSize(width, height);

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

  437.                             kData->gui->setSize(fGui.lastWidth, fGui.lastHeight);

  438.                     }

  439. 

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

  441.                     kData->gui->show();

  442.                 }

  443.                 else

  444.                 {

  445.                     if (kData->gui != nullptr)

  446.                     {

  447.                         kData->guiGeometry = kData->gui->saveGeometry();

  448.                         kData->gui->close();

  449.                         delete kData->gui;

  450.                         kData->gui = nullptr;

  451.                     }

  452. 

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

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

  455.                     return;

  456.                 }

  457.             }

  458.             else

  459.             {

  460.                 CARLA_ASSERT(kData->gui != nullptr);

  461. 

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

  463. 

  464.                 if (kData->gui != nullptr)

  465.                 {

  466.                     fGui.lastWidth  = kData->gui->width();

  467.                     fGui.lastHeight = kData->gui->height();

  468. 

  469.                     kData->guiGeometry = kData->gui->saveGeometry();

  470.                     kData->gui->close();

  471.                     delete kData->gui;

  472.                     kData->gui = nullptr;

  473.                 }

  474.             }

  475.         }

  476. 

  477.         fGui.isVisible = yesNo;

  478.     }

  479. 

  480.     void idleGui() override

  481.     {

  482. #ifdef VESTIGE_HEADER

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

  484. #else

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

  486. #endif

  487.         {

  488.             if (fNeedIdle)

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

  490. 

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

  492.             {

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

  494.                 //kData->gui->idle();

  495.             }

  496.         }

  497. 

  498.         CarlaPlugin::idleGui();

  499.     }

  500. 

  501.     // -------------------------------------------------------------------

  502.     // Plugin state

  503. 

  504.     void reload() override

  505.     {

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

  507.         CARLA_ASSERT(kData->engine != nullptr);

  508.         CARLA_ASSERT(fEffect != nullptr);

  509. 

  510.         if (kData->engine == nullptr)

  511.             return;

  512.         if (fEffect == nullptr)

  513.             return;

  514. 

  515.         const ProcessMode processMode(kData->engine->getProccessMode());

  516. 

  517.         // Safely disable plugin for reload

  518.         const ScopedDisabler sd(this);

  519. 

  520.         if (kData->active)

  521.             deactivate();

  522. 

  523.         clearBuffers();

  524. 

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

  526. 

  527.         bool needsCtrlIn, needsCtrlOut;

  528.         needsCtrlIn = needsCtrlOut = false;

  529. 

  530.         aIns   = fEffect->numInputs;

  531.         aOuts  = fEffect->numOutputs;

  532.         params = fEffect->numParams;

  533. 

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

  535.         {

  536.             mIns = 1;

  537.             needsCtrlIn = true;

  538.         }

  539.         else

  540.             mIns = 0;

  541. 

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

  543.         {

  544.             mOuts = 1;

  545.             needsCtrlOut = true;

  546.         }

  547.         else

  548.             mOuts = 0;

  549. 

  550.         if (aIns > 0)

  551.         {

  552.             kData->audioIn.createNew(aIns);

  553.         }

  554. 

  555.         if (aOuts > 0)

  556.         {

  557.             kData->audioOut.createNew(aOuts);

  558.             needsCtrlIn = true;

  559.         }

  560. 

  561.         if (params > 0)

  562.         {

  563.             kData->param.createNew(params);

  564.             needsCtrlIn = true;

  565.         }

  566. 

  567.         const uint portNameSize(kData->engine->maxPortNameSize());

  568.         CarlaString portName;

  569. 

  570.         // Audio Ins

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

  572.         {

  573.             portName.clear();

  574. 

  575.             if (processMode == PROCESS_MODE_SINGLE_CLIENT)

  576.             {

  577.                 portName  = fName;

  578.                 portName += ":";

  579.             }

  580. 

  581.             if (aIns > 1)

  582.             {

  583.                 portName += "input_";

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

  585.             }

  586.             else

  587.                 portName += "input";

  588. 

  589.             portName.truncate(portNameSize);

  590. 

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

  592.             kData->audioIn.ports[j].rindex = j;

  593.         }

  594. 

  595.         // Audio Outs

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

  597.         {

  598.             portName.clear();

  599. 

  600.             if (processMode == PROCESS_MODE_SINGLE_CLIENT)

  601.             {

  602.                 portName  = fName;

  603.                 portName += ":";

  604.             }

  605. 

  606.             if (aOuts > 1)

  607.             {

  608.                 portName += "output_";

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

  610.             }

  611.             else

  612.                 portName += "output";

  613. 

  614.             portName.truncate(portNameSize);

  615. 

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

  617.             kData->audioOut.ports[j].rindex = j;

  618.         }

  619. 

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

  621.         {

  622.             kData->param.data[j].type   = PARAMETER_INPUT;

  623.             kData->param.data[j].index  = j;

  624.             kData->param.data[j].rindex = j;

  625.             kData->param.data[j].hints  = 0x0;

  626.             kData->param.data[j].midiChannel = 0;

  627.             kData->param.data[j].midiCC = -1;

  628. 

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

  630. 

  631.             VstParameterProperties prop;

  632.             carla_zeroStruct<VstParameterProperties>(prop);

  633. 

  634.             if (fHints & PLUGIN_HAS_COCKOS_EXTENSIONS)

  635.             {

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

  637. 

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

  639.                 {

  640.                     min = range[0];

  641.                     max = range[1];

  642. 

  643.                     if (min > max)

  644.                         max = min;

  645.                     else if (max < min)

  646.                         min = max;

  647. 

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

  649.                     {

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

  651.                         max = min + 0.1f;

  652.                     }

  653.                 }

  654.                 else

  655.                 {

  656.                     min = 0.0f;

  657.                     max = 1.0f;

  658.                 }

  659. 

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

  661.                 {

  662.                     step = 1.0f;

  663.                     stepSmall = 1.0f;

  664.                     stepLarge = 10.0f;

  665.                 }

  666.                 else

  667.                 {

  668.                     float range = max - min;

  669.                     step = range/100.0f;

  670.                     stepSmall = range/1000.0f;

  671.                     stepLarge = range/10.0f;

  672.                 }

  673.             }

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

  675.             {

  676.                 if (prop.flags & kVstParameterUsesIntegerMinMax)

  677.                 {

  678.                     min = float(prop.minInteger);

  679.                     max = float(prop.maxInteger);

  680. 

  681.                     if (min > max)

  682.                         max = min;

  683.                     else if (max < min)

  684.                         min = max;

  685. 

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

  687.                     {

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

  689.                         max = min + 0.1f;

  690.                     }

  691.                 }

  692.                 else

  693.                 {

  694.                     min = 0.0f;

  695.                     max = 1.0f;

  696.                 }

  697. 

  698.                 if (prop.flags & kVstParameterIsSwitch)

  699.                 {

  700.                     step = max - min;

  701.                     stepSmall = step;

  702.                     stepLarge = step;

  703.                     kData->param.data[j].hints |= PARAMETER_IS_BOOLEAN;

  704.                 }

  705.                 else if (prop.flags & kVstParameterUsesIntStep)

  706.                 {

  707.                     step = float(prop.stepInteger);

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

  709.                     stepLarge = float(prop.largeStepInteger);

  710.                     kData->param.data[j].hints |= PARAMETER_IS_INTEGER;

  711.                 }

  712.                 else if (prop.flags & kVstParameterUsesFloatStep)

  713.                 {

  714.                     step = prop.stepFloat;

  715.                     stepSmall = prop.smallStepFloat;

  716.                     stepLarge = prop.largeStepFloat;

  717.                 }

  718.                 else

  719.                 {

  720.                     float range = max - min;

  721.                     step = range/100.0f;

  722.                     stepSmall = range/1000.0f;

  723.                     stepLarge = range/10.0f;

  724.                 }

  725. 

  726.                 if (prop.flags & kVstParameterCanRamp)

  727.                     kData->param.data[j].hints |= PARAMETER_IS_LOGARITHMIC;

  728.             }

  729.             else

  730.             {

  731.                 min = 0.0f;

  732.                 max = 1.0f;

  733.                 step = 0.001f;

  734.                 stepSmall = 0.0001f;

  735.                 stepLarge = 0.1f;

  736.             }

  737. 

  738.             kData->param.data[j].hints |= PARAMETER_IS_ENABLED;

  739. #ifndef BUILD_BRIDGE

  740.             kData->param.data[j].hints |= PARAMETER_USES_CUSTOM_TEXT;

  741. #endif

  742. 

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

  744.                 kData->param.data[j].hints |= PARAMETER_IS_AUTOMABLE;

  745. 

  746.             // no such thing as VST default parameters

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

  748. 

  749.             if (def < min)

  750.                 def = min;

  751.             else if (def > max)

  752.                 def = max;

  753. 

  754.             kData->param.ranges[j].min = min;

  755.             kData->param.ranges[j].max = max;

  756.             kData->param.ranges[j].def = def;

  757.             kData->param.ranges[j].step = step;

  758.             kData->param.ranges[j].stepSmall = stepSmall;

  759.             kData->param.ranges[j].stepLarge = stepLarge;

  760.         }

  761. 

  762.         if (needsCtrlIn)

  763.         {

  764.             portName.clear();

  765. 

  766.             if (processMode == PROCESS_MODE_SINGLE_CLIENT)

  767.             {

  768.                 portName  = fName;

  769.                 portName += ":";

  770.             }

  771. 

  772.             portName += "events-in";

  773.             portName.truncate(portNameSize);

  774. 

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

  776.         }

  777. 

  778.         if (needsCtrlOut)

  779.         {

  780.             portName.clear();

  781. 

  782.             if (processMode == PROCESS_MODE_SINGLE_CLIENT)

  783.             {

  784.                 portName  = fName;

  785.                 portName += ":";

  786.             }

  787. 

  788.             portName += "events-out";

  789.             portName.truncate(portNameSize);

  790. 

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

  792.         }

  793. 

  794.         // plugin hints

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

  796. 

  797.         fHints = 0x0;

  798. 

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

  800.             fHints |= PLUGIN_IS_SYNTH;

  801. 

  802.         if (fEffect->flags & effFlagsHasEditor)

  803.         {

  804.             fHints |= PLUGIN_HAS_GUI;

  805. 

  806.             if (! fGui.isOsc)

  807.                 fHints |= PLUGIN_HAS_SINGLE_THREAD;

  808.         }

  809. 

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

  811.             fHints |= PLUGIN_USES_OLD_VSTSDK;

  812. 

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

  814.             fHints |= PLUGIN_CAN_PROCESS_REPLACING;

  815. 

  816.         if (fEffect->flags & effFlagsHasEditor)

  817.             fHints |= PLUGIN_HAS_GUI;

  818. 

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

  820.             fHints |= PLUGIN_HAS_COCKOS_EXTENSIONS;

  821. 

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

  823.             fHints |= PLUGIN_CAN_DRYWET;

  824. 

  825.         if (aOuts > 0)

  826.             fHints |= PLUGIN_CAN_VOLUME;

  827. 

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

  829.             fHints |= PLUGIN_CAN_BALANCE;

  830. 

  831.         // extra plugin hints

  832.         kData->extraHints = 0x0;

  833. 

  834.         if (mIns > 0)

  835.             kData->extraHints |= PLUGIN_HINT_HAS_MIDI_IN;

  836. 

  837.         if (mOuts > 0)

  838.             kData->extraHints |= PLUGIN_HINT_HAS_MIDI_OUT;

  839. 

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

  841.             kData->extraHints |= PLUGIN_HINT_CAN_RUN_RACK;

  842. 

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

  844.         {

  845.             activate();

  846.             deactivate();

  847.         }

  848. 

  849.         // check latency

  850.         if (fHints & PLUGIN_CAN_DRYWET)

  851.         {

  852. #ifdef VESTIGE_HEADER

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

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

  855.             kData->latency = *initialDelayPtr;

  856. #else

  857.             kData->latency = fEffect->initialDelay;

  858. #endif

  859. 

  860.             kData->client->setLatency(kData->latency);

  861.             kData->recreateLatencyBuffers();

  862.         }

  863. 

  864.         // special plugin fixes

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

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

  867.         {

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

  869.             getLabel(strBuf);

  870. 

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

  872.             {

  873.                 // TODO - disable threaded processing

  874.             }

  875.         }

  876. 

  877.         bufferSizeChanged(kData->engine->getBufferSize());

  878.         reloadPrograms(true);

  879. 

  880.         if (kData->active)

  881.             activate();

  882. 

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

  884.     }

  885. 

  886.     void reloadPrograms(const bool init) override

  887.     {

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

  889.         uint32_t i, oldCount  = kData->prog.count;

  890.         const int32_t current = kData->prog.current;

  891. 

  892.         // Delete old programs

  893.         kData->prog.clear();

  894. 

  895.         // Query new programs

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

  897. 

  898.         if (count > 0)

  899.         {

  900.             kData->prog.createNew(count);

  901. 

  902.             // Update names

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

  904.             {

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

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

  907.                 {

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

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

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

  911.                 }

  912.                 kData->prog.names[i] = strdup(strBuf);

  913.             }

  914.         }

  915. 

  916. #ifndef BUILD_BRIDGE

  917.         // Update OSC Names

  918.         if (kData->engine->isOscControlRegistered())

  919.         {

  920.             kData->engine->osc_send_control_set_program_count(fId, count);

  921. 

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

  923.                 kData->engine->osc_send_control_set_program_name(fId, i, kData->prog.names[i]);

  924.         }

  925. #endif

  926. 

  927.         if (init)

  928.         {

  929.             if (count > 0)

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

  931.         }

  932.         else

  933.         {

  934.             // Check if current program is invalid

  935.             bool programChanged = false;

  936. 

  937.             if (count == oldCount+1)

  938.             {

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

  940.                 kData->prog.current = oldCount;

  941.                 programChanged = true;

  942.             }

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

  944.             {

  945.                 // programs exist now, but not before

  946.                 kData->prog.current = 0;

  947.                 programChanged = true;

  948.             }

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

  950.             {

  951.                 // programs existed before, but not anymore

  952.                 kData->prog.current = -1;

  953.                 programChanged = true;

  954.             }

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

  956.             {

  957.                 // current program > count

  958.                 kData->prog.current = 0;

  959.                 programChanged = true;

  960.             }

  961.             else

  962.             {

  963.                 // no change

  964.                 kData->prog.current = current;

  965.             }

  966. 

  967.             if (programChanged)

  968.             {

  969.                 setProgram(kData->prog.current, true, true, true);

  970.             }

  971.             else

  972.             {

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

  974.                 if (kData->prog.current >= 0)

  975.                     dispatcher(effSetProgram, 0, kData->prog.current, nullptr, 0.0f);

  976.             }

  977. 

  978.             kData->engine->callback(CALLBACK_RELOAD_PROGRAMS, fId, 0, 0, 0.0f, nullptr);

  979.         }

  980.     }

  981. 

  982.     // -------------------------------------------------------------------

  983.     // Plugin processing

  984. 

  985.     void activate() override

  986.     {

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

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

  989.     }

  990. 

  991.     void deactivate() override

  992.     {

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

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

  995.     }

  996. 

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

  998.     {

  999.         uint32_t i, k;

  1000. 

  1001.         // --------------------------------------------------------------------------------------------------------

  1002.         // Check if active

  1003. 

  1004.         if (! kData->active)

  1005.         {

  1006.             // disable any output sound

  1007.             for (i=0; i < kData->audioOut.count; ++i)

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

  1009. 

  1010.             return;

  1011.         }

  1012. 

  1013.         fMidiEventCount = 0;

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

  1015. 

  1016.         // --------------------------------------------------------------------------------------------------------

  1017.         // Check if needs reset

  1018. 

  1019.         if (kData->needsReset)

  1020.         {

  1021.             if (fOptions & PLUGIN_OPTION_SEND_ALL_SOUND_OFF)

  1022.             {

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

  1024.                 {

  1025.                     fMidiEvents[k].type = kVstMidiType;

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

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

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

  1029. 

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

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

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

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

  1034.                 }

  1035. 

  1036.                 fMidiEventCount = MAX_MIDI_CHANNELS*2;

  1037.             }

  1038.             else if (kData->ctrlChannel >= 0 && kData->ctrlChannel < MAX_MIDI_CHANNELS)

  1039.             {

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

  1041.                 {

  1042.                     fMidiEvents[k].type = kVstMidiType;

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

  1044.                     fMidiEvents[k].midiData[0] = MIDI_STATUS_NOTE_OFF + kData->ctrlChannel;

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

  1046.                 }

  1047. 

  1048.                 fMidiEventCount = MAX_MIDI_NOTE;

  1049.             }

  1050. 

  1051.             if (kData->latency > 0)

  1052.             {

  1053.                 for (i=0; i < kData->audioIn.count; ++i)

  1054.                     carla_zeroFloat(kData->latencyBuffers[i], kData->latency);

  1055.             }

  1056. 

  1057.             kData->needsReset = false;

  1058.         }

  1059. 

  1060.         CARLA_PROCESS_CONTINUE_CHECK;

  1061. 

  1062.         // --------------------------------------------------------------------------------------------------------

  1063.         // Set TimeInfo

  1064. 

  1065.         const EngineTimeInfo& timeInfo(kData->engine->getTimeInfo());

  1066. 

  1067.         fTimeInfo.flags = kVstTransportChanged;

  1068. 

  1069.         if (timeInfo.playing)

  1070.             fTimeInfo.flags |= kVstTransportPlaying;

  1071. 

  1072.         fTimeInfo.samplePos  = timeInfo.frame;

  1073.         fTimeInfo.sampleRate = kData->engine->getSampleRate();

  1074. 

  1075.         if (timeInfo.usecs != 0)

  1076.         {

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

  1078.             fTimeInfo.flags |= kVstNanosValid;

  1079.         }

  1080. 

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

  1082.         {

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

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

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

  1086. 

  1087.             // PPQ Pos

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

  1089.             fTimeInfo.flags |= kVstPpqPosValid;

  1090. 

  1091.             // Tempo

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

  1093.             fTimeInfo.flags |= kVstTempoValid;

  1094. 

  1095.             // Bars

  1096.             fTimeInfo.barStartPos = ppqBar;

  1097.             fTimeInfo.flags |= kVstBarsValid;

  1098. 

  1099.             // Time Signature

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

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

  1102.             fTimeInfo.flags |= kVstTimeSigValid;

  1103.         }

  1104.         else

  1105.         {

  1106.             // Tempo

  1107.             fTimeInfo.tempo = 120.0;

  1108.             fTimeInfo.flags |= kVstTempoValid;

  1109. 

  1110.             // Time Signature

  1111.             fTimeInfo.timeSigNumerator   = 4;

  1112.             fTimeInfo.timeSigDenominator = 4;

  1113.             fTimeInfo.flags |= kVstTimeSigValid;

  1114. 

  1115.             // Missing info

  1116.             fTimeInfo.ppqPos = 0.0;

  1117.             fTimeInfo.barStartPos = 0.0;

  1118.         }

  1119. 

  1120.         CARLA_PROCESS_CONTINUE_CHECK;

  1121. 

  1122.         // --------------------------------------------------------------------------------------------------------

  1123.         // Event Input and Processing

  1124. 

  1125.         if (kData->event.portIn != nullptr)

  1126.         {

  1127.             // ----------------------------------------------------------------------------------------------------

  1128.             // MIDI Input (External)

  1129. 

  1130.             if (kData->extNotes.mutex.tryLock())

  1131.             {

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

  1133.                 {

  1134.                     const ExternalMidiNote& note(kData->extNotes.data.getFirst(true));

  1135. 

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

  1137. 

  1138.                     fMidiEvents[fMidiEventCount].type = kVstMidiType;

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

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

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

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

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

  1144. 

  1145.                     fMidiEventCount += 1;

  1146.                 }

  1147. 

  1148.                 kData->extNotes.mutex.unlock();

  1149. 

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

  1151. 

  1152.             // ----------------------------------------------------------------------------------------------------

  1153.             // Event Input (System)

  1154. 

  1155.             bool allNotesOffSent = false;

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

  1157. 

  1158.             uint32_t time, nEvents = kData->event.portIn->getEventCount();

  1159.             uint32_t startTime  = 0;

  1160.             uint32_t timeOffset = 0;

  1161. 

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

  1163.             {

  1164.                 const EngineEvent& event(kData->event.portIn->getEvent(i));

  1165. 

  1166.                 time = event.time;

  1167. 

  1168.                 if (time >= frames)

  1169.                     continue;

  1170. 

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

  1172. 

  1173.                 if (time > timeOffset && sampleAccurate)

  1174.                 {

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

  1176.                     {

  1177.                         startTime  = 0;

  1178.                         timeOffset = time;

  1179. 

  1180.                         if (fMidiEventCount > 0)

  1181.                         {

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

  1183.                             fMidiEventCount = 0;

  1184.                         }

  1185.                     }

  1186.                     else

  1187.                         startTime += timeOffset;

  1188.                 }

  1189. 

  1190.                 // Control change

  1191.                 switch (event.type)

  1192.                 {

  1193.                 case kEngineEventTypeNull:

  1194.                     break;

  1195. 

  1196.                 case kEngineEventTypeControl:

  1197.                 {

  1198.                     const EngineControlEvent& ctrlEvent = event.ctrl;

  1199. 

  1200.                     switch (ctrlEvent.type)

  1201.                     {

  1202.                     case kEngineControlEventTypeNull:

  1203.                         break;

  1204. 

  1205.                     case kEngineControlEventTypeParameter:

  1206.                     {

  1207. #ifndef BUILD_BRIDGE

  1208.                         // Control backend stuff

  1209.                         if (event.channel == kData->ctrlChannel)

  1210.                         {

  1211.                             float value;

  1212. 

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

  1214.                             {

  1215.                                 value = ctrlEvent.value;

  1216.                                 setDryWet(value, false, false);

  1217.                                 postponeRtEvent(kPluginPostRtEventParameterChange, PARAMETER_DRYWET, 0, value);

  1218.                             }

  1219. 

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

  1221.                             {

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

  1223.                                 setVolume(value, false, false);

  1224.                                 postponeRtEvent(kPluginPostRtEventParameterChange, PARAMETER_VOLUME, 0, value);

  1225.                             }

  1226. 

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

  1228.                             {

  1229.                                 float left, right;

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

  1231. 

  1232.                                 if (value < 0.0f)

  1233.                                 {

  1234.                                     left  = -1.0f;

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

  1236.                                 }

  1237.                                 else if (value > 0.0f)

  1238.                                 {

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

  1240.                                     right = 1.0f;

  1241.                                 }

  1242.                                 else

  1243.                                 {

  1244.                                     left  = -1.0f;

  1245.                                     right = 1.0f;

  1246.                                 }

  1247. 

  1248.                                 setBalanceLeft(left, false, false);

  1249.                                 setBalanceRight(right, false, false);

  1250.                                 postponeRtEvent(kPluginPostRtEventParameterChange, PARAMETER_BALANCE_LEFT, 0, left);

  1251.                                 postponeRtEvent(kPluginPostRtEventParameterChange, PARAMETER_BALANCE_RIGHT, 0, right);

  1252.                             }

  1253.                         }

  1254. #endif

  1255. 

  1256.                         // Control plugin parameters

  1257.                         for (k=0; k < kData->param.count; ++k)

  1258.                         {

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

  1260.                                 continue;

  1261.                             if (kData->param.data[k].midiCC != ctrlEvent.param)

  1262.                                 continue;

  1263.                             if (kData->param.data[k].type != PARAMETER_INPUT)

  1264.                                 continue;

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

  1266.                                 continue;

  1267. 

  1268.                             float value;

  1269. 

  1270.                             if (kData->param.data[k].hints & PARAMETER_IS_BOOLEAN)

  1271.                             {

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

  1273.                             }

  1274.                             else

  1275.                             {

  1276.                                 value = kData->param.ranges[k].unnormalizeValue(ctrlEvent.value);

  1277. 

  1278.                                 if (kData->param.data[k].hints & PARAMETER_IS_INTEGER)

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

  1280.                             }

  1281. 

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

  1283.                             postponeRtEvent(kPluginPostRtEventParameterChange, static_cast<int32_t>(k), 0, value);

  1284.                         }

  1285. 

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

  1287.                         {

  1288.                             if (fMidiEventCount >= MAX_MIDI_EVENTS*2)

  1289.                                 continue;

  1290. 

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

  1292. 

  1293.                             fMidiEvents[fMidiEventCount].type = kVstMidiType;

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

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

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

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

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

  1299. 

  1300.                             fMidiEventCount += 1;

  1301.                         }

  1302. 

  1303.                         break;

  1304.                     }

  1305. 

  1306.                     case kEngineControlEventTypeMidiBank:

  1307.                         break;

  1308. 

  1309.                     case kEngineControlEventTypeMidiProgram:

  1310.                         if (event.channel == kData->ctrlChannel && (fOptions & PLUGIN_OPTION_MAP_PROGRAM_CHANGES) != 0)

  1311.                         {

  1312.                             if (ctrlEvent.param < kData->prog.count)

  1313.                             {

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

  1315.                                 postponeRtEvent(kPluginPostRtEventProgramChange, ctrlEvent.param, 0, 0.0f);

  1316.                                 break;

  1317.                             }

  1318.                         }

  1319.                         break;

  1320. 

  1321.                     case kEngineControlEventTypeAllSoundOff:

  1322.                         if (fOptions & PLUGIN_OPTION_SEND_ALL_SOUND_OFF)

  1323.                         {

  1324.                             if (fMidiEventCount >= MAX_MIDI_EVENTS*2)

  1325.                                 continue;

  1326. 

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

  1328. 

  1329.                             fMidiEvents[fMidiEventCount].type = kVstMidiType;

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

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

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

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

  1334. 

  1335.                             fMidiEventCount += 1;

  1336.                         }

  1337.                         break;

  1338. 

  1339.                     case kEngineControlEventTypeAllNotesOff:

  1340.                         if (fOptions & PLUGIN_OPTION_SEND_ALL_SOUND_OFF)

  1341.                         {

  1342.                             if (event.channel == kData->ctrlChannel && ! allNotesOffSent)

  1343.                             {

  1344.                                 allNotesOffSent = true;

  1345.                                 sendMidiAllNotesOffToCallback();

  1346.                             }

  1347. 

  1348.                             if (fMidiEventCount >= MAX_MIDI_EVENTS*2)

  1349.                                 continue;

  1350. 

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

  1352. 

  1353.                             fMidiEvents[fMidiEventCount].type = kVstMidiType;

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

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

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

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

  1358. 

  1359.                             fMidiEventCount += 1;

  1360.                         }

  1361.                         break;

  1362.                     }

  1363. 

  1364.                     break;

  1365.                 }

  1366. 

  1367.                 case kEngineEventTypeMidi:

  1368.                 {

  1369.                     if (fMidiEventCount >= MAX_MIDI_EVENTS*2)

  1370.                         continue;

  1371. 

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

  1373. 

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

  1375.                     uint8_t channel = event.channel;

  1376. 

  1377.                     if (MIDI_IS_STATUS_AFTERTOUCH(status) && (fOptions & PLUGIN_OPTION_SEND_CHANNEL_PRESSURE) == 0)

  1378.                         continue;

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

  1380.                         continue;

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

  1382.                         continue;

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

  1384.                         continue;

  1385. 

  1386.                     // Fix bad note-off

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

  1388.                         status -= 0x10;

  1389. 

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

  1391. 

  1392.                     fMidiEvents[fMidiEventCount].type = kVstMidiType;

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

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

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

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

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

  1398. 

  1399.                     fMidiEventCount += 1;

  1400. 

  1401.                     if (status == MIDI_STATUS_NOTE_ON)

  1402.                         postponeRtEvent(kPluginPostRtEventNoteOn, channel, midiEvent.data[1], midiEvent.data[2]);

  1403.                     else if (status == MIDI_STATUS_NOTE_OFF)

  1404.                         postponeRtEvent(kPluginPostRtEventNoteOff, channel, midiEvent.data[1], 0.0f);

  1405. 

  1406.                     break;

  1407.                 }

  1408.                 }

  1409.             }

  1410. 

  1411.             kData->postRtEvents.trySplice();

  1412. 

  1413.             if (frames > timeOffset)

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

  1415. 

  1416.         } // End of Event Input and Processing

  1417. 

  1418.         // --------------------------------------------------------------------------------------------------------

  1419.         // Plugin processing (no events)

  1420. 

  1421.         else

  1422.         {

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

  1424. 

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

  1426. 

  1427.         CARLA_PROCESS_CONTINUE_CHECK;

  1428. 

  1429.         // --------------------------------------------------------------------------------------------------------

  1430.         // MIDI Output

  1431. 

  1432.         if (kData->event.portOut != nullptr)

  1433.         {

  1434.             // reverse lookup MIDI events

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

  1436.             {

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

  1438.                     break;

  1439. 

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

  1441. 

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

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

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

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

  1446. 

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

  1448.             }

  1449. 

  1450.         } // End of Control and MIDI Output

  1451.     }

  1452. 

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

  1454.     {

  1455.         CARLA_ASSERT(frames > 0);

  1456. 

  1457.         if (frames == 0)

  1458.             return false;

  1459. 

  1460.         if (kData->audioIn.count > 0)

  1461.         {

  1462.             CARLA_ASSERT(inBuffer != nullptr);

  1463.             if (inBuffer == nullptr)

  1464.                 return false;

  1465.         }

  1466.         if (kData->audioOut.count > 0)

  1467.         {

  1468.             CARLA_ASSERT(outBuffer != nullptr);

  1469.             if (outBuffer == nullptr)

  1470.                 return false;

  1471.         }

  1472. 

  1473.         uint32_t i, k;

  1474. 

  1475.         // --------------------------------------------------------------------------------------------------------

  1476.         // Try lock, silence otherwise

  1477. 

  1478.         if (kData->engine->isOffline())

  1479.         {

  1480.             kData->singleMutex.lock();

  1481.         }

  1482.         else if (! kData->singleMutex.tryLock())

  1483.         {

  1484.             for (i=0; i < kData->audioOut.count; ++i)

  1485.             {

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

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

  1488.             }

  1489. 

  1490.             return false;

  1491.         }

  1492. 

  1493.         // --------------------------------------------------------------------------------------------------------

  1494.         // Set audio buffers

  1495. 

  1496.         float* vstInBuffer[kData->audioIn.count];

  1497.         float* vstOutBuffer[kData->audioOut.count];

  1498. 

  1499.         for (i=0; i < kData->audioIn.count; ++i)

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

  1501.         for (i=0; i < kData->audioOut.count; ++i)

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

  1503. 

  1504.         // --------------------------------------------------------------------------------------------------------

  1505.         // Set MIDI events

  1506. 

  1507.         if (fMidiEventCount > 0)

  1508.         {

  1509.             fEvents.numEvents = fMidiEventCount;

  1510.             fEvents.reserved  = 0;

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

  1512.         }

  1513. 

  1514.         // --------------------------------------------------------------------------------------------------------

  1515.         // Run plugin

  1516. 

  1517.         fIsProcessing = true;

  1518. 

  1519.         if (fHints & PLUGIN_CAN_PROCESS_REPLACING)

  1520.         {

  1521.             fEffect->processReplacing(fEffect,

  1522.                                       (kData->audioIn.count > 0) ? vstInBuffer : nullptr,

  1523.                                       (kData->audioOut.count > 0) ? vstOutBuffer : nullptr,

  1524.                                       frames);

  1525.         }

  1526.         else

  1527.         {

  1528.             for (i=0; i < kData->audioOut.count; ++i)

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

  1530. 

  1531. #if ! VST_FORCE_DEPRECATED

  1532.             fEffect->process(fEffect,

  1533.                              (kData->audioIn.count > 0) ? vstInBuffer : nullptr,

  1534.                              (kData->audioOut.count > 0) ? vstOutBuffer : nullptr,

  1535.                              frames);

  1536. #endif

  1537.         }

  1538. 

  1539.         fIsProcessing = false;

  1540.         fTimeInfo.samplePos += frames;

  1541. 

  1542. #ifndef BUILD_BRIDGE

  1543.         // --------------------------------------------------------------------------------------------------------

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

  1545. 

  1546.         {

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

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

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

  1550. 

  1551.             bool isPair;

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

  1553. 

  1554.             for (i=0; i < kData->audioOut.count; ++i)

  1555.             {

  1556.                 // Dry/Wet

  1557.                 if (doDryWet)

  1558.                 {

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

  1560.                     {

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

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

  1563.                     }

  1564.                 }

  1565. 

  1566.                 // Balance

  1567.                 if (doBalance)

  1568.                 {

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

  1570. 

  1571.                     if (isPair)

  1572.                     {

  1573.                         CARLA_ASSERT(i+1 < kData->audioOut.count);

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

  1575.                     }

  1576. 

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

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

  1579. 

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

  1581.                     {

  1582.                         if (isPair)

  1583.                         {

  1584.                             // left

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

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

  1587.                         }

  1588.                         else

  1589.                         {

  1590.                             // right

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

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

  1593.                         }

  1594.                     }

  1595.                 }

  1596. 

  1597.                 // Volume

  1598.                 if (doVolume)

  1599.                 {

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

  1601.                         outBuffer[i][k+timeOffset] *= kData->postProc.volume;

  1602.                 }

  1603.             }

  1604. 

  1605.         } // End of Post-processing

  1606. #endif

  1607. 

  1608.         // --------------------------------------------------------------------------------------------------------

  1609. 

  1610.         kData->singleMutex.unlock();

  1611.         return true;

  1612.     }

  1613. 

  1614.     void bufferSizeChanged(const uint32_t newBufferSize) override

  1615.     {

  1616.         CARLA_ASSERT_INT(newBufferSize > 0, newBufferSize);

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

  1618. 

  1619.         if (kData->active)

  1620.             deactivate();

  1621. 

  1622. #if ! VST_FORCE_DEPRECATED

  1623.         dispatcher(effSetBlockSizeAndSampleRate, 0, newBufferSize, nullptr, kData->engine->getSampleRate());

  1624. #endif

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

  1626. 

  1627.         if (kData->active)

  1628.             activate();

  1629.     }

  1630. 

  1631.     void sampleRateChanged(const double newSampleRate) override

  1632.     {

  1633.         CARLA_ASSERT_INT(newSampleRate > 0.0, newSampleRate);

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

  1635. 

  1636.         if (kData->active)

  1637.             deactivate();

  1638. 

  1639. #if ! VST_FORCE_DEPRECATED

  1640.         dispatcher(effSetBlockSizeAndSampleRate, 0, kData->engine->getBufferSize(), nullptr, newSampleRate);

  1641. #endif

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

  1643. 

  1644.         if (kData->active)

  1645.             activate();

  1646.     }

  1647. 

  1648.     // -------------------------------------------------------------------

  1649.     // Plugin buffers

  1650. 

  1651.     // nothing

  1652. 

  1653.     // -------------------------------------------------------------------

  1654.     // Post-poned UI Stuff

  1655. 

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

  1657.     {

  1658.         CARLA_ASSERT(index < kData->param.count);

  1659. 

  1660.         if (index >= kData->param.count)

  1661.             return;

  1662.         if (! fGui.isOsc)

  1663.             return;

  1664.         if (kData->osc.data.target == nullptr)

  1665.             return;

  1666. 

  1667.         osc_send_control(&kData->osc.data, kData->param.data[index].rindex, value);

  1668.     }

  1669. 

  1670.     void uiProgramChange(const uint32_t index) override

  1671.     {

  1672.         CARLA_ASSERT(index < kData->prog.count);

  1673. 

  1674.         if (index >= kData->prog.count)

  1675.             return;

  1676.         if (! fGui.isOsc)

  1677.             return;

  1678.         if (kData->osc.data.target == nullptr)

  1679.             return;

  1680. 

  1681.         osc_send_program(&kData->osc.data, index);

  1682.     }

  1683. 

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

  1685.     {

  1686.         CARLA_ASSERT(channel < MAX_MIDI_CHANNELS);

  1687.         CARLA_ASSERT(note < MAX_MIDI_NOTE);

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

  1689. 

  1690.         if (channel >= MAX_MIDI_CHANNELS)

  1691.             return;

  1692.         if (note >= MAX_MIDI_NOTE)

  1693.             return;

  1694.         if (velo >= MAX_MIDI_VALUE)

  1695.             return;

  1696.         if (! fGui.isOsc)

  1697.             return;

  1698.         if (kData->osc.data.target == nullptr)

  1699.             return;

  1700. 

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

  1702.         midiData[1] = MIDI_STATUS_NOTE_ON + channel;

  1703.         midiData[2] = note;

  1704.         midiData[3] = velo;

  1705. 

  1706.         osc_send_midi(&kData->osc.data, midiData);

  1707.     }

  1708. 

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

  1710.     {

  1711.         CARLA_ASSERT(channel < MAX_MIDI_CHANNELS);

  1712.         CARLA_ASSERT(note < MAX_MIDI_NOTE);

  1713. 

  1714.         if (channel >= MAX_MIDI_CHANNELS)

  1715.             return;

  1716.         if (note >= MAX_MIDI_NOTE)

  1717.             return;

  1718.         if (! fGui.isOsc)

  1719.             return;

  1720.         if (kData->osc.data.target == nullptr)

  1721.             return;

  1722. 

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

  1724.         midiData[1] = MIDI_STATUS_NOTE_OFF + channel;

  1725.         midiData[2] = note;

  1726. 

  1727.         osc_send_midi(&kData->osc.data, midiData);

  1728.     }

  1729. 

  1730.     // -------------------------------------------------------------------

  1731. 

  1732. protected:

  1733.     void guiClosedCallback() override

  1734.     {

  1735.         showGui(false);

  1736.         kData->engine->callback(CALLBACK_SHOW_GUI, fId, 0, 0, 0.0f, nullptr);

  1737.     }

  1738. 

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

  1740.     {

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

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

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

  1744. #endif

  1745.         CARLA_ASSERT(fEffect != nullptr);

  1746. 

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

  1748.     }

  1749. 

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

  1751.     {

  1752. #if 0

  1753.         // Cockos VST extensions

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

  1755.         {

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

  1757. 

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

  1759.                 return 0;

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

  1761.                 return 0;

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

  1763.                 return 0;

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

  1765.                 return 0;

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

  1767.                 return 0;

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

  1769.                 return 0;

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

  1771.                 return 0;

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

  1773.                 return 0;

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

  1775.                 return 0;

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

  1777.                 return 0;

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

  1779.                 return 0;

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

  1781.                 return 0;

  1782.         }

  1783. #endif

  1784. 

  1785.         intptr_t ret = 0;

  1786. 

  1787.         switch (opcode)

  1788.         {

  1789.         case audioMasterAutomate:

  1790.             if (! fEnabled)

  1791.                 break;

  1792. 

  1793.             // plugins should never do this:

  1794.             CARLA_SAFE_ASSERT_INT(index < static_cast<int32_t>(kData->param.count), index);

  1795. 

  1796.             if (index < 0 || index >= static_cast<int32_t>(kData->param.count))

  1797.                 break;

  1798. 

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

  1800.             {

  1801.                 // Called from GUI

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

  1803.             }

  1804.             else if (fIsProcessing)

  1805.             {

  1806.                 // Called from engine

  1807.                 const float fixedValue(kData->param.fixValue(index, opt));

  1808. 

  1809.                 if (kData->engine->isOffline())

  1810.                 {

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

  1812.                 }

  1813.                 else

  1814.                 {

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

  1816.                     postponeRtEvent(kPluginPostRtEventParameterChange, index, 0, fixedValue);

  1817.                 }

  1818.             }

  1819.             else

  1820.             {

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

  1822.             }

  1823.             break;

  1824. 

  1825.         case audioMasterCurrentId:

  1826.             // TODO

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

  1828.             break;

  1829. 

  1830.         case audioMasterIdle:

  1831.             if (fGui.isVisible)

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

  1833.             break;

  1834. 

  1835. #if ! VST_FORCE_DEPRECATED

  1836.         case audioMasterPinConnected:

  1837.             // Deprecated in VST SDK 2.4

  1838.             // TODO

  1839.             break;

  1840. 

  1841.         case audioMasterWantMidi:

  1842.             // Deprecated in VST SDK 2.4

  1843.             fHints |= PLUGIN_WANTS_MIDI_INPUT;

  1844.             break;

  1845. #endif

  1846. 

  1847.         case audioMasterGetTime:

  1848. #ifdef VESTIGE_HEADER

  1849.             ret = getAddressFromPointer(&fTimeInfo);

  1850. #else

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

  1852. #endif

  1853.             break;

  1854. 

  1855.         case audioMasterProcessEvents:

  1856.             CARLA_ASSERT(fEnabled);

  1857.             CARLA_ASSERT(fIsProcessing);

  1858.             CARLA_ASSERT(kData->event.portOut != nullptr);

  1859.             CARLA_ASSERT(ptr != nullptr);

  1860. 

  1861.             if (! fEnabled)

  1862.                 return 0;

  1863.             if (! fIsProcessing)

  1864.                 return 0;

  1865.             if (kData->event.portOut == nullptr)

  1866.                 return 0;

  1867.             if (ptr == nullptr)

  1868.                 return 0;

  1869.             if (! fIsProcessing)

  1870.             {

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

  1872.                 return 0;

  1873.             }

  1874. 

  1875.             if (fMidiEventCount >= MAX_MIDI_EVENTS*2)

  1876.                 return 0;

  1877. 

  1878. 

  1879.         {

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

  1881. 

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

  1883.             {

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

  1885.                     break;

  1886. 

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

  1888. 

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

  1890.                     continue;

  1891. 

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

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

  1894.                 {

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

  1896.                     {

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

  1898.                         break;

  1899.                     }

  1900.                 }

  1901.             }

  1902.         }

  1903. 

  1904.             ret = 1;

  1905.             break;

  1906. 

  1907. #if ! VST_FORCE_DEPRECATED

  1908.         case audioMasterSetTime:

  1909.             // Deprecated in VST SDK 2.4

  1910.             break;

  1911. 

  1912.         case audioMasterTempoAt:

  1913.             // Deprecated in VST SDK 2.4

  1914.             CARLA_ASSERT(fIsProcessing);

  1915.             ret = fTimeInfo.tempo * 10000;

  1916.             break;

  1917. 

  1918.         case audioMasterGetNumAutomatableParameters:

  1919.             // Deprecated in VST SDK 2.4

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

  1921.             break;

  1922. 

  1923.         case audioMasterGetParameterQuantization:

  1924.             // Deprecated in VST SDK 2.4

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

  1926.             break;

  1927. #endif

  1928. 

  1929. #if 0

  1930.         case audioMasterIOChanged:

  1931.             CARLA_ASSERT(fEnabled);

  1932. 

  1933.             // TESTING

  1934. 

  1935.             if (! fEnabled)

  1936.             {

  1937.                 ret = 1;

  1938.                 break;

  1939.             }

  1940. 

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

  1942.             {

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

  1944.                 return 0;

  1945.             }

  1946. 

  1947.             engineProcessLock();

  1948.             m_enabled = false;

  1949.             engineProcessUnlock();

  1950. 

  1951.             if (m_active)

  1952.             {

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

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

  1955.             }

  1956. 

  1957.             reload();

  1958. 

  1959.             if (m_active)

  1960.             {

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

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

  1963.             }

  1964. 

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

  1966. 

  1967.             ret = 1;

  1968.             break;

  1969. #endif

  1970. 

  1971.         case audioMasterNeedIdle:

  1972.             // Deprecated in VST SDK 2.4

  1973.             fNeedIdle = true;

  1974.             ret = 1;

  1975.             break;

  1976. 

  1977.         case audioMasterSizeWindow:

  1978.             if (kData->gui != nullptr)

  1979.             {

  1980.                 CARLA_SAFE_ASSERT(fGui.isVisible);

  1981.                 if (fGui.isVisible)

  1982.                     kData->gui->setSize(index, value);

  1983.                 ret = 1;

  1984.             }

  1985.             break;

  1986. 

  1987.         case audioMasterGetSampleRate:

  1988.             ret = kData->engine->getSampleRate();

  1989.             break;

  1990. 

  1991.         case audioMasterGetBlockSize:

  1992.             ret = kData->engine->getBufferSize();

  1993.             break;

  1994. 

  1995.         case audioMasterGetInputLatency:

  1996.             ret = 0;

  1997.             break;

  1998. 

  1999.         case audioMasterGetOutputLatency:

  2000.             ret = 0;

  2001.             break;

  2002. 

  2003. #if ! VST_FORCE_DEPRECATED

  2004.         case audioMasterGetPreviousPlug:

  2005.             // Deprecated in VST SDK 2.4

  2006.             // TODO

  2007.             break;

  2008. 

  2009.         case audioMasterGetNextPlug:

  2010.             // Deprecated in VST SDK 2.4

  2011.             // TODO

  2012.             break;

  2013. 

  2014.         case audioMasterWillReplaceOrAccumulate:

  2015.             // Deprecated in VST SDK 2.4

  2016.             ret = 1; // replace

  2017.             break;

  2018. #endif

  2019. 

  2020.         case audioMasterGetCurrentProcessLevel:

  2021.             if (kData->engine->isOffline())

  2022.                 ret = kVstProcessLevelOffline;

  2023.             else if (fIsProcessing)

  2024.                 ret = kVstProcessLevelRealtime;

  2025.             else

  2026.                 ret = kVstProcessLevelUser;

  2027.             break;

  2028. 

  2029.         case audioMasterGetAutomationState:

  2030.             ret = kData->active ? kVstAutomationReadWrite : kVstAutomationOff;

  2031.             break;

  2032. 

  2033.         case audioMasterOfflineStart:

  2034.         case audioMasterOfflineRead:

  2035.         case audioMasterOfflineWrite:

  2036.         case audioMasterOfflineGetCurrentPass:

  2037.         case audioMasterOfflineGetCurrentMetaPass:

  2038.             // TODO

  2039.             break;

  2040. 

  2041. #if ! VST_FORCE_DEPRECATED

  2042.         case audioMasterSetOutputSampleRate:

  2043.             // Deprecated in VST SDK 2.4

  2044.             break;

  2045. 

  2046.         case audioMasterGetOutputSpeakerArrangement:

  2047.             // Deprecated in VST SDK 2.4

  2048.             // TODO

  2049.             break;

  2050. #endif

  2051. 

  2052.         case audioMasterVendorSpecific:

  2053.             // TODO - cockos extensions

  2054.             break;

  2055. 

  2056. #if ! VST_FORCE_DEPRECATED

  2057.         case audioMasterSetIcon:

  2058.             // Deprecated in VST SDK 2.4

  2059.             break;

  2060. #endif

  2061. 

  2062. #if ! VST_FORCE_DEPRECATED

  2063.         case audioMasterOpenWindow:

  2064.         case audioMasterCloseWindow:

  2065.             // Deprecated in VST SDK 2.4

  2066.             // TODO

  2067.             break;

  2068. #endif

  2069. 

  2070.         case audioMasterGetDirectory:

  2071.             // TODO

  2072.             break;

  2073. 

  2074.         case audioMasterUpdateDisplay:

  2075.             // Idle UI if visible

  2076.             if (fGui.isVisible)

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

  2078. 

  2079.             // Update current program

  2080.             if (kData->prog.count > 0)

  2081.             {

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

  2083. 

  2084.                 if (current >= 0 && current < static_cast<int32_t>(kData->prog.count))

  2085.                 {

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

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

  2088. 

  2089.                     if (kData->prog.names[current] != nullptr)

  2090.                         delete[] kData->prog.names[current];

  2091. 

  2092.                     kData->prog.names[current] = carla_strdup(strBuf);

  2093. 

  2094.                     if (kData->prog.current != current)

  2095.                     {

  2096.                         kData->prog.current = current;

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

  2098.                     }

  2099.                 }

  2100.             }

  2101. 

  2102.             kData->engine->callback(CALLBACK_UPDATE, fId, 0, 0, 0.0f, nullptr);

  2103.             ret = 1;

  2104.             break;

  2105. 

  2106.         case audioMasterBeginEdit:

  2107.         case audioMasterEndEdit:

  2108.             // TODO

  2109.             break;

  2110. 

  2111.         case audioMasterOpenFileSelector:

  2112.         case audioMasterCloseFileSelector:

  2113.             // TODO

  2114.             break;

  2115. 

  2116. #if ! VST_FORCE_DEPRECATED

  2117.         case audioMasterEditFile:

  2118.             // Deprecated in VST SDK 2.4

  2119.             // TODO

  2120.             break;

  2121. 

  2122.         case audioMasterGetChunkFile:

  2123.             // Deprecated in VST SDK 2.4

  2124.             // TODO

  2125.             break;

  2126. 

  2127.         case audioMasterGetInputSpeakerArrangement:

  2128.             // Deprecated in VST SDK 2.4

  2129.             // TODO

  2130.             break;

  2131. #endif

  2132. 

  2133.         default:

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

  2135.             break;

  2136.         }

  2137. 

  2138.         return ret;

  2139.     }

  2140. 

  2141.     // -------------------------------------------------------------------

  2142. 

  2143. public:

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

  2145.     {

  2146.         CARLA_ASSERT(kData->engine != nullptr);

  2147.         CARLA_ASSERT(kData->client == nullptr);

  2148.         CARLA_ASSERT(filename != nullptr);

  2149. 

  2150.         // ---------------------------------------------------------------

  2151.         // first checks

  2152. 

  2153.         if (kData->engine == nullptr)

  2154.         {

  2155.             return false;

  2156.         }

  2157. 

  2158.         if (kData->client != nullptr)

  2159.         {

  2160.             kData->engine->setLastError("Plugin client is already registered");

  2161.             return false;

  2162.         }

  2163. 

  2164.         if (filename == nullptr)

  2165.         {

  2166.             kData->engine->setLastError("null filename");

  2167.             return false;

  2168.         }

  2169. 

  2170.         // ---------------------------------------------------------------

  2171.         // open DLL

  2172. 

  2173.         if (! kData->libOpen(filename))

  2174.         {

  2175.             kData->engine->setLastError(kData->libError(filename));

  2176.             return false;

  2177.         }

  2178. 

  2179.         // ---------------------------------------------------------------

  2180.         // get DLL main entry

  2181. 

  2182.         VST_Function vstFn = (VST_Function)kData->libSymbol("VSTPluginMain");

  2183. 

  2184.         if (vstFn == nullptr)

  2185.         {

  2186.             vstFn = (VST_Function)kData->libSymbol("main");

  2187. 

  2188.             if (vstFn == nullptr)

  2189.             {

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

  2191.                 return false;

  2192.             }

  2193.         }

  2194. 

  2195.         // ---------------------------------------------------------------

  2196.         // initialize plugin (part 1)

  2197. 

  2198.         sLastVstPlugin = this;

  2199.         fEffect = vstFn(carla_vst_audioMasterCallback);

  2200.         sLastVstPlugin = nullptr;

  2201. 

  2202.         if (fEffect == nullptr)

  2203.         {

  2204.             kData->engine->setLastError("Plugin failed to initialize");

  2205.             return false;

  2206.         }

  2207. 

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

  2209.         {

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

  2211.             return false;

  2212.         }

  2213. 

  2214. #ifdef VESTIGE_HEADER

  2215.         fEffect->ptr1 = this;

  2216. #else

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

  2218. #endif

  2219. 

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

  2221. 

  2222.         // ---------------------------------------------------------------

  2223.         // get info

  2224. 

  2225.         if (name != nullptr)

  2226.         {

  2227.             fName = kData->engine->getUniquePluginName(name);

  2228.         }

  2229.         else

  2230.         {

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

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

  2233. 

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

  2235.             {

  2236.                 fName = kData->engine->getUniquePluginName(strBuf);

  2237.             }

  2238.             else

  2239.             {

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

  2241.                 fName = kData->engine->getUniquePluginName(label);

  2242.             }

  2243.         }

  2244. 

  2245.         fFilename = filename;

  2246. 

  2247.         // ---------------------------------------------------------------

  2248.         // register client

  2249. 

  2250.         kData->client = kData->engine->addClient(this);

  2251. 

  2252.         if (kData->client == nullptr || ! kData->client->isOk())

  2253.         {

  2254.             kData->engine->setLastError("Failed to register plugin client");

  2255.             return false;

  2256.         }

  2257. 

  2258.         // ---------------------------------------------------------------

  2259.         // initialize plugin (part 2)

  2260. 

  2261. #if ! VST_FORCE_DEPRECATED

  2262.         dispatcher(effSetBlockSizeAndSampleRate, 0, kData->engine->getBufferSize(), nullptr, kData->engine->getSampleRate());

  2263. #endif

  2264.         dispatcher(effSetSampleRate, 0, 0, nullptr, kData->engine->getSampleRate());

  2265.         dispatcher(effSetBlockSize, 0, kData->engine->getBufferSize(), nullptr, 0.0f);

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

  2267. 

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

  2269.             fHints |= PLUGIN_USES_OLD_VSTSDK;

  2270. 

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

  2272.             fHints |= PLUGIN_HAS_COCKOS_EXTENSIONS;

  2273. 

  2274.         // ---------------------------------------------------------------

  2275.         // gui stuff

  2276. 

  2277.         if (fEffect->flags & effFlagsHasEditor)

  2278.         {

  2279.             const EngineOptions& engineOptions(kData->engine->getOptions());

  2280. 

  2281. #if defined(Q_WS_X11)

  2282.             CarlaString uiBridgeBinary(engineOptions.bridge_vstX11);

  2283. #elif defined(CARLA_OS_MAC)

  2284.             CarlaString uiBridgeBinary(engineOptions.bridge_vstCocoa);

  2285. #elif defined(CARLA_OS_WIN)

  2286.             CarlaString uiBridgeBinary(engineOptions.bridge_vstHWND);

  2287. #else

  2288.             CarlaString uiBridgeBinary;

  2289. #endif

  2290. 

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

  2292.             {

  2293.                 kData->osc.thread.setOscData(uiBridgeBinary, nullptr);

  2294.                 fGui.isOsc = true;

  2295.             }

  2296.         }

  2297. 

  2298.         // ---------------------------------------------------------------

  2299.         // load plugin settings

  2300. 

  2301.         {

  2302.             // set default options

  2303.             fOptions = 0x0;

  2304. 

  2305.             fOptions |= PLUGIN_OPTION_MAP_PROGRAM_CHANGES;

  2306. 

  2307.             if (midiInCount() > 0)

  2308.                 fOptions |= PLUGIN_OPTION_FIXED_BUFFER;

  2309. 

  2310.             if (fEffect->flags & effFlagsProgramChunks)

  2311.                 fOptions |= PLUGIN_OPTION_USE_CHUNKS;

  2312. 

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

  2314.             {

  2315.                 fOptions |= PLUGIN_OPTION_SEND_CHANNEL_PRESSURE;

  2316.                 fOptions |= PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH;

  2317.                 fOptions |= PLUGIN_OPTION_SEND_PITCHBEND;

  2318.                 fOptions |= PLUGIN_OPTION_SEND_ALL_SOUND_OFF;

  2319.             }

  2320. 

  2321.             // load settings

  2322.             kData->idStr  = "VST/";

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

  2324.             kData->idStr += "/";

  2325.             kData->idStr += CarlaString(uniqueId());

  2326.             fOptions = kData->loadSettings(fOptions, availableOptions());

  2327. 

  2328.             // ignore settings, we need this anyway

  2329.             if (midiInCount() > 0)

  2330.                 fOptions |= PLUGIN_OPTION_FIXED_BUFFER;

  2331.         }

  2332. 

  2333.         return true;

  2334.     }

  2335. 

  2336. private:

  2337.     int fUnique1;

  2338.     AEffect* fEffect;

  2339. 

  2340.     void*         fLastChunk;

  2341.     uint32_t      fMidiEventCount;

  2342.     VstMidiEvent  fMidiEvents[MAX_MIDI_EVENTS*2];

  2343.     VstTimeInfo_R fTimeInfo;

  2344. 

  2345.     struct FixedVstEvents {

  2346.         int32_t numEvents;

  2347.         intptr_t reserved;

  2348.         VstEvent* data[MAX_MIDI_EVENTS*2];

  2349. 

  2350.         FixedVstEvents()

  2351.             : numEvents(0),

  2352. #ifdef CARLA_PROPER_CPP11_SUPPORT

  2353.               reserved(0),

  2354.               data{nullptr} {}

  2355. #else

  2356.               reserved(0)

  2357.         {

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

  2359.         }

  2360. #endif

  2361.     } fEvents;

  2362. 

  2363.     struct GuiInfo {

  2364.         bool isOsc;

  2365.         bool isVisible;

  2366.         int  lastWidth;

  2367.         int  lastHeight;

  2368. 

  2369.         GuiInfo()

  2370.             : isOsc(false),

  2371.               isVisible(false),

  2372.               lastWidth(0),

  2373.               lastHeight(0) {}

  2374.     } fGui;

  2375. 

  2376.     bool fIsProcessing;

  2377.     bool fNeedIdle;

  2378.     int  fUnique2;

  2379. 

  2380.     static VstPlugin* sLastVstPlugin;

  2381. 

  2382.     // -------------------------------------------------------------------

  2383. 

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

  2385.     {

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

  2387. 

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

  2389.             return 1;

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

  2391.             return 1;

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

  2393.             return 1;

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

  2395.             return 1;

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

  2397.             return 1;

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

  2399.             return 1;

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

  2401.             return 1;

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

  2403.             return -1;

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

  2405.             return -1;

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

  2407.             return 1;

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

  2409.             return 1;

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

  2411.             return -1;

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

  2413.             return -1;

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

  2415.             return -1;

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

  2417.             return 1;

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

  2419.             return -1;

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

  2421.             return -1;

  2422. 

  2423.         // unimplemented

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

  2425.         return 0;

  2426.     }

  2427. 

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

  2429.     {

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

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

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

  2433. #endif

  2434. 

  2435.         switch (opcode)

  2436.         {

  2437.         case audioMasterVersion:

  2438.             return kVstVersion;

  2439. 

  2440.         case audioMasterGetVendorString:

  2441.             CARLA_ASSERT(ptr != nullptr);

  2442. 

  2443.             if (ptr != nullptr)

  2444.             {

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

  2446.                 return 1;

  2447.             }

  2448.             else

  2449.             {

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

  2451.                 return 0;

  2452.             }

  2453. 

  2454.         case audioMasterGetProductString:

  2455.             CARLA_ASSERT(ptr != nullptr);

  2456. 

  2457.             if (ptr != nullptr)

  2458.             {

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

  2460.                 return 1;

  2461.             }

  2462.             else

  2463.             {

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

  2465.                 return 0;

  2466.             }

  2467. 

  2468.         case audioMasterGetVendorVersion:

  2469.             return 0x121; // 1.2.1

  2470. 

  2471.         case audioMasterCanDo:

  2472.             CARLA_ASSERT(ptr != nullptr);

  2473. 

  2474.             if (ptr != nullptr)

  2475.             {

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

  2477.             }

  2478.             else

  2479.             {

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

  2481.                 return 0;

  2482.             }

  2483. 

  2484.         case audioMasterGetLanguage:

  2485.             return kVstLangEnglish;

  2486.         }

  2487. 

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

  2489.         VstPlugin* self = nullptr;

  2490. 

  2491.         if (effect != nullptr)

  2492.         {

  2493. #ifdef VESTIGE_HEADER

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

  2495.             {

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

  2497. #else

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

  2499.             {

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

  2501. #endif

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

  2503.                     self = nullptr;

  2504.             }

  2505. 

  2506.             if (self != nullptr)

  2507.             {

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

  2509.                     self->fEffect = effect;

  2510. 

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

  2512.                 {

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

  2514.                     self = nullptr;

  2515.                 }

  2516.             }

  2517.             else if (sLastVstPlugin != nullptr)

  2518.             {

  2519. #ifdef VESTIGE_HEADER

  2520.                 effect->ptr1 = sLastVstPlugin;

  2521. #else

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

  2523. #endif

  2524.                 self = sLastVstPlugin;

  2525.             }

  2526.         }

  2527. 

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

  2529.     }

  2530. 

  2531.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(VstPlugin)

  2532. };

  2533. 

  2534. VstPlugin* VstPlugin::sLastVstPlugin = nullptr;

  2535. 

  2536. CARLA_BACKEND_END_NAMESPACE

  2537. 

  2538. #else // WANT_VST

  2539. # warning Building without VST support

  2540. #endif

  2541. 

  2542. CARLA_BACKEND_START_NAMESPACE

  2543. 

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

  2545. {

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

  2547. 

  2548. #ifdef WANT_VST

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

  2550. 

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

  2552.     {

  2553.         delete plugin;

  2554.         return nullptr;

  2555.     }

  2556. 

  2557.     plugin->reload();

  2558. 

  2559.     if (init.engine->getProccessMode() == PROCESS_MODE_CONTINUOUS_RACK && ! CarlaPluginProtectedData::canRunInRack(plugin))

  2560.     {

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

  2562.         delete plugin;

  2563.         return nullptr;

  2564.     }

  2565. 

  2566.     return plugin;

  2567. #else

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

  2569.     return nullptr;

  2570. #endif

  2571. }

  2572. 

  2573. CARLA_BACKEND_END_NAMESPACE