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

2546 lines
81KB
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.         CARLA_ASSERT(! fIsProcessing);

  98. 

  99.         if (kData->active)

  100.         {

  101.             deactivate();

  102.             kData->active = false;

  103.         }

  104. 

  105.         if (fEffect != nullptr)

  106.         {

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

  108.             fEffect = nullptr;

  109.         }

  110. 

  111.         // make plugin invalid

  112.         fUnique2 += 1;

  113. 

  114.         if (fLastChunk != nullptr)

  115.         {

  116.             std::free(fLastChunk);

  117.             fLastChunk = nullptr;

  118.         }

  119. 

  120.         clearBuffers();

  121.     }

  122. 

  123.     // -------------------------------------------------------------------

  124.     // Information (base)

  125. 

  126.     PluginType type() const override

  127.     {

  128.         return PLUGIN_VST;

  129.     }

  130. 

  131.     PluginCategory category() override

  132.     {

  133.         CARLA_ASSERT(fEffect != nullptr);

  134. 

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

  136. 

  137.         switch (category)

  138.         {

  139.         case kPlugCategSynth:

  140.             return PLUGIN_CATEGORY_SYNTH;

  141.         case kPlugCategAnalysis:

  142.             return PLUGIN_CATEGORY_UTILITY;

  143.         case kPlugCategMastering:

  144.             return PLUGIN_CATEGORY_DYNAMICS;

  145.         case kPlugCategRoomFx:

  146.             return PLUGIN_CATEGORY_DELAY;

  147.         case kPlugCategRestoration:

  148.             return PLUGIN_CATEGORY_UTILITY;

  149.         case kPlugCategGenerator:

  150.             return PLUGIN_CATEGORY_SYNTH;

  151.         }

  152. 

  153.         if (fEffect->flags & effFlagsIsSynth)

  154.             return PLUGIN_CATEGORY_SYNTH;

  155. 

  156.         return getPluginCategoryFromName(fName);

  157.     }

  158. 

  159.     long uniqueId() const override

  160.     {

  161.         CARLA_ASSERT(fEffect != nullptr);

  162. 

  163.         return fEffect->uniqueID;

  164.     }

  165. 

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

  167.     // Information (count)

  168. 

  169.     // nothing

  170. 

  171.     // -------------------------------------------------------------------

  172.     // Information (current data)

  173. 

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

  175.     {

  176.         CARLA_ASSERT(fOptions & PLUGIN_OPTION_USE_CHUNKS);

  177.         CARLA_ASSERT(fEffect != nullptr);

  178.         CARLA_ASSERT(dataPtr != nullptr);

  179. 

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

  181.     }

  182. 

  183.     // -------------------------------------------------------------------

  184.     // Information (per-plugin data)

  185. 

  186.     unsigned int availableOptions() override

  187.     {

  188.         CARLA_ASSERT(fEffect != nullptr);

  189. 

  190.         if (fEffect == nullptr)

  191.             return 0x0;

  192. 

  193.         unsigned int options = 0x0;

  194. 

  195.         options |= PLUGIN_OPTION_MAP_PROGRAM_CHANGES;

  196. 

  197.         if (midiInCount() == 0)

  198.             options |= PLUGIN_OPTION_FIXED_BUFFER;

  199. 

  200.         if (fEffect->flags & effFlagsProgramChunks)

  201.             options |= PLUGIN_OPTION_USE_CHUNKS;

  202. 

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

  204.         {

  205.             options |= PLUGIN_OPTION_SEND_CONTROL_CHANGES;

  206.             options |= PLUGIN_OPTION_SEND_CHANNEL_PRESSURE;

  207.             options |= PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH;

  208.             options |= PLUGIN_OPTION_SEND_PITCHBEND;

  209.             options |= PLUGIN_OPTION_SEND_ALL_SOUND_OFF;

  210.         }

  211. 

  212.         return options;

  213.     }

  214. 

  215.     float getParameterValue(const uint32_t parameterId) override

  216.     {

  217.         CARLA_ASSERT(fEffect != nullptr);

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

  219. 

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

  221.     }

  222. 

  223.     void getLabel(char* const strBuf) override

  224.     {

  225.         CARLA_ASSERT(fEffect != nullptr);

  226. 

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

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

  229.     }

  230. 

  231.     void getMaker(char* const strBuf) override

  232.     {

  233.         CARLA_ASSERT(fEffect != nullptr);

  234. 

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

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

  237.     }

  238. 

  239.     void getCopyright(char* const strBuf) override

  240.     {

  241.         CARLA_ASSERT(fEffect != nullptr);

  242. 

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

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

  245.     }

  246. 

  247.     void getRealName(char* const strBuf) override

  248.     {

  249.         CARLA_ASSERT(fEffect != nullptr);

  250. 

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

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

  253.     }

  254. 

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

  256.     {

  257.         CARLA_ASSERT(fEffect != nullptr);

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

  259. 

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

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

  262.     }

  263. 

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

  265.     {

  266.         CARLA_ASSERT(fEffect != nullptr);

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

  268. 

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

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

  271. 

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

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

  274.     }

  275. 

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

  277.     {

  278.         CARLA_ASSERT(fEffect != nullptr);

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

  280. 

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

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

  283.     }

  284. 

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

  286.     // Set data (state)

  287. 

  288.     // nothing

  289. 

  290.     // -------------------------------------------------------------------

  291.     // Set data (internal stuff)

  292. 

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

  294.     {

  295.         CarlaPlugin::setName(newName);

  296. 

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

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

  299.     }

  300. 

  301.     // -------------------------------------------------------------------

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

  303. 

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

  305.     {

  306.         CARLA_ASSERT(fEffect != nullptr);

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

  308. 

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

  310. 

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

  312. 

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

  314.     }

  315. 

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

  317.     {

  318.         CARLA_ASSERT(fOptions & PLUGIN_OPTION_USE_CHUNKS);

  319.         CARLA_ASSERT(fEffect != nullptr);

  320.         CARLA_ASSERT(stringData != nullptr);

  321. 

  322.         if (fLastChunk != nullptr)

  323.         {

  324.             std::free(fLastChunk);

  325.             fLastChunk = nullptr;

  326.         }

  327. 

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

  329. 

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

  331. 

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

  333.         {

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

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

  336. 

  337.             {

  338.                 const ScopedSingleProcessLocker spl(this, true);

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

  340.             }

  341. 

  342.             // simulate an updateDisplay callback

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

  344.         }

  345.     }

  346. 

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

  348.     {

  349.         CARLA_ASSERT(fEffect != nullptr);

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

  351. 

  352.         if (index < -1)

  353.             index = -1;

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

  355.             return;

  356. 

  357.         if (index >= 0)

  358.         {

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

  360. 

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

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

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

  364.         }

  365. 

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

  367.     }

  368. 

  369.     // -------------------------------------------------------------------

  370.     // Set gui stuff

  371. 

  372.     void showGui(const bool yesNo) override

  373.     {

  374.         if (fGui.isVisible == yesNo)

  375.             return;

  376. 

  377.         if (fGui.isOsc)

  378.         {

  379.             if (yesNo)

  380.             {

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

  382.             }

  383.             else

  384.             {

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

  386.                 {

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

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

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

  390.                 }

  391. 

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

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

  394.             }

  395.         }

  396.         else

  397.         {

  398.             if (yesNo)

  399.             {

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

  401. 

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

  403.                 {

  404.                     CarlaPluginGui::Options guiOptions;

  405.                     guiOptions.parented  = true;

  406.                     guiOptions.resizable = false;

  407. 

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

  409.                 }

  410. 

  411.                 int32_t value = 0;

  412. #ifdef Q_WS_X11

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

  414. #endif

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

  416. 

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

  418.                 {

  419.                     ERect* vstRect = nullptr;

  420. 

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

  422. 

  423.                     if (vstRect != nullptr)

  424.                     {

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

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

  427. 

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

  429. 

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

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

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

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

  434.                     }

  435. 

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

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

  438.                 }

  439.                 else

  440.                 {

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

  442.                     {

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

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

  445.                         delete kData->gui;

  446.                         kData->gui = nullptr;

  447.                     }

  448. 

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

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

  451.                     return;

  452.                 }

  453.             }

  454.             else

  455.             {

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

  457. 

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

  459. 

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

  461.                 {

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

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

  464. 

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

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

  467.                     delete kData->gui;

  468.                     kData->gui = nullptr;

  469.                 }

  470.             }

  471.         }

  472. 

  473.         fGui.isVisible = yesNo;

  474.     }

  475. 

  476.     void idleGui() override

  477.     {

  478. #ifdef VESTIGE_HEADER

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

  480. #else

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

  482. #endif

  483.         {

  484.             if (fNeedIdle)

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

  486. 

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

  488.             {

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

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

  491.             }

  492.         }

  493. 

  494.         CarlaPlugin::idleGui();

  495.     }

  496. 

  497.     // -------------------------------------------------------------------

  498.     // Plugin state

  499. 

  500.     void reload() override

  501.     {

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

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

  504.         CARLA_ASSERT(fEffect != nullptr);

  505. 

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

  507.             return;

  508.         if (fEffect == nullptr)

  509.             return;

  510. 

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

  512. 

  513.         // Safely disable plugin for reload

  514.         const ScopedDisabler sd(this);

  515. 

  516.         if (kData->active)

  517.             deactivate();

  518. 

  519.         clearBuffers();

  520. 

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

  522. 

  523.         bool needsCtrlIn, needsCtrlOut;

  524.         needsCtrlIn = needsCtrlOut = false;

  525. 

  526.         aIns   = fEffect->numInputs;

  527.         aOuts  = fEffect->numOutputs;

  528.         params = fEffect->numParams;

  529. 

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

  531.         {

  532.             mIns = 1;

  533.             needsCtrlIn = true;

  534.         }

  535.         else

  536.             mIns = 0;

  537. 

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

  539.         {

  540.             mOuts = 1;

  541.             needsCtrlOut = true;

  542.         }

  543.         else

  544.             mOuts = 0;

  545. 

  546.         if (aIns > 0)

  547.         {

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

  549.         }

  550. 

  551.         if (aOuts > 0)

  552.         {

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

  554.             needsCtrlIn = true;

  555.         }

  556. 

  557.         if (params > 0)

  558.         {

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

  560.             needsCtrlIn = true;

  561.         }

  562. 

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

  564.         CarlaString portName;

  565. 

  566.         // Audio Ins

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

  568.         {

  569.             portName.clear();

  570. 

  571.             if (processMode == PROCESS_MODE_SINGLE_CLIENT)

  572.             {

  573.                 portName  = fName;

  574.                 portName += ":";

  575.             }

  576. 

  577.             if (aIns > 1)

  578.             {

  579.                 portName += "input_";

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

  581.             }

  582.             else

  583.                 portName += "input";

  584. 

  585.             portName.truncate(portNameSize);

  586. 

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

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

  589.         }

  590. 

  591.         // Audio Outs

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

  593.         {

  594.             portName.clear();

  595. 

  596.             if (processMode == PROCESS_MODE_SINGLE_CLIENT)

  597.             {

  598.                 portName  = fName;

  599.                 portName += ":";

  600.             }

  601. 

  602.             if (aOuts > 1)

  603.             {

  604.                 portName += "output_";

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

  606.             }

  607.             else

  608.                 portName += "output";

  609. 

  610.             portName.truncate(portNameSize);

  611. 

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

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

  614.         }

  615. 

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

  617.         {

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

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

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

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

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

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

  624. 

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

  626. 

  627.             VstParameterProperties prop;

  628.             carla_zeroStruct<VstParameterProperties>(prop);

  629. 

  630.             if (fHints & PLUGIN_HAS_COCKOS_EXTENSIONS)

  631.             {

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

  633. 

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

  635.                 {

  636.                     min = range[0];

  637.                     max = range[1];

  638. 

  639.                     if (min > max)

  640.                         max = min;

  641.                     else if (max < min)

  642.                         min = max;

  643. 

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

  645.                     {

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

  647.                         max = min + 0.1f;

  648.                     }

  649.                 }

  650.                 else

  651.                 {

  652.                     min = 0.0f;

  653.                     max = 1.0f;

  654.                 }

  655. 

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

  657.                 {

  658.                     step = 1.0f;

  659.                     stepSmall = 1.0f;

  660.                     stepLarge = 10.0f;

  661.                 }

  662.                 else

  663.                 {

  664.                     float range = max - min;

  665.                     step = range/100.0f;

  666.                     stepSmall = range/1000.0f;

  667.                     stepLarge = range/10.0f;

  668.                 }

  669.             }

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

  671.             {

  672.                 if (prop.flags & kVstParameterUsesIntegerMinMax)

  673.                 {

  674.                     min = float(prop.minInteger);

  675.                     max = float(prop.maxInteger);

  676. 

  677.                     if (min > max)

  678.                         max = min;

  679.                     else if (max < min)

  680.                         min = max;

  681. 

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

  683.                     {

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

  685.                         max = min + 0.1f;

  686.                     }

  687.                 }

  688.                 else

  689.                 {

  690.                     min = 0.0f;

  691.                     max = 1.0f;

  692.                 }

  693. 

  694.                 if (prop.flags & kVstParameterIsSwitch)

  695.                 {

  696.                     step = max - min;

  697.                     stepSmall = step;

  698.                     stepLarge = step;

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

  700.                 }

  701.                 else if (prop.flags & kVstParameterUsesIntStep)

  702.                 {

  703.                     step = float(prop.stepInteger);

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

  705.                     stepLarge = float(prop.largeStepInteger);

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

  707.                 }

  708.                 else if (prop.flags & kVstParameterUsesFloatStep)

  709.                 {

  710.                     step = prop.stepFloat;

  711.                     stepSmall = prop.smallStepFloat;

  712.                     stepLarge = prop.largeStepFloat;

  713.                 }

  714.                 else

  715.                 {

  716.                     float range = max - min;

  717.                     step = range/100.0f;

  718.                     stepSmall = range/1000.0f;

  719.                     stepLarge = range/10.0f;

  720.                 }

  721. 

  722.                 if (prop.flags & kVstParameterCanRamp)

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

  724.             }

  725.             else

  726.             {

  727.                 min = 0.0f;

  728.                 max = 1.0f;

  729.                 step = 0.001f;

  730.                 stepSmall = 0.0001f;

  731.                 stepLarge = 0.1f;

  732.             }

  733. 

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

  735. #ifndef BUILD_BRIDGE

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

  737. #endif

  738. 

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

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

  741. 

  742.             // no such thing as VST default parameters

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

  744. 

  745.             if (def < min)

  746.                 def = min;

  747.             else if (def > max)

  748.                 def = max;

  749. 

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

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

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

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

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

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

  756.         }

  757. 

  758.         if (needsCtrlIn)

  759.         {

  760.             portName.clear();

  761. 

  762.             if (processMode == PROCESS_MODE_SINGLE_CLIENT)

  763.             {

  764.                 portName  = fName;

  765.                 portName += ":";

  766.             }

  767. 

  768.             portName += "events-in";

  769.             portName.truncate(portNameSize);

  770. 

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

  772.         }

  773. 

  774.         if (needsCtrlOut)

  775.         {

  776.             portName.clear();

  777. 

  778.             if (processMode == PROCESS_MODE_SINGLE_CLIENT)

  779.             {

  780.                 portName  = fName;

  781.                 portName += ":";

  782.             }

  783. 

  784.             portName += "events-out";

  785.             portName.truncate(portNameSize);

  786. 

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

  788.         }

  789. 

  790.         // plugin hints

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

  792. 

  793.         fHints = 0x0;

  794. 

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

  796.             fHints |= PLUGIN_IS_SYNTH;

  797. 

  798.         if (fEffect->flags & effFlagsHasEditor)

  799.         {

  800.             fHints |= PLUGIN_HAS_GUI;

  801. 

  802.             if (! fGui.isOsc)

  803.                 fHints |= PLUGIN_HAS_SINGLE_THREAD;

  804.         }

  805. 

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

  807.             fHints |= PLUGIN_USES_OLD_VSTSDK;

  808. 

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

  810.             fHints |= PLUGIN_CAN_PROCESS_REPLACING;

  811. 

  812.         if (fEffect->flags & effFlagsHasEditor)

  813.             fHints |= PLUGIN_HAS_GUI;

  814. 

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

  816.             fHints |= PLUGIN_HAS_COCKOS_EXTENSIONS;

  817. 

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

  819.             fHints |= PLUGIN_CAN_DRYWET;

  820. 

  821.         if (aOuts > 0)

  822.             fHints |= PLUGIN_CAN_VOLUME;

  823. 

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

  825.             fHints |= PLUGIN_CAN_BALANCE;

  826. 

  827.         // extra plugin hints

  828.         kData->extraHints = 0x0;

  829. 

  830.         if (mIns > 0)

  831.             kData->extraHints |= PLUGIN_HINT_HAS_MIDI_IN;

  832. 

  833.         if (mOuts > 0)

  834.             kData->extraHints |= PLUGIN_HINT_HAS_MIDI_OUT;

  835. 

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

  837.             kData->extraHints |= PLUGIN_HINT_CAN_RUN_RACK;

  838. 

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

  840.         {

  841.             activate();

  842.             deactivate();

  843.         }

  844. 

  845.         // check latency

  846.         if (fHints & PLUGIN_CAN_DRYWET)

  847.         {

  848. #ifdef VESTIGE_HEADER

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

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

  851.             kData->latency = *initialDelayPtr;

  852. #else

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

  854. #endif

  855. 

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

  857.             kData->recreateLatencyBuffers();

  858.         }

  859. 

  860.         // special plugin fixes

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

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

  863.         {

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

  865.             getLabel(strBuf);

  866. 

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

  868.             {

  869.                 // TODO - disable threaded processing

  870.             }

  871.         }

  872. 

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

  874.         reloadPrograms(true);

  875. 

  876.         if (kData->active)

  877.             activate();

  878. 

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

  880.     }

  881. 

  882.     void reloadPrograms(const bool init) override

  883.     {

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

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

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

  887. 

  888.         // Delete old programs

  889.         kData->prog.clear();

  890. 

  891.         // Query new programs

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

  893. 

  894.         if (count > 0)

  895.         {

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

  897. 

  898.             // Update names

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

  900.             {

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

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

  903.                 {

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

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

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

  907.                 }

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

  909.             }

  910.         }

  911. 

  912. #ifndef BUILD_BRIDGE

  913.         // Update OSC Names

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

  915.         {

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

  917. 

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

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

  920.         }

  921. #endif

  922. 

  923.         if (init)

  924.         {

  925.             if (count > 0)

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

  927.         }

  928.         else

  929.         {

  930.             // Check if current program is invalid

  931.             bool programChanged = false;

  932. 

  933.             if (count == oldCount+1)

  934.             {

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

  936.                 kData->prog.current = oldCount;

  937.                 programChanged = true;

  938.             }

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

  940.             {

  941.                 // programs exist now, but not before

  942.                 kData->prog.current = 0;

  943.                 programChanged = true;

  944.             }

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

  946.             {

  947.                 // programs existed before, but not anymore

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

  949.                 programChanged = true;

  950.             }

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

  952.             {

  953.                 // current program > count

  954.                 kData->prog.current = 0;

  955.                 programChanged = true;

  956.             }

  957.             else

  958.             {

  959.                 // no change

  960.                 kData->prog.current = current;

  961.             }

  962. 

  963.             if (programChanged)

  964.             {

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

  966.             }

  967.             else

  968.             {

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

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

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

  972.             }

  973. 

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

  975.         }

  976.     }

  977. 

  978.     // -------------------------------------------------------------------

  979.     // Plugin processing

  980. 

  981.     void activate() override

  982.     {

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

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

  985.     }

  986. 

  987.     void deactivate() override

  988.     {

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

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

  991.     }

  992. 

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

  994.     {

  995.         uint32_t i, k;

  996. 

  997.         // --------------------------------------------------------------------------------------------------------

  998.         // Check if active

  999. 

  1000.         if (! kData->active)

  1001.         {

  1002.             // disable any output sound

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

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

  1005. 

  1006.             return;

  1007.         }

  1008. 

  1009.         fMidiEventCount = 0;

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

  1011. 

  1012.         // --------------------------------------------------------------------------------------------------------

  1013.         // Check if needs reset

  1014. 

  1015.         if (kData->needsReset)

  1016.         {

  1017.             if (fOptions & PLUGIN_OPTION_SEND_ALL_SOUND_OFF)

  1018.             {

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

  1020.                 {

  1021.                     fMidiEvents[k].type = kVstMidiType;

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

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

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

  1025. 

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

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

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

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

  1030.                 }

  1031. 

  1032.                 fMidiEventCount = MAX_MIDI_CHANNELS*2;

  1033.             }

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

  1035.             {

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

  1037.                 {

  1038.                     fMidiEvents[k].type = kVstMidiType;

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

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

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

  1042.                 }

  1043. 

  1044.                 fMidiEventCount = MAX_MIDI_NOTE;

  1045.             }

  1046. 

  1047.             if (kData->latency > 0)

  1048.             {

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

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

  1051.             }

  1052. 

  1053.             kData->needsReset = false;

  1054.         }

  1055. 

  1056.         CARLA_PROCESS_CONTINUE_CHECK;

  1057. 

  1058.         // --------------------------------------------------------------------------------------------------------

  1059.         // Set TimeInfo

  1060. 

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

  1062. 

  1063.         fTimeInfo.flags = kVstTransportChanged;

  1064. 

  1065.         if (timeInfo.playing)

  1066.             fTimeInfo.flags |= kVstTransportPlaying;

  1067. 

  1068.         fTimeInfo.samplePos  = timeInfo.frame;

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

  1070. 

  1071.         if (timeInfo.usecs != 0)

  1072.         {

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

  1074.             fTimeInfo.flags |= kVstNanosValid;

  1075.         }

  1076. 

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

  1078.         {

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

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

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

  1082. 

  1083.             // PPQ Pos

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

  1085.             fTimeInfo.flags |= kVstPpqPosValid;

  1086. 

  1087.             // Tempo

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

  1089.             fTimeInfo.flags |= kVstTempoValid;

  1090. 

  1091.             // Bars

  1092.             fTimeInfo.barStartPos = ppqBar;

  1093.             fTimeInfo.flags |= kVstBarsValid;

  1094. 

  1095.             // Time Signature

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

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

  1098.             fTimeInfo.flags |= kVstTimeSigValid;

  1099.         }

  1100.         else

  1101.         {

  1102.             // Tempo

  1103.             fTimeInfo.tempo = 120.0;

  1104.             fTimeInfo.flags |= kVstTempoValid;

  1105. 

  1106.             // Time Signature

  1107.             fTimeInfo.timeSigNumerator   = 4;

  1108.             fTimeInfo.timeSigDenominator = 4;

  1109.             fTimeInfo.flags |= kVstTimeSigValid;

  1110. 

  1111.             // Missing info

  1112.             fTimeInfo.ppqPos = 0.0;

  1113.             fTimeInfo.barStartPos = 0.0;

  1114.         }

  1115. 

  1116.         CARLA_PROCESS_CONTINUE_CHECK;

  1117. 

  1118.         // --------------------------------------------------------------------------------------------------------

  1119.         // Event Input and Processing

  1120. 

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

  1122.         {

  1123.             // ----------------------------------------------------------------------------------------------------

  1124.             // MIDI Input (External)

  1125. 

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

  1127.             {

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

  1129.                 {

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

  1131. 

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

  1133. 

  1134.                     fMidiEvents[fMidiEventCount].type = kVstMidiType;

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

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

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

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

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

  1140. 

  1141.                     fMidiEventCount += 1;

  1142.                 }

  1143. 

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

  1145. 

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

  1147. 

  1148.             // ----------------------------------------------------------------------------------------------------

  1149.             // Event Input (System)

  1150. 

  1151.             bool allNotesOffSent = false;

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

  1153. 

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

  1155.             uint32_t startTime  = 0;

  1156.             uint32_t timeOffset = 0;

  1157. 

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

  1159.             {

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

  1161. 

  1162.                 time = event.time;

  1163. 

  1164.                 if (time >= frames)

  1165.                     continue;

  1166. 

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

  1168. 

  1169.                 if (time > timeOffset && sampleAccurate)

  1170.                 {

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

  1172.                     {

  1173.                         startTime  = 0;

  1174.                         timeOffset = time;

  1175. 

  1176.                         if (fMidiEventCount > 0)

  1177.                         {

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

  1179.                             fMidiEventCount = 0;

  1180.                         }

  1181.                     }

  1182.                     else

  1183.                         startTime += timeOffset;

  1184.                 }

  1185. 

  1186.                 // Control change

  1187.                 switch (event.type)

  1188.                 {

  1189.                 case kEngineEventTypeNull:

  1190.                     break;

  1191. 

  1192.                 case kEngineEventTypeControl:

  1193.                 {

  1194.                     const EngineControlEvent& ctrlEvent = event.ctrl;

  1195. 

  1196.                     switch (ctrlEvent.type)

  1197.                     {

  1198.                     case kEngineControlEventTypeNull:

  1199.                         break;

  1200. 

  1201.                     case kEngineControlEventTypeParameter:

  1202.                     {

  1203. #ifndef BUILD_BRIDGE

  1204.                         // Control backend stuff

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

  1206.                         {

  1207.                             float value;

  1208. 

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

  1210.                             {

  1211.                                 value = ctrlEvent.value;

  1212.                                 setDryWet(value, false, false);

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

  1214.                             }

  1215. 

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

  1217.                             {

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

  1219.                                 setVolume(value, false, false);

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

  1221.                             }

  1222. 

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

  1224.                             {

  1225.                                 float left, right;

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

  1227. 

  1228.                                 if (value < 0.0f)

  1229.                                 {

  1230.                                     left  = -1.0f;

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

  1232.                                 }

  1233.                                 else if (value > 0.0f)

  1234.                                 {

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

  1236.                                     right = 1.0f;

  1237.                                 }

  1238.                                 else

  1239.                                 {

  1240.                                     left  = -1.0f;

  1241.                                     right = 1.0f;

  1242.                                 }

  1243. 

  1244.                                 setBalanceLeft(left, false, false);

  1245.                                 setBalanceRight(right, false, false);

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

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

  1248.                             }

  1249.                         }

  1250. #endif

  1251. 

  1252.                         // Control plugin parameters

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

  1254.                         {

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

  1256.                                 continue;

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

  1258.                                 continue;

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

  1260.                                 continue;

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

  1262.                                 continue;

  1263. 

  1264.                             float value;

  1265. 

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

  1267.                             {

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

  1269.                             }

  1270.                             else

  1271.                             {

  1272.                                 value = kData->param.ranges[i].unnormalizeValue(ctrlEvent.value);

  1273. 

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

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

  1276.                             }

  1277. 

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

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

  1280.                         }

  1281. 

  1282.                         break;

  1283.                     }

  1284. 

  1285.                     case kEngineControlEventTypeMidiBank:

  1286.                         break;

  1287. 

  1288.                     case kEngineControlEventTypeMidiProgram:

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

  1290.                         {

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

  1292.                             {

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

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

  1295.                                 break;

  1296.                             }

  1297.                         }

  1298.                         break;

  1299. 

  1300.                     case kEngineControlEventTypeAllSoundOff:

  1301.                         if (fOptions & PLUGIN_OPTION_SEND_ALL_SOUND_OFF)

  1302.                         {

  1303.                             if (fMidiEventCount >= MAX_MIDI_EVENTS*2)

  1304.                                 continue;

  1305. 

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

  1307. 

  1308.                             fMidiEvents[fMidiEventCount].type = kVstMidiType;

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

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

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

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

  1313. 

  1314.                             fMidiEventCount += 1;

  1315.                         }

  1316.                         break;

  1317. 

  1318.                     case kEngineControlEventTypeAllNotesOff:

  1319.                         if (fOptions & PLUGIN_OPTION_SEND_ALL_SOUND_OFF)

  1320.                         {

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

  1322.                             {

  1323.                                 allNotesOffSent = true;

  1324.                                 sendMidiAllNotesOffToCallback();

  1325.                             }

  1326. 

  1327.                             if (fMidiEventCount >= MAX_MIDI_EVENTS*2)

  1328.                                 continue;

  1329. 

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

  1331. 

  1332.                             fMidiEvents[fMidiEventCount].type = kVstMidiType;

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

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

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

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

  1337. 

  1338.                             fMidiEventCount += 1;

  1339.                         }

  1340.                         break;

  1341.                     }

  1342. 

  1343.                     break;

  1344.                 }

  1345. 

  1346.                 case kEngineEventTypeMidi:

  1347.                 {

  1348.                     if (fMidiEventCount >= MAX_MIDI_EVENTS*2)

  1349.                         continue;

  1350. 

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

  1352. 

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

  1354.                     uint8_t channel = event.channel;

  1355. 

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

  1357.                         continue;

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

  1359.                         continue;

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

  1361.                         continue;

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

  1363.                         continue;

  1364. 

  1365.                     // Fix bad note-off

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

  1367.                         status -= 0x10;

  1368. 

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

  1370. 

  1371.                     fMidiEvents[fMidiEventCount].type = kVstMidiType;

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

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

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

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

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

  1377. 

  1378.                     fMidiEventCount += 1;

  1379. 

  1380.                     if (status == MIDI_STATUS_NOTE_ON)

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

  1382.                     else if (status == MIDI_STATUS_NOTE_OFF)

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

  1384. 

  1385.                     break;

  1386.                 }

  1387.                 }

  1388.             }

  1389. 

  1390.             kData->postRtEvents.trySplice();

  1391. 

  1392.             if (frames > timeOffset)

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

  1394. 

  1395.         } // End of Event Input and Processing

  1396. 

  1397.         // --------------------------------------------------------------------------------------------------------

  1398.         // Plugin processing (no events)

  1399. 

  1400.         else

  1401.         {

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

  1403. 

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

  1405. 

  1406.         CARLA_PROCESS_CONTINUE_CHECK;

  1407. 

  1408.         // --------------------------------------------------------------------------------------------------------

  1409.         // MIDI Output

  1410. 

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

  1412.         {

  1413.             // reverse lookup MIDI events

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

  1415.             {

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

  1417.                     break;

  1418. 

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

  1420. 

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

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

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

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

  1425. 

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

  1427.             }

  1428. 

  1429.         } // End of Control and MIDI Output

  1430.     }

  1431. 

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

  1433.     {

  1434.         CARLA_ASSERT(frames > 0);

  1435. 

  1436.         if (frames == 0)

  1437.             return false;

  1438. 

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

  1440.         {

  1441.             CARLA_ASSERT(inBuffer != nullptr);

  1442.             if (inBuffer == nullptr)

  1443.                 return false;

  1444.         }

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

  1446.         {

  1447.             CARLA_ASSERT(outBuffer != nullptr);

  1448.             if (outBuffer == nullptr)

  1449.                 return false;

  1450.         }

  1451. 

  1452.         uint32_t i, k;

  1453. 

  1454.         // --------------------------------------------------------------------------------------------------------

  1455.         // Try lock, silence otherwise

  1456. 

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

  1458.         {

  1459.             kData->singleMutex.lock();

  1460.         }

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

  1462.         {

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

  1464.             {

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

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

  1467.             }

  1468. 

  1469.             return false;

  1470.         }

  1471. 

  1472.         // --------------------------------------------------------------------------------------------------------

  1473.         // Set audio buffers

  1474. 

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

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

  1477. 

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

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

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

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

  1482. 

  1483.         // --------------------------------------------------------------------------------------------------------

  1484.         // Set MIDI events

  1485. 

  1486.         if (fMidiEventCount > 0)

  1487.         {

  1488.             fEvents.numEvents = fMidiEventCount;

  1489.             fEvents.reserved  = 0;

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

  1491.         }

  1492. 

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

  1494.         // Run plugin

  1495. 

  1496.         fIsProcessing = true;

  1497. 

  1498.         if (fHints & PLUGIN_CAN_PROCESS_REPLACING)

  1499.         {

  1500.             fEffect->processReplacing(fEffect,

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

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

  1503.                                       frames);

  1504.         }

  1505.         else

  1506.         {

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

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

  1509. 

  1510. #if ! VST_FORCE_DEPRECATED

  1511.             fEffect->process(fEffect,

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

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

  1514.                              frames);

  1515. #endif

  1516.         }

  1517. 

  1518.         fIsProcessing = false;

  1519.         fTimeInfo.samplePos += frames;

  1520. 

  1521. #ifndef BUILD_BRIDGE

  1522.         // --------------------------------------------------------------------------------------------------------

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

  1524. 

  1525.         {

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

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

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

  1529. 

  1530.             bool isPair;

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

  1532. 

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

  1534.             {

  1535.                 // Dry/Wet

  1536.                 if (doDryWet)

  1537.                 {

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

  1539.                     {

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

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

  1542.                     }

  1543.                 }

  1544. 

  1545.                 // Balance

  1546.                 if (doBalance)

  1547.                 {

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

  1549. 

  1550.                     if (isPair)

  1551.                     {

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

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

  1554.                     }

  1555. 

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

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

  1558. 

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

  1560.                     {

  1561.                         if (isPair)

  1562.                         {

  1563.                             // left

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

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

  1566.                         }

  1567.                         else

  1568.                         {

  1569.                             // right

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

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

  1572.                         }

  1573.                     }

  1574.                 }

  1575. 

  1576.                 // Volume

  1577.                 if (doVolume)

  1578.                 {

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

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

  1581.                 }

  1582.             }

  1583. 

  1584.         } // End of Post-processing

  1585. #endif

  1586. 

  1587.         // --------------------------------------------------------------------------------------------------------

  1588. 

  1589.         kData->singleMutex.unlock();

  1590.         return true;

  1591.     }

  1592. 

  1593.     void bufferSizeChanged(const uint32_t newBufferSize) override

  1594.     {

  1595.         CARLA_ASSERT_INT(newBufferSize > 0, newBufferSize);

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

  1597. 

  1598.         if (kData->active)

  1599.             deactivate();

  1600. 

  1601. #if ! VST_FORCE_DEPRECATED

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

  1603. #endif

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

  1605. 

  1606.         if (kData->active)

  1607.             activate();

  1608.     }

  1609. 

  1610.     void sampleRateChanged(const double newSampleRate) override

  1611.     {

  1612.         CARLA_ASSERT_INT(newSampleRate > 0.0, newSampleRate);

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

  1614. 

  1615.         if (kData->active)

  1616.             deactivate();

  1617. 

  1618. #if ! VST_FORCE_DEPRECATED

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

  1620. #endif

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

  1622. 

  1623.         if (kData->active)

  1624.             activate();

  1625.     }

  1626. 

  1627.     // -------------------------------------------------------------------

  1628.     // Plugin buffers

  1629. 

  1630.     // nothing

  1631. 

  1632.     // -------------------------------------------------------------------

  1633.     // Post-poned UI Stuff

  1634. 

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

  1636.     {

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

  1638. 

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

  1640.             return;

  1641.         if (! fGui.isOsc)

  1642.             return;

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

  1644.             return;

  1645. 

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

  1647.     }

  1648. 

  1649.     void uiProgramChange(const uint32_t index) override

  1650.     {

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

  1652. 

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

  1654.             return;

  1655.         if (! fGui.isOsc)

  1656.             return;

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

  1658.             return;

  1659. 

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

  1661.     }

  1662. 

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

  1664.     {

  1665.         CARLA_ASSERT(channel < MAX_MIDI_CHANNELS);

  1666.         CARLA_ASSERT(note < MAX_MIDI_NOTE);

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

  1668. 

  1669.         if (channel >= MAX_MIDI_CHANNELS)

  1670.             return;

  1671.         if (note >= MAX_MIDI_NOTE)

  1672.             return;

  1673.         if (velo >= MAX_MIDI_VALUE)

  1674.             return;

  1675.         if (! fGui.isOsc)

  1676.             return;

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

  1678.             return;

  1679. 

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

  1681.         midiData[1] = MIDI_STATUS_NOTE_ON + channel;

  1682.         midiData[2] = note;

  1683.         midiData[3] = velo;

  1684. 

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

  1686.     }

  1687. 

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

  1689.     {

  1690.         CARLA_ASSERT(channel < MAX_MIDI_CHANNELS);

  1691.         CARLA_ASSERT(note < MAX_MIDI_NOTE);

  1692. 

  1693.         if (channel >= MAX_MIDI_CHANNELS)

  1694.             return;

  1695.         if (note >= MAX_MIDI_NOTE)

  1696.             return;

  1697.         if (! fGui.isOsc)

  1698.             return;

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

  1700.             return;

  1701. 

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

  1703.         midiData[1] = MIDI_STATUS_NOTE_OFF + channel;

  1704.         midiData[2] = note;

  1705. 

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

  1707.     }

  1708. 

  1709.     // -------------------------------------------------------------------

  1710. 

  1711. protected:

  1712.     void guiClosedCallback() override

  1713.     {

  1714.         showGui(false);

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

  1716.     }

  1717. 

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

  1719.     {

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

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

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

  1723. #endif

  1724.         CARLA_ASSERT(fEffect != nullptr);

  1725. 

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

  1727.     }

  1728. 

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

  1730.     {

  1731. #if 0

  1732.         // Cockos VST extensions

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

  1734.         {

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

  1736. 

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

  1738.                 return 0;

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

  1740.                 return 0;

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

  1742.                 return 0;

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

  1744.                 return 0;

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

  1746.                 return 0;

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

  1748.                 return 0;

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

  1750.                 return 0;

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

  1752.                 return 0;

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

  1754.                 return 0;

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

  1756.                 return 0;

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

  1758.                 return 0;

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

  1760.                 return 0;

  1761.         }

  1762. #endif

  1763. 

  1764.         intptr_t ret = 0;

  1765. 

  1766.         switch (opcode)

  1767.         {

  1768.         case audioMasterAutomate:

  1769.             if (! fEnabled)

  1770.                 break;

  1771. 

  1772.             // plugins should never do this:

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

  1774. 

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

  1776.                 break;

  1777. 

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

  1779.             {

  1780.                 // Called from GUI

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

  1782.             }

  1783.             else if (fIsProcessing)

  1784.             {

  1785.                 // Called from engine

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

  1787. 

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

  1789.                 {

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

  1791.                 }

  1792.                 else

  1793.                 {

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

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

  1796.                 }

  1797.             }

  1798.             else

  1799.             {

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

  1801.             }

  1802.             break;

  1803. 

  1804.         case audioMasterCurrentId:

  1805.             // TODO

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

  1807.             break;

  1808. 

  1809.         case audioMasterIdle:

  1810.             if (fGui.isVisible)

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

  1812.             break;

  1813. 

  1814. #if ! VST_FORCE_DEPRECATED

  1815.         case audioMasterPinConnected:

  1816.             // Deprecated in VST SDK 2.4

  1817.             // TODO

  1818.             break;

  1819. 

  1820.         case audioMasterWantMidi:

  1821.             // Deprecated in VST SDK 2.4

  1822.             fHints |= PLUGIN_WANTS_MIDI_INPUT;

  1823.             break;

  1824. #endif

  1825. 

  1826.         case audioMasterGetTime:

  1827. #ifdef VESTIGE_HEADER

  1828.             ret = getAddressFromPointer(&fTimeInfo);

  1829. #else

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

  1831. #endif

  1832.             break;

  1833. 

  1834.         case audioMasterProcessEvents:

  1835.             CARLA_ASSERT(fEnabled);

  1836.             CARLA_ASSERT(fIsProcessing);

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

  1838.             CARLA_ASSERT(ptr != nullptr);

  1839. 

  1840.             if (! fEnabled)

  1841.                 return 0;

  1842.             if (! fIsProcessing)

  1843.                 return 0;

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

  1845.                 return 0;

  1846.             if (ptr == nullptr)

  1847.                 return 0;

  1848.             if (! fIsProcessing)

  1849.             {

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

  1851.                 return 0;

  1852.             }

  1853. 

  1854.             if (fMidiEventCount >= MAX_MIDI_EVENTS*2)

  1855.                 return 0;

  1856. 

  1857. 

  1858.         {

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

  1860. 

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

  1862.             {

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

  1864.                     break;

  1865. 

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

  1867. 

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

  1869.                     continue;

  1870. 

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

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

  1873.                 {

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

  1875.                     {

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

  1877.                         break;

  1878.                     }

  1879.                 }

  1880.             }

  1881.         }

  1882. 

  1883.             ret = 1;

  1884.             break;

  1885. 

  1886. #if ! VST_FORCE_DEPRECATED

  1887.         case audioMasterSetTime:

  1888.             // Deprecated in VST SDK 2.4

  1889.             break;

  1890. 

  1891.         case audioMasterTempoAt:

  1892.             // Deprecated in VST SDK 2.4

  1893.             CARLA_ASSERT(fIsProcessing);

  1894.             ret = fTimeInfo.tempo * 10000;

  1895.             break;

  1896. 

  1897.         case audioMasterGetNumAutomatableParameters:

  1898.             // Deprecated in VST SDK 2.4

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

  1900.             break;

  1901. 

  1902.         case audioMasterGetParameterQuantization:

  1903.             // Deprecated in VST SDK 2.4

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

  1905.             break;

  1906. #endif

  1907. 

  1908. #if 0

  1909.         case audioMasterIOChanged:

  1910.             CARLA_ASSERT(fEnabled);

  1911. 

  1912.             // TESTING

  1913. 

  1914.             if (! fEnabled)

  1915.             {

  1916.                 ret = 1;

  1917.                 break;

  1918.             }

  1919. 

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

  1921.             {

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

  1923.                 return 0;

  1924.             }

  1925. 

  1926.             engineProcessLock();

  1927.             m_enabled = false;

  1928.             engineProcessUnlock();

  1929. 

  1930.             if (m_active)

  1931.             {

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

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

  1934.             }

  1935. 

  1936.             reload();

  1937. 

  1938.             if (m_active)

  1939.             {

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

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

  1942.             }

  1943. 

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

  1945. 

  1946.             ret = 1;

  1947.             break;

  1948. #endif

  1949. 

  1950.         case audioMasterNeedIdle:

  1951.             // Deprecated in VST SDK 2.4

  1952.             fNeedIdle = true;

  1953.             ret = 1;

  1954.             break;

  1955. 

  1956.         case audioMasterSizeWindow:

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

  1958.             {

  1959.                 CARLA_SAFE_ASSERT(fGui.isVisible);

  1960.                 if (fGui.isVisible)

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

  1962.                 ret = 1;

  1963.             }

  1964.             break;

  1965. 

  1966.         case audioMasterGetSampleRate:

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

  1968.             break;

  1969. 

  1970.         case audioMasterGetBlockSize:

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

  1972.             break;

  1973. 

  1974.         case audioMasterGetInputLatency:

  1975.             ret = 0;

  1976.             break;

  1977. 

  1978.         case audioMasterGetOutputLatency:

  1979.             ret = 0;

  1980.             break;

  1981. 

  1982. #if ! VST_FORCE_DEPRECATED

  1983.         case audioMasterGetPreviousPlug:

  1984.             // Deprecated in VST SDK 2.4

  1985.             // TODO

  1986.             break;

  1987. 

  1988.         case audioMasterGetNextPlug:

  1989.             // Deprecated in VST SDK 2.4

  1990.             // TODO

  1991.             break;

  1992. 

  1993.         case audioMasterWillReplaceOrAccumulate:

  1994.             // Deprecated in VST SDK 2.4

  1995.             ret = 1; // replace

  1996.             break;

  1997. #endif

  1998. 

  1999.         case audioMasterGetCurrentProcessLevel:

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

  2001.                 ret = kVstProcessLevelOffline;

  2002.             else if (fIsProcessing)

  2003.                 ret = kVstProcessLevelRealtime;

  2004.             else

  2005.                 ret = kVstProcessLevelUser;

  2006.             break;

  2007. 

  2008.         case audioMasterGetAutomationState:

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

  2010.             break;

  2011. 

  2012.         case audioMasterOfflineStart:

  2013.         case audioMasterOfflineRead:

  2014.         case audioMasterOfflineWrite:

  2015.         case audioMasterOfflineGetCurrentPass:

  2016.         case audioMasterOfflineGetCurrentMetaPass:

  2017.             // TODO

  2018.             break;

  2019. 

  2020. #if ! VST_FORCE_DEPRECATED

  2021.         case audioMasterSetOutputSampleRate:

  2022.             // Deprecated in VST SDK 2.4

  2023.             break;

  2024. 

  2025.         case audioMasterGetOutputSpeakerArrangement:

  2026.             // Deprecated in VST SDK 2.4

  2027.             // TODO

  2028.             break;

  2029. #endif

  2030. 

  2031.         case audioMasterVendorSpecific:

  2032.             // TODO - cockos extensions

  2033.             break;

  2034. 

  2035. #if ! VST_FORCE_DEPRECATED

  2036.         case audioMasterSetIcon:

  2037.             // Deprecated in VST SDK 2.4

  2038.             break;

  2039. #endif

  2040. 

  2041. #if ! VST_FORCE_DEPRECATED

  2042.         case audioMasterOpenWindow:

  2043.         case audioMasterCloseWindow:

  2044.             // Deprecated in VST SDK 2.4

  2045.             // TODO

  2046.             break;

  2047. #endif

  2048. 

  2049.         case audioMasterGetDirectory:

  2050.             // TODO

  2051.             break;

  2052. 

  2053.         case audioMasterUpdateDisplay:

  2054.             // Idle UI if visible

  2055.             if (fGui.isVisible)

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

  2057. 

  2058.             // Update current program

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

  2060.             {

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

  2062. 

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

  2064.                 {

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

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

  2067. 

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

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

  2070. 

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

  2072. 

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

  2074.                     {

  2075.                         kData->prog.current = current;

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

  2077.                     }

  2078.                 }

  2079.             }

  2080. 

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

  2082.             ret = 1;

  2083.             break;

  2084. 

  2085.         case audioMasterBeginEdit:

  2086.         case audioMasterEndEdit:

  2087.             // TODO

  2088.             break;

  2089. 

  2090.         case audioMasterOpenFileSelector:

  2091.         case audioMasterCloseFileSelector:

  2092.             // TODO

  2093.             break;

  2094. 

  2095. #if ! VST_FORCE_DEPRECATED

  2096.         case audioMasterEditFile:

  2097.             // Deprecated in VST SDK 2.4

  2098.             // TODO

  2099.             break;

  2100. 

  2101.         case audioMasterGetChunkFile:

  2102.             // Deprecated in VST SDK 2.4

  2103.             // TODO

  2104.             break;

  2105. 

  2106.         case audioMasterGetInputSpeakerArrangement:

  2107.             // Deprecated in VST SDK 2.4

  2108.             // TODO

  2109.             break;

  2110. #endif

  2111. 

  2112.         default:

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

  2114.             break;

  2115.         }

  2116. 

  2117.         return ret;

  2118.     }

  2119. 

  2120.     // -------------------------------------------------------------------

  2121. 

  2122. public:

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

  2124.     {

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

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

  2127.         CARLA_ASSERT(filename != nullptr);

  2128. 

  2129.         // ---------------------------------------------------------------

  2130.         // first checks

  2131. 

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

  2133.         {

  2134.             return false;

  2135.         }

  2136. 

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

  2138.         {

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

  2140.             return false;

  2141.         }

  2142. 

  2143.         if (filename == nullptr)

  2144.         {

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

  2146.             return false;

  2147.         }

  2148. 

  2149.         // ---------------------------------------------------------------

  2150.         // open DLL

  2151. 

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

  2153.         {

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

  2155.             return false;

  2156.         }

  2157. 

  2158.         // ---------------------------------------------------------------

  2159.         // get DLL main entry

  2160. 

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

  2162. 

  2163.         if (vstFn == nullptr)

  2164.         {

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

  2166. 

  2167.             if (vstFn == nullptr)

  2168.             {

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

  2170.                 return false;

  2171.             }

  2172.         }

  2173. 

  2174.         // ---------------------------------------------------------------

  2175.         // initialize plugin (part 1)

  2176. 

  2177.         sLastVstPlugin = this;

  2178.         fEffect = vstFn(carla_vst_audioMasterCallback);

  2179.         sLastVstPlugin = nullptr;

  2180. 

  2181.         if (fEffect == nullptr)

  2182.         {

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

  2184.             return false;

  2185.         }

  2186. 

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

  2188.         {

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

  2190.             return false;

  2191.         }

  2192. 

  2193. #ifdef VESTIGE_HEADER

  2194.         fEffect->ptr1 = this;

  2195. #else

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

  2197. #endif

  2198. 

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

  2200. 

  2201.         // ---------------------------------------------------------------

  2202.         // get info

  2203. 

  2204.         if (name != nullptr)

  2205.         {

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

  2207.         }

  2208.         else

  2209.         {

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

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

  2212. 

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

  2214.             {

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

  2216.             }

  2217.             else

  2218.             {

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

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

  2221.             }

  2222.         }

  2223. 

  2224.         fFilename = filename;

  2225. 

  2226.         // ---------------------------------------------------------------

  2227.         // register client

  2228. 

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

  2230. 

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

  2232.         {

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

  2234.             return false;

  2235.         }

  2236. 

  2237.         // ---------------------------------------------------------------

  2238.         // initialize plugin (part 2)

  2239. 

  2240. #if ! VST_FORCE_DEPRECATED

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

  2242. #endif

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

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

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

  2246. 

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

  2248.             fHints |= PLUGIN_USES_OLD_VSTSDK;

  2249. 

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

  2251.             fHints |= PLUGIN_HAS_COCKOS_EXTENSIONS;

  2252. 

  2253.         // ---------------------------------------------------------------

  2254.         // gui stuff

  2255. 

  2256.         if (fEffect->flags & effFlagsHasEditor)

  2257.         {

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

  2259. 

  2260. #if defined(Q_WS_X11)

  2261.             CarlaString uiBridgeBinary(engineOptions.bridge_vstX11);

  2262. #elif defined(CARLA_OS_MAC)

  2263.             CarlaString uiBridgeBinary(engineOptions.bridge_vstCocoa);

  2264. #elif defined(CARLA_OS_WIN)

  2265.             CarlaString uiBridgeBinary(engineOptions.bridge_vstHWND);

  2266. #else

  2267.             CarlaString uiBridgeBinary;

  2268. #endif

  2269. 

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

  2271.             {

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

  2273.                 fGui.isOsc = true;

  2274.             }

  2275.         }

  2276. 

  2277.         // ---------------------------------------------------------------

  2278.         // load plugin settings

  2279. 

  2280.         {

  2281.             // set default options

  2282.             fOptions = 0x0;

  2283. 

  2284.             fOptions |= PLUGIN_OPTION_MAP_PROGRAM_CHANGES;

  2285. 

  2286.             if (midiInCount() > 0)

  2287.                 fOptions |= PLUGIN_OPTION_FIXED_BUFFER;

  2288. 

  2289.             if (fEffect->flags & effFlagsProgramChunks)

  2290.                 fOptions |= PLUGIN_OPTION_USE_CHUNKS;

  2291. 

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

  2293.             {

  2294.                 fOptions |= PLUGIN_OPTION_SEND_CHANNEL_PRESSURE;

  2295.                 fOptions |= PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH;

  2296.                 fOptions |= PLUGIN_OPTION_SEND_PITCHBEND;

  2297.                 fOptions |= PLUGIN_OPTION_SEND_ALL_SOUND_OFF;

  2298.             }

  2299. 

  2300.             // load settings

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

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

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

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

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

  2306. 

  2307.             // ignore settings, we need this anyway

  2308.             if (midiInCount() > 0)

  2309.                 fOptions |= PLUGIN_OPTION_FIXED_BUFFER;

  2310.         }

  2311. 

  2312.         return true;

  2313.     }

  2314. 

  2315. private:

  2316.     int fUnique1;

  2317.     AEffect* fEffect;

  2318. 

  2319.     void*         fLastChunk;

  2320.     uint32_t      fMidiEventCount;

  2321.     VstMidiEvent  fMidiEvents[MAX_MIDI_EVENTS*2];

  2322.     VstTimeInfo_R fTimeInfo;

  2323. 

  2324.     struct FixedVstEvents {

  2325.         int32_t numEvents;

  2326.         intptr_t reserved;

  2327.         VstEvent* data[MAX_MIDI_EVENTS*2];

  2328. 

  2329.         FixedVstEvents()

  2330.             : numEvents(0),

  2331.               reserved(0),

  2332.               data{nullptr} {}

  2333.     } fEvents;

  2334. 

  2335.     struct GuiInfo {

  2336.         bool isOsc;

  2337.         bool isVisible;

  2338.         int  lastWidth;

  2339.         int  lastHeight;

  2340. 

  2341.         GuiInfo()

  2342.             : isOsc(false),

  2343.               isVisible(false),

  2344.               lastWidth(0),

  2345.               lastHeight(0) {}

  2346.     } fGui;

  2347. 

  2348.     bool fIsProcessing;

  2349.     bool fNeedIdle;

  2350.     int  fUnique2;

  2351. 

  2352.     static VstPlugin* sLastVstPlugin;

  2353. 

  2354.     // -------------------------------------------------------------------

  2355. 

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

  2357.     {

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

  2359. 

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

  2361.             return 1;

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

  2363.             return 1;

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

  2365.             return 1;

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

  2367.             return 1;

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

  2369.             return 1;

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

  2371.             return 1;

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

  2373.             return 1;

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

  2375.             return -1;

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

  2377.             return -1;

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

  2379.             return 1;

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

  2381.             return 1;

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

  2383.             return -1;

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

  2385.             return -1;

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

  2387.             return -1;

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

  2389.             return 1;

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

  2391.             return -1;

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

  2393.             return -1;

  2394. 

  2395.         // unimplemented

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

  2397.         return 0;

  2398.     }

  2399. 

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

  2401.     {

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

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

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

  2405. #endif

  2406. 

  2407.         switch (opcode)

  2408.         {

  2409.         case audioMasterVersion:

  2410.             return kVstVersion;

  2411. 

  2412.         case audioMasterGetVendorString:

  2413.             CARLA_ASSERT(ptr != nullptr);

  2414. 

  2415.             if (ptr != nullptr)

  2416.             {

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

  2418.                 return 1;

  2419.             }

  2420.             else

  2421.             {

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

  2423.                 return 0;

  2424.             }

  2425. 

  2426.         case audioMasterGetProductString:

  2427.             CARLA_ASSERT(ptr != nullptr);

  2428. 

  2429.             if (ptr != nullptr)

  2430.             {

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

  2432.                 return 1;

  2433.             }

  2434.             else

  2435.             {

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

  2437.                 return 0;

  2438.             }

  2439. 

  2440.         case audioMasterGetVendorVersion:

  2441.             return 0x080; // 0.8.0

  2442. 

  2443.         case audioMasterCanDo:

  2444.             CARLA_ASSERT(ptr != nullptr);

  2445. 

  2446.             if (ptr != nullptr)

  2447.             {

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

  2449.             }

  2450.             else

  2451.             {

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

  2453.                 return 0;

  2454.             }

  2455. 

  2456.         case audioMasterGetLanguage:

  2457.             return kVstLangEnglish;

  2458.         }

  2459. 

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

  2461.         VstPlugin* self = nullptr;

  2462. 

  2463.         if (effect != nullptr)

  2464.         {

  2465. #ifdef VESTIGE_HEADER

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

  2467.             {

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

  2469. #else

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

  2471.             {

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

  2473. #endif

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

  2475.                     self = nullptr;

  2476.             }

  2477. 

  2478.             if (self != nullptr)

  2479.             {

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

  2481.                     self->fEffect = effect;

  2482. 

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

  2484.                 {

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

  2486.                     self = nullptr;

  2487.                 }

  2488.             }

  2489.             else if (sLastVstPlugin != nullptr)

  2490.             {

  2491. #ifdef VESTIGE_HEADER

  2492.                 effect->ptr1 = sLastVstPlugin;

  2493. #else

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

  2495. #endif

  2496.                 self = sLastVstPlugin;

  2497.             }

  2498.         }

  2499. 

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

  2501.     }

  2502. 

  2503.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(VstPlugin)

  2504. };

  2505. 

  2506. VstPlugin* VstPlugin::sLastVstPlugin = nullptr;

  2507. 

  2508. CARLA_BACKEND_END_NAMESPACE

  2509. 

  2510. #else // WANT_VST

  2511. # warning Building without VST support

  2512. #endif

  2513. 

  2514. CARLA_BACKEND_START_NAMESPACE

  2515. 

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

  2517. {

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

  2519. 

  2520. #ifdef WANT_VST

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

  2522. 

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

  2524.     {

  2525.         delete plugin;

  2526.         return nullptr;

  2527.     }

  2528. 

  2529.     plugin->reload();

  2530. 

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

  2532.     {

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

  2534.         delete plugin;

  2535.         return nullptr;

  2536.     }

  2537. 

  2538.     return plugin;

  2539. #else

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

  2541.     return nullptr;

  2542. #endif

  2543. }

  2544. 

  2545. CARLA_BACKEND_END_NAMESPACE