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

2563 lines
82KB
Raw Blame History 

  1. /*

  2.  * Carla VST Plugin

  3.  * Copyright (C) 2011-2013 Filipe Coelho <falktx@falktx.com>

  4.  *

  5.  * This program is free software; you can redistribute it and/or

  6.  * modify it under the terms of the GNU General Public License as

  7.  * published by the Free Software Foundation; either version 2 of

  8.  * the License, or any later version.

  9.  *

  10.  * This program is distributed in the hope that it will be useful,

  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

  13.  * GNU General Public License for more details.

  14.  *

  15.  * For a full copy of the GNU General Public License see the 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.                         if ((fOptions & PLUGIN_OPTION_SEND_CONTROL_CHANGES) != 0 && ctrlEvent.param <= 0x5F)

  1283.                         {

  1284.                             if (fMidiEventCount >= MAX_MIDI_EVENTS*2)

  1285.                                 continue;

  1286. 

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

  1288. 

  1289.                             fMidiEvents[fMidiEventCount].type = kVstMidiType;

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

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

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

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

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

  1295. 

  1296.                             fMidiEventCount += 1;

  1297.                         }

  1298. 

  1299.                         break;

  1300.                     }

  1301. 

  1302.                     case kEngineControlEventTypeMidiBank:

  1303.                         break;

  1304. 

  1305.                     case kEngineControlEventTypeMidiProgram:

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

  1307.                         {

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

  1309.                             {

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

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

  1312.                                 break;

  1313.                             }

  1314.                         }

  1315.                         break;

  1316. 

  1317.                     case kEngineControlEventTypeAllSoundOff:

  1318.                         if (fOptions & PLUGIN_OPTION_SEND_ALL_SOUND_OFF)

  1319.                         {

  1320.                             if (fMidiEventCount >= MAX_MIDI_EVENTS*2)

  1321.                                 continue;

  1322. 

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

  1324. 

  1325.                             fMidiEvents[fMidiEventCount].type = kVstMidiType;

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

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

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

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

  1330. 

  1331.                             fMidiEventCount += 1;

  1332.                         }

  1333.                         break;

  1334. 

  1335.                     case kEngineControlEventTypeAllNotesOff:

  1336.                         if (fOptions & PLUGIN_OPTION_SEND_ALL_SOUND_OFF)

  1337.                         {

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

  1339.                             {

  1340.                                 allNotesOffSent = true;

  1341.                                 sendMidiAllNotesOffToCallback();

  1342.                             }

  1343. 

  1344.                             if (fMidiEventCount >= MAX_MIDI_EVENTS*2)

  1345.                                 continue;

  1346. 

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

  1348. 

  1349.                             fMidiEvents[fMidiEventCount].type = kVstMidiType;

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

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

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

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

  1354. 

  1355.                             fMidiEventCount += 1;

  1356.                         }

  1357.                         break;

  1358.                     }

  1359. 

  1360.                     break;

  1361.                 }

  1362. 

  1363.                 case kEngineEventTypeMidi:

  1364.                 {

  1365.                     if (fMidiEventCount >= MAX_MIDI_EVENTS*2)

  1366.                         continue;

  1367. 

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

  1369. 

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

  1371.                     uint8_t channel = event.channel;

  1372. 

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

  1374.                         continue;

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

  1376.                         continue;

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

  1378.                         continue;

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

  1380.                         continue;

  1381. 

  1382.                     // Fix bad note-off

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

  1384.                         status -= 0x10;

  1385. 

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

  1387. 

  1388.                     fMidiEvents[fMidiEventCount].type = kVstMidiType;

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

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

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

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

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

  1394. 

  1395.                     fMidiEventCount += 1;

  1396. 

  1397.                     if (status == MIDI_STATUS_NOTE_ON)

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

  1399.                     else if (status == MIDI_STATUS_NOTE_OFF)

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

  1401. 

  1402.                     break;

  1403.                 }

  1404.                 }

  1405.             }

  1406. 

  1407.             kData->postRtEvents.trySplice();

  1408. 

  1409.             if (frames > timeOffset)

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

  1411. 

  1412.         } // End of Event Input and Processing

  1413. 

  1414.         // --------------------------------------------------------------------------------------------------------

  1415.         // Plugin processing (no events)

  1416. 

  1417.         else

  1418.         {

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

  1420. 

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

  1422. 

  1423.         CARLA_PROCESS_CONTINUE_CHECK;

  1424. 

  1425.         // --------------------------------------------------------------------------------------------------------

  1426.         // MIDI Output

  1427. 

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

  1429.         {

  1430.             // reverse lookup MIDI events

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

  1432.             {

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

  1434.                     break;

  1435. 

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

  1437. 

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

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

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

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

  1442. 

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

  1444.             }

  1445. 

  1446.         } // End of Control and MIDI Output

  1447.     }

  1448. 

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

  1450.     {

  1451.         CARLA_ASSERT(frames > 0);

  1452. 

  1453.         if (frames == 0)

  1454.             return false;

  1455. 

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

  1457.         {

  1458.             CARLA_ASSERT(inBuffer != nullptr);

  1459.             if (inBuffer == nullptr)

  1460.                 return false;

  1461.         }

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

  1463.         {

  1464.             CARLA_ASSERT(outBuffer != nullptr);

  1465.             if (outBuffer == nullptr)

  1466.                 return false;

  1467.         }

  1468. 

  1469.         uint32_t i, k;

  1470. 

  1471.         // --------------------------------------------------------------------------------------------------------

  1472.         // Try lock, silence otherwise

  1473. 

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

  1475.         {

  1476.             kData->singleMutex.lock();

  1477.         }

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

  1479.         {

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

  1481.             {

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

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

  1484.             }

  1485. 

  1486.             return false;

  1487.         }

  1488. 

  1489.         // --------------------------------------------------------------------------------------------------------

  1490.         // Set audio buffers

  1491. 

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

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

  1494. 

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

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

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

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

  1499. 

  1500.         // --------------------------------------------------------------------------------------------------------

  1501.         // Set MIDI events

  1502. 

  1503.         if (fMidiEventCount > 0)

  1504.         {

  1505.             fEvents.numEvents = fMidiEventCount;

  1506.             fEvents.reserved  = 0;

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

  1508.         }

  1509. 

  1510.         // --------------------------------------------------------------------------------------------------------

  1511.         // Run plugin

  1512. 

  1513.         fIsProcessing = true;

  1514. 

  1515.         if (fHints & PLUGIN_CAN_PROCESS_REPLACING)

  1516.         {

  1517.             fEffect->processReplacing(fEffect,

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

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

  1520.                                       frames);

  1521.         }

  1522.         else

  1523.         {

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

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

  1526. 

  1527. #if ! VST_FORCE_DEPRECATED

  1528.             fEffect->process(fEffect,

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

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

  1531.                              frames);

  1532. #endif

  1533.         }

  1534. 

  1535.         fIsProcessing = false;

  1536.         fTimeInfo.samplePos += frames;

  1537. 

  1538. #ifndef BUILD_BRIDGE

  1539.         // --------------------------------------------------------------------------------------------------------

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

  1541. 

  1542.         {

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

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

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

  1546. 

  1547.             bool isPair;

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

  1549. 

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

  1551.             {

  1552.                 // Dry/Wet

  1553.                 if (doDryWet)

  1554.                 {

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

  1556.                     {

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

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

  1559.                     }

  1560.                 }

  1561. 

  1562.                 // Balance

  1563.                 if (doBalance)

  1564.                 {

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

  1566. 

  1567.                     if (isPair)

  1568.                     {

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

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

  1571.                     }

  1572. 

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

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

  1575. 

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

  1577.                     {

  1578.                         if (isPair)

  1579.                         {

  1580.                             // left

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

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

  1583.                         }

  1584.                         else

  1585.                         {

  1586.                             // right

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

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

  1589.                         }

  1590.                     }

  1591.                 }

  1592. 

  1593.                 // Volume

  1594.                 if (doVolume)

  1595.                 {

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

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

  1598.                 }

  1599.             }

  1600. 

  1601.         } // End of Post-processing

  1602. #endif

  1603. 

  1604.         // --------------------------------------------------------------------------------------------------------

  1605. 

  1606.         kData->singleMutex.unlock();

  1607.         return true;

  1608.     }

  1609. 

  1610.     void bufferSizeChanged(const uint32_t newBufferSize) override

  1611.     {

  1612.         CARLA_ASSERT_INT(newBufferSize > 0, newBufferSize);

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

  1614. 

  1615.         if (kData->active)

  1616.             deactivate();

  1617. 

  1618. #if ! VST_FORCE_DEPRECATED

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

  1620. #endif

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

  1622. 

  1623.         if (kData->active)

  1624.             activate();

  1625.     }

  1626. 

  1627.     void sampleRateChanged(const double newSampleRate) override

  1628.     {

  1629.         CARLA_ASSERT_INT(newSampleRate > 0.0, newSampleRate);

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

  1631. 

  1632.         if (kData->active)

  1633.             deactivate();

  1634. 

  1635. #if ! VST_FORCE_DEPRECATED

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

  1637. #endif

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

  1639. 

  1640.         if (kData->active)

  1641.             activate();

  1642.     }

  1643. 

  1644.     // -------------------------------------------------------------------

  1645.     // Plugin buffers

  1646. 

  1647.     // nothing

  1648. 

  1649.     // -------------------------------------------------------------------

  1650.     // Post-poned UI Stuff

  1651. 

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

  1653.     {

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

  1655. 

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

  1657.             return;

  1658.         if (! fGui.isOsc)

  1659.             return;

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

  1661.             return;

  1662. 

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

  1664.     }

  1665. 

  1666.     void uiProgramChange(const uint32_t index) override

  1667.     {

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

  1669. 

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

  1671.             return;

  1672.         if (! fGui.isOsc)

  1673.             return;

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

  1675.             return;

  1676. 

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

  1678.     }

  1679. 

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

  1681.     {

  1682.         CARLA_ASSERT(channel < MAX_MIDI_CHANNELS);

  1683.         CARLA_ASSERT(note < MAX_MIDI_NOTE);

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

  1685. 

  1686.         if (channel >= MAX_MIDI_CHANNELS)

  1687.             return;

  1688.         if (note >= MAX_MIDI_NOTE)

  1689.             return;

  1690.         if (velo >= MAX_MIDI_VALUE)

  1691.             return;

  1692.         if (! fGui.isOsc)

  1693.             return;

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

  1695.             return;

  1696. 

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

  1698.         midiData[1] = MIDI_STATUS_NOTE_ON + channel;

  1699.         midiData[2] = note;

  1700.         midiData[3] = velo;

  1701. 

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

  1703.     }

  1704. 

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

  1706.     {

  1707.         CARLA_ASSERT(channel < MAX_MIDI_CHANNELS);

  1708.         CARLA_ASSERT(note < MAX_MIDI_NOTE);

  1709. 

  1710.         if (channel >= MAX_MIDI_CHANNELS)

  1711.             return;

  1712.         if (note >= MAX_MIDI_NOTE)

  1713.             return;

  1714.         if (! fGui.isOsc)

  1715.             return;

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

  1717.             return;

  1718. 

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

  1720.         midiData[1] = MIDI_STATUS_NOTE_OFF + channel;

  1721.         midiData[2] = note;

  1722. 

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

  1724.     }

  1725. 

  1726.     // -------------------------------------------------------------------

  1727. 

  1728. protected:

  1729.     void guiClosedCallback() override

  1730.     {

  1731.         showGui(false);

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

  1733.     }

  1734. 

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

  1736.     {

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

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

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

  1740. #endif

  1741.         CARLA_ASSERT(fEffect != nullptr);

  1742. 

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

  1744.     }

  1745. 

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

  1747.     {

  1748. #if 0

  1749.         // Cockos VST extensions

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

  1751.         {

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

  1753. 

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

  1755.                 return 0;

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

  1757.                 return 0;

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

  1759.                 return 0;

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

  1761.                 return 0;

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

  1763.                 return 0;

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

  1765.                 return 0;

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

  1767.                 return 0;

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

  1769.                 return 0;

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

  1771.                 return 0;

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

  1773.                 return 0;

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

  1775.                 return 0;

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

  1777.                 return 0;

  1778.         }

  1779. #endif

  1780. 

  1781.         intptr_t ret = 0;

  1782. 

  1783.         switch (opcode)

  1784.         {

  1785.         case audioMasterAutomate:

  1786.             if (! fEnabled)

  1787.                 break;

  1788. 

  1789.             // plugins should never do this:

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

  1791. 

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

  1793.                 break;

  1794. 

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

  1796.             {

  1797.                 // Called from GUI

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

  1799.             }

  1800.             else if (fIsProcessing)

  1801.             {

  1802.                 // Called from engine

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

  1804. 

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

  1806.                 {

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

  1808.                 }

  1809.                 else

  1810.                 {

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

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

  1813.                 }

  1814.             }

  1815.             else

  1816.             {

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

  1818.             }

  1819.             break;

  1820. 

  1821.         case audioMasterCurrentId:

  1822.             // TODO

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

  1824.             break;

  1825. 

  1826.         case audioMasterIdle:

  1827.             if (fGui.isVisible)

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

  1829.             break;

  1830. 

  1831. #if ! VST_FORCE_DEPRECATED

  1832.         case audioMasterPinConnected:

  1833.             // Deprecated in VST SDK 2.4

  1834.             // TODO

  1835.             break;

  1836. 

  1837.         case audioMasterWantMidi:

  1838.             // Deprecated in VST SDK 2.4

  1839.             fHints |= PLUGIN_WANTS_MIDI_INPUT;

  1840.             break;

  1841. #endif

  1842. 

  1843.         case audioMasterGetTime:

  1844. #ifdef VESTIGE_HEADER

  1845.             ret = getAddressFromPointer(&fTimeInfo);

  1846. #else

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

  1848. #endif

  1849.             break;

  1850. 

  1851.         case audioMasterProcessEvents:

  1852.             CARLA_ASSERT(fEnabled);

  1853.             CARLA_ASSERT(fIsProcessing);

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

  1855.             CARLA_ASSERT(ptr != nullptr);

  1856. 

  1857.             if (! fEnabled)

  1858.                 return 0;

  1859.             if (! fIsProcessing)

  1860.                 return 0;

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

  1862.                 return 0;

  1863.             if (ptr == nullptr)

  1864.                 return 0;

  1865.             if (! fIsProcessing)

  1866.             {

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

  1868.                 return 0;

  1869.             }

  1870. 

  1871.             if (fMidiEventCount >= MAX_MIDI_EVENTS*2)

  1872.                 return 0;

  1873. 

  1874. 

  1875.         {

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

  1877. 

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

  1879.             {

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

  1881.                     break;

  1882. 

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

  1884. 

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

  1886.                     continue;

  1887. 

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

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

  1890.                 {

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

  1892.                     {

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

  1894.                         break;

  1895.                     }

  1896.                 }

  1897.             }

  1898.         }

  1899. 

  1900.             ret = 1;

  1901.             break;

  1902. 

  1903. #if ! VST_FORCE_DEPRECATED

  1904.         case audioMasterSetTime:

  1905.             // Deprecated in VST SDK 2.4

  1906.             break;

  1907. 

  1908.         case audioMasterTempoAt:

  1909.             // Deprecated in VST SDK 2.4

  1910.             CARLA_ASSERT(fIsProcessing);

  1911.             ret = fTimeInfo.tempo * 10000;

  1912.             break;

  1913. 

  1914.         case audioMasterGetNumAutomatableParameters:

  1915.             // Deprecated in VST SDK 2.4

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

  1917.             break;

  1918. 

  1919.         case audioMasterGetParameterQuantization:

  1920.             // Deprecated in VST SDK 2.4

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

  1922.             break;

  1923. #endif

  1924. 

  1925. #if 0

  1926.         case audioMasterIOChanged:

  1927.             CARLA_ASSERT(fEnabled);

  1928. 

  1929.             // TESTING

  1930. 

  1931.             if (! fEnabled)

  1932.             {

  1933.                 ret = 1;

  1934.                 break;

  1935.             }

  1936. 

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

  1938.             {

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

  1940.                 return 0;

  1941.             }

  1942. 

  1943.             engineProcessLock();

  1944.             m_enabled = false;

  1945.             engineProcessUnlock();

  1946. 

  1947.             if (m_active)

  1948.             {

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

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

  1951.             }

  1952. 

  1953.             reload();

  1954. 

  1955.             if (m_active)

  1956.             {

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

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

  1959.             }

  1960. 

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

  1962. 

  1963.             ret = 1;

  1964.             break;

  1965. #endif

  1966. 

  1967.         case audioMasterNeedIdle:

  1968.             // Deprecated in VST SDK 2.4

  1969.             fNeedIdle = true;

  1970.             ret = 1;

  1971.             break;

  1972. 

  1973.         case audioMasterSizeWindow:

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

  1975.             {

  1976.                 CARLA_SAFE_ASSERT(fGui.isVisible);

  1977.                 if (fGui.isVisible)

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

  1979.                 ret = 1;

  1980.             }

  1981.             break;

  1982. 

  1983.         case audioMasterGetSampleRate:

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

  1985.             break;

  1986. 

  1987.         case audioMasterGetBlockSize:

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

  1989.             break;

  1990. 

  1991.         case audioMasterGetInputLatency:

  1992.             ret = 0;

  1993.             break;

  1994. 

  1995.         case audioMasterGetOutputLatency:

  1996.             ret = 0;

  1997.             break;

  1998. 

  1999. #if ! VST_FORCE_DEPRECATED

  2000.         case audioMasterGetPreviousPlug:

  2001.             // Deprecated in VST SDK 2.4

  2002.             // TODO

  2003.             break;

  2004. 

  2005.         case audioMasterGetNextPlug:

  2006.             // Deprecated in VST SDK 2.4

  2007.             // TODO

  2008.             break;

  2009. 

  2010.         case audioMasterWillReplaceOrAccumulate:

  2011.             // Deprecated in VST SDK 2.4

  2012.             ret = 1; // replace

  2013.             break;

  2014. #endif

  2015. 

  2016.         case audioMasterGetCurrentProcessLevel:

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

  2018.                 ret = kVstProcessLevelOffline;

  2019.             else if (fIsProcessing)

  2020.                 ret = kVstProcessLevelRealtime;

  2021.             else

  2022.                 ret = kVstProcessLevelUser;

  2023.             break;

  2024. 

  2025.         case audioMasterGetAutomationState:

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

  2027.             break;

  2028. 

  2029.         case audioMasterOfflineStart:

  2030.         case audioMasterOfflineRead:

  2031.         case audioMasterOfflineWrite:

  2032.         case audioMasterOfflineGetCurrentPass:

  2033.         case audioMasterOfflineGetCurrentMetaPass:

  2034.             // TODO

  2035.             break;

  2036. 

  2037. #if ! VST_FORCE_DEPRECATED

  2038.         case audioMasterSetOutputSampleRate:

  2039.             // Deprecated in VST SDK 2.4

  2040.             break;

  2041. 

  2042.         case audioMasterGetOutputSpeakerArrangement:

  2043.             // Deprecated in VST SDK 2.4

  2044.             // TODO

  2045.             break;

  2046. #endif

  2047. 

  2048.         case audioMasterVendorSpecific:

  2049.             // TODO - cockos extensions

  2050.             break;

  2051. 

  2052. #if ! VST_FORCE_DEPRECATED

  2053.         case audioMasterSetIcon:

  2054.             // Deprecated in VST SDK 2.4

  2055.             break;

  2056. #endif

  2057. 

  2058. #if ! VST_FORCE_DEPRECATED

  2059.         case audioMasterOpenWindow:

  2060.         case audioMasterCloseWindow:

  2061.             // Deprecated in VST SDK 2.4

  2062.             // TODO

  2063.             break;

  2064. #endif

  2065. 

  2066.         case audioMasterGetDirectory:

  2067.             // TODO

  2068.             break;

  2069. 

  2070.         case audioMasterUpdateDisplay:

  2071.             // Idle UI if visible

  2072.             if (fGui.isVisible)

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

  2074. 

  2075.             // Update current program

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

  2077.             {

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

  2079. 

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

  2081.                 {

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

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

  2084. 

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

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

  2087. 

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

  2089. 

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

  2091.                     {

  2092.                         kData->prog.current = current;

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

  2094.                     }

  2095.                 }

  2096.             }

  2097. 

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

  2099.             ret = 1;

  2100.             break;

  2101. 

  2102.         case audioMasterBeginEdit:

  2103.         case audioMasterEndEdit:

  2104.             // TODO

  2105.             break;

  2106. 

  2107.         case audioMasterOpenFileSelector:

  2108.         case audioMasterCloseFileSelector:

  2109.             // TODO

  2110.             break;

  2111. 

  2112. #if ! VST_FORCE_DEPRECATED

  2113.         case audioMasterEditFile:

  2114.             // Deprecated in VST SDK 2.4

  2115.             // TODO

  2116.             break;

  2117. 

  2118.         case audioMasterGetChunkFile:

  2119.             // Deprecated in VST SDK 2.4

  2120.             // TODO

  2121.             break;

  2122. 

  2123.         case audioMasterGetInputSpeakerArrangement:

  2124.             // Deprecated in VST SDK 2.4

  2125.             // TODO

  2126.             break;

  2127. #endif

  2128. 

  2129.         default:

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

  2131.             break;

  2132.         }

  2133. 

  2134.         return ret;

  2135.     }

  2136. 

  2137.     // -------------------------------------------------------------------

  2138. 

  2139. public:

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

  2141.     {

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

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

  2144.         CARLA_ASSERT(filename != nullptr);

  2145. 

  2146.         // ---------------------------------------------------------------

  2147.         // first checks

  2148. 

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

  2150.         {

  2151.             return false;

  2152.         }

  2153. 

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

  2155.         {

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

  2157.             return false;

  2158.         }

  2159. 

  2160.         if (filename == nullptr)

  2161.         {

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

  2163.             return false;

  2164.         }

  2165. 

  2166.         // ---------------------------------------------------------------

  2167.         // open DLL

  2168. 

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

  2170.         {

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

  2172.             return false;

  2173.         }

  2174. 

  2175.         // ---------------------------------------------------------------

  2176.         // get DLL main entry

  2177. 

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

  2179. 

  2180.         if (vstFn == nullptr)

  2181.         {

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

  2183. 

  2184.             if (vstFn == nullptr)

  2185.             {

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

  2187.                 return false;

  2188.             }

  2189.         }

  2190. 

  2191.         // ---------------------------------------------------------------

  2192.         // initialize plugin (part 1)

  2193. 

  2194.         sLastVstPlugin = this;

  2195.         fEffect = vstFn(carla_vst_audioMasterCallback);

  2196.         sLastVstPlugin = nullptr;

  2197. 

  2198.         if (fEffect == nullptr)

  2199.         {

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

  2201.             return false;

  2202.         }

  2203. 

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

  2205.         {

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

  2207.             return false;

  2208.         }

  2209. 

  2210. #ifdef VESTIGE_HEADER

  2211.         fEffect->ptr1 = this;

  2212. #else

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

  2214. #endif

  2215. 

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

  2217. 

  2218.         // ---------------------------------------------------------------

  2219.         // get info

  2220. 

  2221.         if (name != nullptr)

  2222.         {

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

  2224.         }

  2225.         else

  2226.         {

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

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

  2229. 

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

  2231.             {

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

  2233.             }

  2234.             else

  2235.             {

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

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

  2238.             }

  2239.         }

  2240. 

  2241.         fFilename = filename;

  2242. 

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

  2244.         // register client

  2245. 

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

  2247. 

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

  2249.         {

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

  2251.             return false;

  2252.         }

  2253. 

  2254.         // ---------------------------------------------------------------

  2255.         // initialize plugin (part 2)

  2256. 

  2257. #if ! VST_FORCE_DEPRECATED

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

  2259. #endif

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

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

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

  2263. 

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

  2265.             fHints |= PLUGIN_USES_OLD_VSTSDK;

  2266. 

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

  2268.             fHints |= PLUGIN_HAS_COCKOS_EXTENSIONS;

  2269. 

  2270.         // ---------------------------------------------------------------

  2271.         // gui stuff

  2272. 

  2273.         if (fEffect->flags & effFlagsHasEditor)

  2274.         {

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

  2276. 

  2277. #if defined(Q_WS_X11)

  2278.             CarlaString uiBridgeBinary(engineOptions.bridge_vstX11);

  2279. #elif defined(CARLA_OS_MAC)

  2280.             CarlaString uiBridgeBinary(engineOptions.bridge_vstCocoa);

  2281. #elif defined(CARLA_OS_WIN)

  2282.             CarlaString uiBridgeBinary(engineOptions.bridge_vstHWND);

  2283. #else

  2284.             CarlaString uiBridgeBinary;

  2285. #endif

  2286. 

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

  2288.             {

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

  2290.                 fGui.isOsc = true;

  2291.             }

  2292.         }

  2293. 

  2294.         // ---------------------------------------------------------------

  2295.         // load plugin settings

  2296. 

  2297.         {

  2298.             // set default options

  2299.             fOptions = 0x0;

  2300. 

  2301.             fOptions |= PLUGIN_OPTION_MAP_PROGRAM_CHANGES;

  2302. 

  2303.             if (midiInCount() > 0)

  2304.                 fOptions |= PLUGIN_OPTION_FIXED_BUFFER;

  2305. 

  2306.             if (fEffect->flags & effFlagsProgramChunks)

  2307.                 fOptions |= PLUGIN_OPTION_USE_CHUNKS;

  2308. 

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

  2310.             {

  2311.                 fOptions |= PLUGIN_OPTION_SEND_CHANNEL_PRESSURE;

  2312.                 fOptions |= PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH;

  2313.                 fOptions |= PLUGIN_OPTION_SEND_PITCHBEND;

  2314.                 fOptions |= PLUGIN_OPTION_SEND_ALL_SOUND_OFF;

  2315.             }

  2316. 

  2317.             // load settings

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

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

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

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

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

  2323. 

  2324.             // ignore settings, we need this anyway

  2325.             if (midiInCount() > 0)

  2326.                 fOptions |= PLUGIN_OPTION_FIXED_BUFFER;

  2327.         }

  2328. 

  2329.         return true;

  2330.     }

  2331. 

  2332. private:

  2333.     int fUnique1;

  2334.     AEffect* fEffect;

  2335. 

  2336.     void*         fLastChunk;

  2337.     uint32_t      fMidiEventCount;

  2338.     VstMidiEvent  fMidiEvents[MAX_MIDI_EVENTS*2];

  2339.     VstTimeInfo_R fTimeInfo;

  2340. 

  2341.     struct FixedVstEvents {

  2342.         int32_t numEvents;

  2343.         intptr_t reserved;

  2344.         VstEvent* data[MAX_MIDI_EVENTS*2];

  2345. 

  2346.         FixedVstEvents()

  2347.             : numEvents(0),

  2348.               reserved(0),

  2349.               data{nullptr} {}

  2350.     } fEvents;

  2351. 

  2352.     struct GuiInfo {

  2353.         bool isOsc;

  2354.         bool isVisible;

  2355.         int  lastWidth;

  2356.         int  lastHeight;

  2357. 

  2358.         GuiInfo()

  2359.             : isOsc(false),

  2360.               isVisible(false),

  2361.               lastWidth(0),

  2362.               lastHeight(0) {}

  2363.     } fGui;

  2364. 

  2365.     bool fIsProcessing;

  2366.     bool fNeedIdle;

  2367.     int  fUnique2;

  2368. 

  2369.     static VstPlugin* sLastVstPlugin;

  2370. 

  2371.     // -------------------------------------------------------------------

  2372. 

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

  2374.     {

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

  2376. 

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

  2378.             return 1;

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

  2380.             return 1;

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

  2382.             return 1;

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

  2384.             return 1;

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

  2386.             return 1;

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

  2388.             return 1;

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

  2390.             return 1;

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

  2392.             return -1;

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

  2394.             return -1;

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

  2396.             return 1;

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

  2398.             return 1;

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

  2400.             return -1;

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

  2402.             return -1;

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

  2404.             return -1;

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

  2406.             return 1;

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

  2408.             return -1;

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

  2410.             return -1;

  2411. 

  2412.         // unimplemented

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

  2414.         return 0;

  2415.     }

  2416. 

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

  2418.     {

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

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

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

  2422. #endif

  2423. 

  2424.         switch (opcode)

  2425.         {

  2426.         case audioMasterVersion:

  2427.             return kVstVersion;

  2428. 

  2429.         case audioMasterGetVendorString:

  2430.             CARLA_ASSERT(ptr != nullptr);

  2431. 

  2432.             if (ptr != nullptr)

  2433.             {

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

  2435.                 return 1;

  2436.             }

  2437.             else

  2438.             {

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

  2440.                 return 0;

  2441.             }

  2442. 

  2443.         case audioMasterGetProductString:

  2444.             CARLA_ASSERT(ptr != nullptr);

  2445. 

  2446.             if (ptr != nullptr)

  2447.             {

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

  2449.                 return 1;

  2450.             }

  2451.             else

  2452.             {

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

  2454.                 return 0;

  2455.             }

  2456. 

  2457.         case audioMasterGetVendorVersion:

  2458.             return 0x080; // 0.8.0

  2459. 

  2460.         case audioMasterCanDo:

  2461.             CARLA_ASSERT(ptr != nullptr);

  2462. 

  2463.             if (ptr != nullptr)

  2464.             {

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

  2466.             }

  2467.             else

  2468.             {

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

  2470.                 return 0;

  2471.             }

  2472. 

  2473.         case audioMasterGetLanguage:

  2474.             return kVstLangEnglish;

  2475.         }

  2476. 

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

  2478.         VstPlugin* self = nullptr;

  2479. 

  2480.         if (effect != nullptr)

  2481.         {

  2482. #ifdef VESTIGE_HEADER

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

  2484.             {

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

  2486. #else

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

  2488.             {

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

  2490. #endif

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

  2492.                     self = nullptr;

  2493.             }

  2494. 

  2495.             if (self != nullptr)

  2496.             {

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

  2498.                     self->fEffect = effect;

  2499. 

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

  2501.                 {

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

  2503.                     self = nullptr;

  2504.                 }

  2505.             }

  2506.             else if (sLastVstPlugin != nullptr)

  2507.             {

  2508. #ifdef VESTIGE_HEADER

  2509.                 effect->ptr1 = sLastVstPlugin;

  2510. #else

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

  2512. #endif

  2513.                 self = sLastVstPlugin;

  2514.             }

  2515.         }

  2516. 

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

  2518.     }

  2519. 

  2520.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(VstPlugin)

  2521. };

  2522. 

  2523. VstPlugin* VstPlugin::sLastVstPlugin = nullptr;

  2524. 

  2525. CARLA_BACKEND_END_NAMESPACE

  2526. 

  2527. #else // WANT_VST

  2528. # warning Building without VST support

  2529. #endif

  2530. 

  2531. CARLA_BACKEND_START_NAMESPACE

  2532. 

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

  2534. {

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

  2536. 

  2537. #ifdef WANT_VST

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

  2539. 

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

  2541.     {

  2542.         delete plugin;

  2543.         return nullptr;

  2544.     }

  2545. 

  2546.     plugin->reload();

  2547. 

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

  2549.     {

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

  2551.         delete plugin;

  2552.         return nullptr;

  2553.     }

  2554. 

  2555.     return plugin;

  2556. #else

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

  2558.     return nullptr;

  2559. #endif

  2560. }

  2561. 

  2562. CARLA_BACKEND_END_NAMESPACE