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

2562 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);

  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->gui->close();

  444.                         delete kData->gui;

  445.                         kData->gui = nullptr;

  446.                     }

  447. 

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

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

  450.                     return;

  451.                 }

  452.             }

  453.             else

  454.             {

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

  456. 

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

  458. 

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

  460.                 {

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

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

  463. 

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

  465.                     delete kData->gui;

  466.                     kData->gui = nullptr;

  467.                 }

  468.             }

  469.         }

  470. 

  471.         fGui.isVisible = yesNo;

  472.     }

  473. 

  474.     void idleGui() override

  475.     {

  476. #ifdef VESTIGE_HEADER

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

  478. #else

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

  480. #endif

  481.         {

  482.             if (fNeedIdle)

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

  484. 

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

  486.             {

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

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

  489.             }

  490.         }

  491. 

  492.         CarlaPlugin::idleGui();

  493.     }

  494. 

  495.     // -------------------------------------------------------------------

  496.     // Plugin state

  497. 

  498.     void reload() override

  499.     {

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

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

  502.         CARLA_ASSERT(fEffect != nullptr);

  503. 

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

  505.             return;

  506.         if (fEffect == nullptr)

  507.             return;

  508. 

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

  510. 

  511.         // Safely disable plugin for reload

  512.         const ScopedDisabler sd(this);

  513. 

  514.         if (kData->active)

  515.             deactivate();

  516. 

  517.         clearBuffers();

  518. 

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

  520. 

  521.         bool needsCtrlIn, needsCtrlOut;

  522.         needsCtrlIn = needsCtrlOut = false;

  523. 

  524.         aIns   = fEffect->numInputs;

  525.         aOuts  = fEffect->numOutputs;

  526.         params = fEffect->numParams;

  527. 

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

  529.         {

  530.             mIns = 1;

  531.             needsCtrlIn = true;

  532.         }

  533.         else

  534.             mIns = 0;

  535. 

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

  537.         {

  538.             mOuts = 1;

  539.             needsCtrlOut = true;

  540.         }

  541.         else

  542.             mOuts = 0;

  543. 

  544.         if (aIns > 0)

  545.         {

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

  547.         }

  548. 

  549.         if (aOuts > 0)

  550.         {

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

  552.             needsCtrlIn = true;

  553.         }

  554. 

  555.         if (params > 0)

  556.         {

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

  558.             needsCtrlIn = true;

  559.         }

  560. 

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

  562.         CarlaString portName;

  563. 

  564.         // Audio Ins

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

  566.         {

  567.             portName.clear();

  568. 

  569.             if (processMode == PROCESS_MODE_SINGLE_CLIENT)

  570.             {

  571.                 portName  = fName;

  572.                 portName += ":";

  573.             }

  574. 

  575.             if (aIns > 1)

  576.             {

  577.                 portName += "input_";

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

  579.             }

  580.             else

  581.                 portName += "input";

  582. 

  583.             portName.truncate(portNameSize);

  584. 

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

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

  587.         }

  588. 

  589.         // Audio Outs

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

  591.         {

  592.             portName.clear();

  593. 

  594.             if (processMode == PROCESS_MODE_SINGLE_CLIENT)

  595.             {

  596.                 portName  = fName;

  597.                 portName += ":";

  598.             }

  599. 

  600.             if (aOuts > 1)

  601.             {

  602.                 portName += "output_";

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

  604.             }

  605.             else

  606.                 portName += "output";

  607. 

  608.             portName.truncate(portNameSize);

  609. 

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

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

  612.         }

  613. 

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

  615.         {

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

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

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

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

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

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

  622. 

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

  624. 

  625.             VstParameterProperties prop;

  626.             carla_zeroStruct<VstParameterProperties>(prop);

  627. 

  628.             if (fHints & PLUGIN_HAS_COCKOS_EXTENSIONS)

  629.             {

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

  631. 

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

  633.                 {

  634.                     min = range[0];

  635.                     max = range[1];

  636. 

  637.                     if (min > max)

  638.                         max = min;

  639.                     else if (max < min)

  640.                         min = max;

  641. 

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

  643.                     {

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

  645.                         max = min + 0.1f;

  646.                     }

  647.                 }

  648.                 else

  649.                 {

  650.                     min = 0.0f;

  651.                     max = 1.0f;

  652.                 }

  653. 

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

  655.                 {

  656.                     step = 1.0f;

  657.                     stepSmall = 1.0f;

  658.                     stepLarge = 10.0f;

  659.                 }

  660.                 else

  661.                 {

  662.                     float range = max - min;

  663.                     step = range/100.0f;

  664.                     stepSmall = range/1000.0f;

  665.                     stepLarge = range/10.0f;

  666.                 }

  667.             }

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

  669.             {

  670.                 if (prop.flags & kVstParameterUsesIntegerMinMax)

  671.                 {

  672.                     min = float(prop.minInteger);

  673.                     max = float(prop.maxInteger);

  674. 

  675.                     if (min > max)

  676.                         max = min;

  677.                     else if (max < min)

  678.                         min = max;

  679. 

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

  681.                     {

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

  683.                         max = min + 0.1f;

  684.                     }

  685.                 }

  686.                 else

  687.                 {

  688.                     min = 0.0f;

  689.                     max = 1.0f;

  690.                 }

  691. 

  692.                 if (prop.flags & kVstParameterIsSwitch)

  693.                 {

  694.                     step = max - min;

  695.                     stepSmall = step;

  696.                     stepLarge = step;

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

  698.                 }

  699.                 else if (prop.flags & kVstParameterUsesIntStep)

  700.                 {

  701.                     step = float(prop.stepInteger);

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

  703.                     stepLarge = float(prop.largeStepInteger);

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

  705.                 }

  706.                 else if (prop.flags & kVstParameterUsesFloatStep)

  707.                 {

  708.                     step = prop.stepFloat;

  709.                     stepSmall = prop.smallStepFloat;

  710.                     stepLarge = prop.largeStepFloat;

  711.                 }

  712.                 else

  713.                 {

  714.                     float range = max - min;

  715.                     step = range/100.0f;

  716.                     stepSmall = range/1000.0f;

  717.                     stepLarge = range/10.0f;

  718.                 }

  719. 

  720.                 if (prop.flags & kVstParameterCanRamp)

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

  722.             }

  723.             else

  724.             {

  725.                 min = 0.0f;

  726.                 max = 1.0f;

  727.                 step = 0.001f;

  728.                 stepSmall = 0.0001f;

  729.                 stepLarge = 0.1f;

  730.             }

  731. 

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

  733. #ifndef BUILD_BRIDGE

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

  735. #endif

  736. 

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

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

  739. 

  740.             // no such thing as VST default parameters

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

  742. 

  743.             if (def < min)

  744.                 def = min;

  745.             else if (def > max)

  746.                 def = max;

  747. 

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

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

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

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

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

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

  754.         }

  755. 

  756.         if (needsCtrlIn)

  757.         {

  758.             portName.clear();

  759. 

  760.             if (processMode == PROCESS_MODE_SINGLE_CLIENT)

  761.             {

  762.                 portName  = fName;

  763.                 portName += ":";

  764.             }

  765. 

  766.             portName += "events-in";

  767.             portName.truncate(portNameSize);

  768. 

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

  770.         }

  771. 

  772.         if (needsCtrlOut)

  773.         {

  774.             portName.clear();

  775. 

  776.             if (processMode == PROCESS_MODE_SINGLE_CLIENT)

  777.             {

  778.                 portName  = fName;

  779.                 portName += ":";

  780.             }

  781. 

  782.             portName += "events-out";

  783.             portName.truncate(portNameSize);

  784. 

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

  786.         }

  787. 

  788.         // plugin hints

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

  790. 

  791.         fHints = 0x0;

  792. 

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

  794.             fHints |= PLUGIN_IS_SYNTH;

  795. 

  796.         if (fEffect->flags & effFlagsHasEditor)

  797.         {

  798.             fHints |= PLUGIN_HAS_GUI;

  799. 

  800.             if (! fGui.isOsc)

  801.                 fHints |= PLUGIN_HAS_SINGLE_THREAD;

  802.         }

  803. 

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

  805.             fHints |= PLUGIN_USES_OLD_VSTSDK;

  806. 

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

  808.             fHints |= PLUGIN_CAN_PROCESS_REPLACING;

  809. 

  810.         if (fEffect->flags & effFlagsHasEditor)

  811.             fHints |= PLUGIN_HAS_GUI;

  812. 

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

  814.             fHints |= PLUGIN_HAS_COCKOS_EXTENSIONS;

  815. 

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

  817.             fHints |= PLUGIN_CAN_DRYWET;

  818. 

  819.         if (aOuts > 0)

  820.             fHints |= PLUGIN_CAN_VOLUME;

  821. 

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

  823.             fHints |= PLUGIN_CAN_BALANCE;

  824. 

  825.         // extra plugin hints

  826.         kData->extraHints = 0x0;

  827. 

  828.         if (mIns > 0)

  829.             kData->extraHints |= PLUGIN_HINT_HAS_MIDI_IN;

  830. 

  831.         if (mOuts > 0)

  832.             kData->extraHints |= PLUGIN_HINT_HAS_MIDI_OUT;

  833. 

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

  835.             kData->extraHints |= PLUGIN_HINT_CAN_RUN_RACK;

  836. 

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

  838.         {

  839.             activate();

  840.             deactivate();

  841.         }

  842. 

  843.         // check latency

  844.         if (fHints & PLUGIN_CAN_DRYWET)

  845.         {

  846. #ifdef VESTIGE_HEADER

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

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

  849.             kData->latency = *initialDelayPtr;

  850. #else

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

  852. #endif

  853. 

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

  855.             kData->recreateLatencyBuffers();

  856.         }

  857. 

  858.         // special plugin fixes

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

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

  861.         {

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

  863.             getLabel(strBuf);

  864. 

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

  866.             {

  867.                 // TODO - disable threaded processing

  868.             }

  869.         }

  870. 

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

  872.         reloadPrograms(true);

  873. 

  874.         if (kData->active)

  875.             activate();

  876. 

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

  878.     }

  879. 

  880.     void reloadPrograms(const bool init) override

  881.     {

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

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

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

  885. 

  886.         // Delete old programs

  887.         kData->prog.clear();

  888. 

  889.         // Query new programs

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

  891. 

  892.         if (count > 0)

  893.         {

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

  895. 

  896.             // Update names

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

  898.             {

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

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

  901.                 {

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

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

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

  905.                 }

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

  907.             }

  908.         }

  909. 

  910. #ifndef BUILD_BRIDGE

  911.         // Update OSC Names

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

  913.         {

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

  915. 

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

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

  918.         }

  919. #endif

  920. 

  921.         if (init)

  922.         {

  923.             if (count > 0)

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

  925.         }

  926.         else

  927.         {

  928.             // Check if current program is invalid

  929.             bool programChanged = false;

  930. 

  931.             if (count == oldCount+1)

  932.             {

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

  934.                 kData->prog.current = oldCount;

  935.                 programChanged = true;

  936.             }

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

  938.             {

  939.                 // programs exist now, but not before

  940.                 kData->prog.current = 0;

  941.                 programChanged = true;

  942.             }

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

  944.             {

  945.                 // programs existed before, but not anymore

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

  947.                 programChanged = true;

  948.             }

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

  950.             {

  951.                 // current program > count

  952.                 kData->prog.current = 0;

  953.                 programChanged = true;

  954.             }

  955.             else

  956.             {

  957.                 // no change

  958.                 kData->prog.current = current;

  959.             }

  960. 

  961.             if (programChanged)

  962.             {

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

  964.             }

  965.             else

  966.             {

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

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

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

  970.             }

  971. 

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

  973.         }

  974.     }

  975. 

  976.     // -------------------------------------------------------------------

  977.     // Plugin processing

  978. 

  979.     void activate() override

  980.     {

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

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

  983.     }

  984. 

  985.     void deactivate() override

  986.     {

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

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

  989.     }

  990. 

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

  992.     {

  993.         uint32_t i, k;

  994. 

  995.         // --------------------------------------------------------------------------------------------------------

  996.         // Check if active

  997. 

  998.         if (! kData->active)

  999.         {

  1000.             // disable any output sound

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

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

  1003. 

  1004.             return;

  1005.         }

  1006. 

  1007.         fMidiEventCount = 0;

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

  1009. 

  1010.         // --------------------------------------------------------------------------------------------------------

  1011.         // Check if needs reset

  1012. 

  1013.         if (kData->needsReset)

  1014.         {

  1015.             if (fOptions & PLUGIN_OPTION_SEND_ALL_SOUND_OFF)

  1016.             {

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

  1018.                 {

  1019.                     fMidiEvents[k].type = kVstMidiType;

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

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

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

  1023. 

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

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

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

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

  1028.                 }

  1029. 

  1030.                 fMidiEventCount = MAX_MIDI_CHANNELS*2;

  1031.             }

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

  1033.             {

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

  1035.                 {

  1036.                     fMidiEvents[k].type = kVstMidiType;

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

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

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

  1040.                 }

  1041. 

  1042.                 fMidiEventCount = MAX_MIDI_NOTE;

  1043.             }

  1044. 

  1045.             if (kData->latency > 0)

  1046.             {

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

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

  1049.             }

  1050. 

  1051.             kData->needsReset = false;

  1052.         }

  1053. 

  1054.         CARLA_PROCESS_CONTINUE_CHECK;

  1055. 

  1056.         // --------------------------------------------------------------------------------------------------------

  1057.         // Set TimeInfo

  1058. 

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

  1060. 

  1061.         fTimeInfo.flags = kVstTransportChanged;

  1062. 

  1063.         if (timeInfo.playing)

  1064.             fTimeInfo.flags |= kVstTransportPlaying;

  1065. 

  1066.         fTimeInfo.samplePos  = timeInfo.frame;

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

  1068. 

  1069.         if (timeInfo.usecs != 0)

  1070.         {

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

  1072.             fTimeInfo.flags |= kVstNanosValid;

  1073.         }

  1074. 

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

  1076.         {

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

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

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

  1080. 

  1081.             // PPQ Pos

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

  1083.             fTimeInfo.flags |= kVstPpqPosValid;

  1084. 

  1085.             // Tempo

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

  1087.             fTimeInfo.flags |= kVstTempoValid;

  1088. 

  1089.             // Bars

  1090.             fTimeInfo.barStartPos = ppqBar;

  1091.             fTimeInfo.flags |= kVstBarsValid;

  1092. 

  1093.             // Time Signature

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

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

  1096.             fTimeInfo.flags |= kVstTimeSigValid;

  1097.         }

  1098.         else

  1099.         {

  1100.             // Tempo

  1101.             fTimeInfo.tempo = 120.0;

  1102.             fTimeInfo.flags |= kVstTempoValid;

  1103. 

  1104.             // Time Signature

  1105.             fTimeInfo.timeSigNumerator   = 4;

  1106.             fTimeInfo.timeSigDenominator = 4;

  1107.             fTimeInfo.flags |= kVstTimeSigValid;

  1108. 

  1109.             // Missing info

  1110.             fTimeInfo.ppqPos = 0.0;

  1111.             fTimeInfo.barStartPos = 0.0;

  1112.         }

  1113. 

  1114.         CARLA_PROCESS_CONTINUE_CHECK;

  1115. 

  1116.         // --------------------------------------------------------------------------------------------------------

  1117.         // Event Input and Processing

  1118. 

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

  1120.         {

  1121.             // ----------------------------------------------------------------------------------------------------

  1122.             // MIDI Input (External)

  1123. 

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

  1125.             {

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

  1127.                 {

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

  1129. 

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

  1131. 

  1132.                     fMidiEvents[fMidiEventCount].type = kVstMidiType;

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

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

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

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

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

  1138. 

  1139.                     fMidiEventCount += 1;

  1140.                 }

  1141. 

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

  1143. 

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

  1145. 

  1146.             // ----------------------------------------------------------------------------------------------------

  1147.             // Event Input (System)

  1148. 

  1149.             bool allNotesOffSent = false;

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

  1151. 

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

  1153.             uint32_t startTime  = 0;

  1154.             uint32_t timeOffset = 0;

  1155. 

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

  1157.             {

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

  1159. 

  1160.                 time = event.time;

  1161. 

  1162.                 if (time >= frames)

  1163.                     continue;

  1164. 

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

  1166. 

  1167.                 if (time > timeOffset && sampleAccurate)

  1168.                 {

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

  1170.                     {

  1171.                         startTime  = 0;

  1172.                         timeOffset = time;

  1173. 

  1174.                         if (fMidiEventCount > 0)

  1175.                         {

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

  1177.                             fMidiEventCount = 0;

  1178.                         }

  1179.                     }

  1180.                     else

  1181.                         startTime += timeOffset;

  1182.                 }

  1183. 

  1184.                 // Control change

  1185.                 switch (event.type)

  1186.                 {

  1187.                 case kEngineEventTypeNull:

  1188.                     break;

  1189. 

  1190.                 case kEngineEventTypeControl:

  1191.                 {

  1192.                     const EngineControlEvent& ctrlEvent = event.ctrl;

  1193. 

  1194.                     switch (ctrlEvent.type)

  1195.                     {

  1196.                     case kEngineControlEventTypeNull:

  1197.                         break;

  1198. 

  1199.                     case kEngineControlEventTypeParameter:

  1200.                     {

  1201. #ifndef BUILD_BRIDGE

  1202.                         // Control backend stuff

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

  1204.                         {

  1205.                             float value;

  1206. 

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

  1208.                             {

  1209.                                 value = ctrlEvent.value;

  1210.                                 setDryWet(value, false, false);

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

  1212.                                 continue;

  1213.                             }

  1214. 

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

  1216.                             {

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

  1218.                                 setVolume(value, false, false);

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

  1220.                                 continue;

  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.                                 continue;

  1249.                             }

  1250.                         }

  1251. #endif

  1252. 

  1253.                         // Control plugin parameters

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

  1255.                         {

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

  1257.                                 continue;

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

  1259.                                 continue;

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

  1261.                                 continue;

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

  1263.                                 continue;

  1264. 

  1265.                             float value;

  1266. 

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

  1268.                             {

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

  1270.                             }

  1271.                             else

  1272.                             {

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

  1274. 

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

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

  1277.                             }

  1278. 

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

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

  1281.                         }

  1282. 

  1283.                         break;

  1284.                     }

  1285. 

  1286.                     case kEngineControlEventTypeMidiBank:

  1287.                         break;

  1288. 

  1289.                     case kEngineControlEventTypeMidiProgram:

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

  1291.                         {

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

  1293.                             {

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

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

  1296.                                 break;

  1297.                             }

  1298.                         }

  1299.                         break;

  1300. 

  1301.                     case kEngineControlEventTypeAllSoundOff:

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

  1303.                         {

  1304.                             if (! allNotesOffSent)

  1305.                             {

  1306.                                 allNotesOffSent = true;

  1307.                                 sendMidiAllNotesOffToCallback();

  1308.                             }

  1309. 

  1310.                             postponeRtEvent(kPluginPostRtEventParameterChange, PARAMETER_ACTIVE, 0, 0.0f);

  1311.                             postponeRtEvent(kPluginPostRtEventParameterChange, PARAMETER_ACTIVE, 0, 1.0f);

  1312.                         }

  1313. 

  1314.                         if (fMidiEventCount >= MAX_MIDI_EVENTS*2)

  1315.                             continue;

  1316. 

  1317.                         if (fOptions & PLUGIN_OPTION_SEND_ALL_SOUND_OFF)

  1318.                         {

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

  1320. 

  1321.                             fMidiEvents[fMidiEventCount].type = kVstMidiType;

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

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

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

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

  1326. 

  1327.                             fMidiEventCount += 1;

  1328.                         }

  1329.                         break;

  1330. 

  1331.                     case kEngineControlEventTypeAllNotesOff:

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

  1333.                         {

  1334.                             if (! allNotesOffSent)

  1335.                             {

  1336.                                 allNotesOffSent = true;

  1337.                                 sendMidiAllNotesOffToCallback();

  1338.                             }

  1339.                         }

  1340. 

  1341.                         if (fMidiEventCount >= MAX_MIDI_EVENTS*2)

  1342.                             continue;

  1343. 

  1344.                         if (fOptions & PLUGIN_OPTION_SEND_ALL_SOUND_OFF)

  1345.                         {

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

  1347. 

  1348.                             fMidiEvents[fMidiEventCount].type = kVstMidiType;

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

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

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

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

  1353. 

  1354.                             fMidiEventCount += 1;

  1355.                         }

  1356.                         break;

  1357.                     }

  1358. 

  1359.                     break;

  1360.                 }

  1361. 

  1362.                 case kEngineEventTypeMidi:

  1363.                 {

  1364.                     if (fMidiEventCount >= MAX_MIDI_EVENTS*2)

  1365.                         continue;

  1366. 

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

  1368. 

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

  1370.                     uint8_t channel = event.channel;

  1371. 

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

  1373.                         continue;

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

  1375.                         continue;

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

  1377.                         continue;

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

  1379.                         continue;

  1380. 

  1381.                     // Fix bad note-off

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

  1383.                         status -= 0x10;

  1384. 

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

  1386. 

  1387.                     fMidiEvents[fMidiEventCount].type = kVstMidiType;

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

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

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

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

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

  1393. 

  1394.                     fMidiEventCount += 1;

  1395. 

  1396.                     if (status == MIDI_STATUS_NOTE_ON)

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

  1398.                     else if (status == MIDI_STATUS_NOTE_OFF)

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

  1400. 

  1401.                     break;

  1402.                 }

  1403.                 }

  1404.             }

  1405. 

  1406.             kData->postRtEvents.trySplice();

  1407. 

  1408.             if (frames > timeOffset)

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

  1410. 

  1411.         } // End of Event Input and Processing

  1412. 

  1413.         // --------------------------------------------------------------------------------------------------------

  1414.         // Plugin processing (no events)

  1415. 

  1416.         else

  1417.         {

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

  1419. 

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

  1421. 

  1422.         CARLA_PROCESS_CONTINUE_CHECK;

  1423. 

  1424.         // --------------------------------------------------------------------------------------------------------

  1425.         // MIDI Output

  1426. 

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

  1428.         {

  1429.             // reverse lookup MIDI events

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

  1431.             {

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

  1433.                     break;

  1434. 

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

  1436. 

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

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

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

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

  1441. 

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

  1443.             }

  1444. 

  1445.         } // End of Control and MIDI Output

  1446.     }

  1447. 

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

  1449.     {

  1450.         CARLA_ASSERT(frames > 0);

  1451. 

  1452.         if (frames == 0)

  1453.             return false;

  1454. 

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

  1456.         {

  1457.             CARLA_ASSERT(inBuffer != nullptr);

  1458.             if (inBuffer == nullptr)

  1459.                 return false;

  1460.         }

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

  1462.         {

  1463.             CARLA_ASSERT(outBuffer != nullptr);

  1464.             if (outBuffer == nullptr)

  1465.                 return false;

  1466.         }

  1467. 

  1468.         uint32_t i, k;

  1469. 

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

  1471.         // Try lock, silence otherwise

  1472. 

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

  1474.         {

  1475.             kData->singleMutex.lock();

  1476.         }

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

  1478.         {

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

  1480.             {

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

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

  1483.             }

  1484. 

  1485.             return false;

  1486.         }

  1487. 

  1488.         // --------------------------------------------------------------------------------------------------------

  1489.         // Set audio buffers

  1490. 

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

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

  1493. 

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

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

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

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

  1498. 

  1499.         // --------------------------------------------------------------------------------------------------------

  1500.         // Set MIDI events

  1501. 

  1502.         if (fMidiEventCount > 0)

  1503.         {

  1504.             fEvents.numEvents = fMidiEventCount;

  1505.             fEvents.reserved  = 0;

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

  1507.         }

  1508. 

  1509.         // --------------------------------------------------------------------------------------------------------

  1510.         // Run plugin

  1511. 

  1512.         fIsProcessing = true;

  1513. 

  1514.         if (fHints & PLUGIN_CAN_PROCESS_REPLACING)

  1515.         {

  1516.             fEffect->processReplacing(fEffect,

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

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

  1519.                                       frames);

  1520.         }

  1521.         else

  1522.         {

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

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

  1525. 

  1526. #if ! VST_FORCE_DEPRECATED

  1527.             fEffect->process(fEffect,

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

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

  1530.                              frames);

  1531. #endif

  1532.         }

  1533. 

  1534.         fIsProcessing = false;

  1535.         fTimeInfo.samplePos += frames;

  1536. 

  1537. #ifndef BUILD_BRIDGE

  1538.         // --------------------------------------------------------------------------------------------------------

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

  1540. 

  1541.         {

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

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

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

  1545. 

  1546.             bool isPair;

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

  1548. 

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

  1550.             {

  1551.                 // Dry/Wet

  1552.                 if (doDryWet)

  1553.                 {

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

  1555.                     {

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

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

  1558.                     }

  1559.                 }

  1560. 

  1561.                 // Balance

  1562.                 if (doBalance)

  1563.                 {

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

  1565. 

  1566.                     if (isPair)

  1567.                     {

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

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

  1570.                     }

  1571. 

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

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

  1574. 

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

  1576.                     {

  1577.                         if (isPair)

  1578.                         {

  1579.                             // left

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

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

  1582.                         }

  1583.                         else

  1584.                         {

  1585.                             // right

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

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

  1588.                         }

  1589.                     }

  1590.                 }

  1591. 

  1592.                 // Volume

  1593.                 if (doVolume)

  1594.                 {

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

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

  1597.                 }

  1598.             }

  1599. 

  1600.         } // End of Post-processing

  1601. #endif

  1602. 

  1603.         // --------------------------------------------------------------------------------------------------------

  1604. 

  1605.         kData->singleMutex.unlock();

  1606.         return true;

  1607.     }

  1608. 

  1609.     void bufferSizeChanged(const uint32_t newBufferSize) override

  1610.     {

  1611.         CARLA_ASSERT_INT(newBufferSize > 0, newBufferSize);

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

  1613. 

  1614.         if (kData->active)

  1615.             deactivate();

  1616. 

  1617. #if ! VST_FORCE_DEPRECATED

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

  1619. #endif

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

  1621. 

  1622.         if (kData->active)

  1623.             activate();

  1624.     }

  1625. 

  1626.     void sampleRateChanged(const double newSampleRate) override

  1627.     {

  1628.         CARLA_ASSERT_INT(newSampleRate > 0.0, newSampleRate);

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

  1630. 

  1631.         if (kData->active)

  1632.             deactivate();

  1633. 

  1634. #if ! VST_FORCE_DEPRECATED

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

  1636. #endif

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

  1638. 

  1639.         if (kData->active)

  1640.             activate();

  1641.     }

  1642. 

  1643.     // -------------------------------------------------------------------

  1644.     // Plugin buffers

  1645. 

  1646.     // nothing

  1647. 

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

  1649.     // Post-poned UI Stuff

  1650. 

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

  1652.     {

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

  1654. 

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

  1656.             return;

  1657.         if (! fGui.isOsc)

  1658.             return;

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

  1660.             return;

  1661. 

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

  1663.     }

  1664. 

  1665.     void uiProgramChange(const uint32_t index) override

  1666.     {

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

  1668. 

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

  1670.             return;

  1671.         if (! fGui.isOsc)

  1672.             return;

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

  1674.             return;

  1675. 

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

  1677.     }

  1678. 

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

  1680.     {

  1681.         CARLA_ASSERT(channel < MAX_MIDI_CHANNELS);

  1682.         CARLA_ASSERT(note < MAX_MIDI_NOTE);

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

  1684. 

  1685.         if (channel >= MAX_MIDI_CHANNELS)

  1686.             return;

  1687.         if (note >= MAX_MIDI_NOTE)

  1688.             return;

  1689.         if (velo >= MAX_MIDI_VALUE)

  1690.             return;

  1691.         if (! fGui.isOsc)

  1692.             return;

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

  1694.             return;

  1695. 

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

  1697.         midiData[1] = MIDI_STATUS_NOTE_ON + channel;

  1698.         midiData[2] = note;

  1699.         midiData[3] = velo;

  1700. 

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

  1702.     }

  1703. 

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

  1705.     {

  1706.         CARLA_ASSERT(channel < MAX_MIDI_CHANNELS);

  1707.         CARLA_ASSERT(note < MAX_MIDI_NOTE);

  1708. 

  1709.         if (channel >= MAX_MIDI_CHANNELS)

  1710.             return;

  1711.         if (note >= MAX_MIDI_NOTE)

  1712.             return;

  1713.         if (! fGui.isOsc)

  1714.             return;

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

  1716.             return;

  1717. 

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

  1719.         midiData[1] = MIDI_STATUS_NOTE_OFF + channel;

  1720.         midiData[2] = note;

  1721. 

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

  1723.     }

  1724. 

  1725.     // -------------------------------------------------------------------

  1726. 

  1727. protected:

  1728.     void guiClosedCallback() override

  1729.     {

  1730.         showGui(false);

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

  1732.     }

  1733. 

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

  1735.     {

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

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

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

  1739. #endif

  1740.         CARLA_ASSERT(fEffect != nullptr);

  1741. 

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

  1743.     }

  1744. 

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

  1746.     {

  1747. #if 0

  1748.         // Cockos VST extensions

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

  1750.         {

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

  1752. 

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

  1754.                 return 0;

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

  1756.                 return 0;

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

  1758.                 return 0;

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

  1760.                 return 0;

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

  1762.                 return 0;

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

  1764.                 return 0;

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

  1766.                 return 0;

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

  1768.                 return 0;

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

  1770.                 return 0;

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

  1772.                 return 0;

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

  1774.                 return 0;

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

  1776.                 return 0;

  1777.         }

  1778. #endif

  1779. 

  1780.         intptr_t ret = 0;

  1781. 

  1782.         switch (opcode)

  1783.         {

  1784.         case audioMasterAutomate:

  1785.             if (! fEnabled)

  1786.                 break;

  1787. 

  1788.             // plugins should never do this:

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

  1790. 

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

  1792.                 break;

  1793. 

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

  1795.             {

  1796.                 // Called from GUI

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

  1798.             }

  1799.             else if (fIsProcessing)

  1800.             {

  1801.                 // Called from engine

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

  1803. 

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

  1805.                 {

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

  1807.                 }

  1808.                 else

  1809.                 {

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

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

  1812.                 }

  1813.             }

  1814.             else

  1815.             {

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

  1817.             }

  1818.             break;

  1819. 

  1820.         case audioMasterCurrentId:

  1821.             // TODO

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

  1823.             break;

  1824. 

  1825.         case audioMasterIdle:

  1826.             if (fGui.isVisible)

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

  1828.             break;

  1829. 

  1830. #if ! VST_FORCE_DEPRECATED

  1831.         case audioMasterPinConnected:

  1832.             // Deprecated in VST SDK 2.4

  1833.             // TODO

  1834.             break;

  1835. 

  1836.         case audioMasterWantMidi:

  1837.             // Deprecated in VST SDK 2.4

  1838.             fHints |= PLUGIN_WANTS_MIDI_INPUT;

  1839.             break;

  1840. #endif

  1841. 

  1842.         case audioMasterGetTime:

  1843. #ifdef VESTIGE_HEADER

  1844.             ret = getAddressFromPointer(&fTimeInfo);

  1845. #else

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

  1847. #endif

  1848.             break;

  1849. 

  1850.         case audioMasterProcessEvents:

  1851.             CARLA_ASSERT(fEnabled);

  1852.             CARLA_ASSERT(fIsProcessing);

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

  1854.             CARLA_ASSERT(ptr != nullptr);

  1855. 

  1856.             if (! fEnabled)

  1857.                 return 0;

  1858.             if (! fIsProcessing)

  1859.                 return 0;

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

  1861.                 return 0;

  1862.             if (ptr == nullptr)

  1863.                 return 0;

  1864.             if (! fIsProcessing)

  1865.             {

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

  1867.                 return 0;

  1868.             }

  1869. 

  1870.             if (fMidiEventCount >= MAX_MIDI_EVENTS*2)

  1871.                 return 0;

  1872. 

  1873. 

  1874.         {

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

  1876. 

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

  1878.             {

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

  1880.                     break;

  1881. 

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

  1883. 

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

  1885.                     continue;

  1886. 

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

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

  1889.                 {

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

  1891.                     {

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

  1893.                         break;

  1894.                     }

  1895.                 }

  1896.             }

  1897.         }

  1898. 

  1899.             ret = 1;

  1900.             break;

  1901. 

  1902. #if ! VST_FORCE_DEPRECATED

  1903.         case audioMasterSetTime:

  1904.             // Deprecated in VST SDK 2.4

  1905.             break;

  1906. 

  1907.         case audioMasterTempoAt:

  1908.             // Deprecated in VST SDK 2.4

  1909.             CARLA_ASSERT(fIsProcessing);

  1910.             ret = fTimeInfo.tempo * 10000;

  1911.             break;

  1912. 

  1913.         case audioMasterGetNumAutomatableParameters:

  1914.             // Deprecated in VST SDK 2.4

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

  1916.             break;

  1917. 

  1918.         case audioMasterGetParameterQuantization:

  1919.             // Deprecated in VST SDK 2.4

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

  1921.             break;

  1922. #endif

  1923. 

  1924. #if 0

  1925.         case audioMasterIOChanged:

  1926.             CARLA_ASSERT(fEnabled);

  1927. 

  1928.             // TESTING

  1929. 

  1930.             if (! fEnabled)

  1931.             {

  1932.                 ret = 1;

  1933.                 break;

  1934.             }

  1935. 

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

  1937.             {

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

  1939.                 return 0;

  1940.             }

  1941. 

  1942.             engineProcessLock();

  1943.             m_enabled = false;

  1944.             engineProcessUnlock();

  1945. 

  1946.             if (m_active)

  1947.             {

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

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

  1950.             }

  1951. 

  1952.             reload();

  1953. 

  1954.             if (m_active)

  1955.             {

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

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

  1958.             }

  1959. 

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

  1961. 

  1962.             ret = 1;

  1963.             break;

  1964. #endif

  1965. 

  1966.         case audioMasterNeedIdle:

  1967.             // Deprecated in VST SDK 2.4

  1968.             fNeedIdle = true;

  1969.             ret = 1;

  1970.             break;

  1971. 

  1972.         case audioMasterSizeWindow:

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

  1974.             {

  1975.                 CARLA_SAFE_ASSERT(fGui.isVisible);

  1976.                 if (fGui.isVisible)

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

  1978.                 ret = 1;

  1979.             }

  1980.             break;

  1981. 

  1982.         case audioMasterGetSampleRate:

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

  1984.             break;

  1985. 

  1986.         case audioMasterGetBlockSize:

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

  1988.             break;

  1989. 

  1990.         case audioMasterGetInputLatency:

  1991.             ret = 0;

  1992.             break;

  1993. 

  1994.         case audioMasterGetOutputLatency:

  1995.             ret = 0;

  1996.             break;

  1997. 

  1998. #if ! VST_FORCE_DEPRECATED

  1999.         case audioMasterGetPreviousPlug:

  2000.             // Deprecated in VST SDK 2.4

  2001.             // TODO

  2002.             break;

  2003. 

  2004.         case audioMasterGetNextPlug:

  2005.             // Deprecated in VST SDK 2.4

  2006.             // TODO

  2007.             break;

  2008. 

  2009.         case audioMasterWillReplaceOrAccumulate:

  2010.             // Deprecated in VST SDK 2.4

  2011.             ret = 1; // replace

  2012.             break;

  2013. #endif

  2014. 

  2015.         case audioMasterGetCurrentProcessLevel:

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

  2017.                 ret = kVstProcessLevelOffline;

  2018.             else if (fIsProcessing)

  2019.                 ret = kVstProcessLevelRealtime;

  2020.             else

  2021.                 ret = kVstProcessLevelUser;

  2022.             break;

  2023. 

  2024.         case audioMasterGetAutomationState:

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

  2026.             break;

  2027. 

  2028.         case audioMasterOfflineStart:

  2029.         case audioMasterOfflineRead:

  2030.         case audioMasterOfflineWrite:

  2031.         case audioMasterOfflineGetCurrentPass:

  2032.         case audioMasterOfflineGetCurrentMetaPass:

  2033.             // TODO

  2034.             break;

  2035. 

  2036. #if ! VST_FORCE_DEPRECATED

  2037.         case audioMasterSetOutputSampleRate:

  2038.             // Deprecated in VST SDK 2.4

  2039.             break;

  2040. 

  2041.         case audioMasterGetOutputSpeakerArrangement:

  2042.             // Deprecated in VST SDK 2.4

  2043.             // TODO

  2044.             break;

  2045. #endif

  2046. 

  2047.         case audioMasterVendorSpecific:

  2048.             // TODO - cockos extensions

  2049.             break;

  2050. 

  2051. #if ! VST_FORCE_DEPRECATED

  2052.         case audioMasterSetIcon:

  2053.             // Deprecated in VST SDK 2.4

  2054.             break;

  2055. #endif

  2056. 

  2057. #if ! VST_FORCE_DEPRECATED

  2058.         case audioMasterOpenWindow:

  2059.         case audioMasterCloseWindow:

  2060.             // Deprecated in VST SDK 2.4

  2061.             // TODO

  2062.             break;

  2063. #endif

  2064. 

  2065.         case audioMasterGetDirectory:

  2066.             // TODO

  2067.             break;

  2068. 

  2069.         case audioMasterUpdateDisplay:

  2070.             // Idle UI if visible

  2071.             if (fGui.isVisible)

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

  2073. 

  2074.             // Update current program

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

  2076.             {

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

  2078. 

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

  2080.                 {

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

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

  2083. 

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

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

  2086. 

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

  2088. 

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

  2090.                     {

  2091.                         kData->prog.current = current;

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

  2093.                     }

  2094.                 }

  2095.             }

  2096. 

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

  2098.             ret = 1;

  2099.             break;

  2100. 

  2101.         case audioMasterBeginEdit:

  2102.         case audioMasterEndEdit:

  2103.             // TODO

  2104.             break;

  2105. 

  2106.         case audioMasterOpenFileSelector:

  2107.         case audioMasterCloseFileSelector:

  2108.             // TODO

  2109.             break;

  2110. 

  2111. #if ! VST_FORCE_DEPRECATED

  2112.         case audioMasterEditFile:

  2113.             // Deprecated in VST SDK 2.4

  2114.             // TODO

  2115.             break;

  2116. 

  2117.         case audioMasterGetChunkFile:

  2118.             // Deprecated in VST SDK 2.4

  2119.             // TODO

  2120.             break;

  2121. 

  2122.         case audioMasterGetInputSpeakerArrangement:

  2123.             // Deprecated in VST SDK 2.4

  2124.             // TODO

  2125.             break;

  2126. #endif

  2127. 

  2128.         default:

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

  2130.             break;

  2131.         }

  2132. 

  2133.         return ret;

  2134.     }

  2135. 

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

  2137. 

  2138. public:

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

  2140.     {

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

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

  2143.         CARLA_ASSERT(filename != nullptr);

  2144. 

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

  2146.         // first checks

  2147. 

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

  2149.         {

  2150.             return false;

  2151.         }

  2152. 

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

  2154.         {

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

  2156.             return false;

  2157.         }

  2158. 

  2159.         if (filename == nullptr)

  2160.         {

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

  2162.             return false;

  2163.         }

  2164. 

  2165.         // ---------------------------------------------------------------

  2166.         // open DLL

  2167. 

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

  2169.         {

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

  2171.             return false;

  2172.         }

  2173. 

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

  2175.         // get DLL main entry

  2176. 

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

  2178. 

  2179.         if (vstFn == nullptr)

  2180.         {

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

  2182. 

  2183.             if (vstFn == nullptr)

  2184.             {

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

  2186.                 return false;

  2187.             }

  2188.         }

  2189. 

  2190.         // ---------------------------------------------------------------

  2191.         // initialize plugin (part 1)

  2192. 

  2193.         sLastVstPlugin = this;

  2194.         fEffect = vstFn(carla_vst_audioMasterCallback);

  2195.         sLastVstPlugin = nullptr;

  2196. 

  2197.         if (fEffect == nullptr)

  2198.         {

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

  2200.             return false;

  2201.         }

  2202. 

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

  2204.         {

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

  2206.             return false;

  2207.         }

  2208. 

  2209. #ifdef VESTIGE_HEADER

  2210.         fEffect->ptr1 = this;

  2211. #else

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

  2213. #endif

  2214. 

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

  2216. 

  2217.         // ---------------------------------------------------------------

  2218.         // get info

  2219. 

  2220.         if (name != nullptr)

  2221.         {

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

  2223.         }

  2224.         else

  2225.         {

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

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

  2228. 

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

  2230.             {

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

  2232.             }

  2233.             else

  2234.             {

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

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

  2237.             }

  2238.         }

  2239. 

  2240.         fFilename = filename;

  2241. 

  2242.         // ---------------------------------------------------------------

  2243.         // register client

  2244. 

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

  2246. 

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

  2248.         {

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

  2250.             return false;

  2251.         }

  2252. 

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

  2254.         // initialize plugin (part 2)

  2255. 

  2256. #if ! VST_FORCE_DEPRECATED

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

  2258. #endif

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

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

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

  2262. 

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

  2264.             fHints |= PLUGIN_USES_OLD_VSTSDK;

  2265. 

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

  2267.             fHints |= PLUGIN_HAS_COCKOS_EXTENSIONS;

  2268. 

  2269.         // ---------------------------------------------------------------

  2270.         // gui stuff

  2271. 

  2272.         if (fEffect->flags & effFlagsHasEditor)

  2273.         {

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

  2275. 

  2276. #if defined(Q_WS_X11)

  2277.             CarlaString uiBridgeBinary(engineOptions.bridge_vstX11);

  2278. #elif defined(CARLA_OS_MAC)

  2279.             CarlaString uiBridgeBinary(engineOptions.bridge_vstCocoa);

  2280. #elif defined(CARLA_OS_WIN)

  2281.             CarlaString uiBridgeBinary(engineOptions.bridge_vstHWND);

  2282. #else

  2283.             CarlaString uiBridgeBinary;

  2284. #endif

  2285. 

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

  2287.             {

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

  2289.                 fGui.isOsc = true;

  2290.             }

  2291.         }

  2292. 

  2293.         // ---------------------------------------------------------------

  2294.         // load plugin settings

  2295. 

  2296.         {

  2297.             // set default options

  2298.             fOptions = 0x0;

  2299. 

  2300.             fOptions |= PLUGIN_OPTION_MAP_PROGRAM_CHANGES;

  2301. 

  2302.             if (midiInCount() > 0)

  2303.                 fOptions |= PLUGIN_OPTION_FIXED_BUFFER;

  2304. 

  2305.             if (fEffect->flags & effFlagsProgramChunks)

  2306.                 fOptions |= PLUGIN_OPTION_USE_CHUNKS;

  2307. 

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

  2309.             {

  2310.                 fOptions |= PLUGIN_OPTION_SEND_CHANNEL_PRESSURE;

  2311.                 fOptions |= PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH;

  2312.                 fOptions |= PLUGIN_OPTION_SEND_PITCHBEND;

  2313.                 fOptions |= PLUGIN_OPTION_SEND_ALL_SOUND_OFF;

  2314.             }

  2315. 

  2316.             // load settings

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

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

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

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

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

  2322. 

  2323.             // ignore settings, we need this anyway

  2324.             if (midiInCount() > 0)

  2325.                 fOptions |= PLUGIN_OPTION_FIXED_BUFFER;

  2326.         }

  2327. 

  2328.         return true;

  2329.     }

  2330. 

  2331. private:

  2332.     int fUnique1;

  2333.     AEffect* fEffect;

  2334. 

  2335.     void*         fLastChunk;

  2336.     uint32_t      fMidiEventCount;

  2337.     VstMidiEvent  fMidiEvents[MAX_MIDI_EVENTS*2];

  2338.     VstTimeInfo_R fTimeInfo;

  2339. 

  2340.     struct FixedVstEvents {

  2341.         int32_t numEvents;

  2342.         intptr_t reserved;

  2343.         VstEvent* data[MAX_MIDI_EVENTS*2];

  2344. 

  2345.         FixedVstEvents()

  2346.             : numEvents(0),

  2347.               reserved(0),

  2348.               data{nullptr} {}

  2349.     } fEvents;

  2350. 

  2351.     struct GuiInfo {

  2352.         bool isOsc;

  2353.         bool isVisible;

  2354.         int  lastWidth;

  2355.         int  lastHeight;

  2356. 

  2357.         GuiInfo()

  2358.             : isOsc(false),

  2359.               isVisible(false),

  2360.               lastWidth(0),

  2361.               lastHeight(0) {}

  2362.     } fGui;

  2363. 

  2364.     bool fIsProcessing;

  2365.     bool fNeedIdle;

  2366.     int  fUnique2;

  2367. 

  2368.     static VstPlugin* sLastVstPlugin;

  2369. 

  2370.     // -------------------------------------------------------------------

  2371. 

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

  2373.     {

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

  2375. 

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

  2377.             return 1;

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

  2379.             return 1;

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

  2381.             return 1;

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

  2383.             return 1;

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

  2385.             return 1;

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

  2387.             return 1;

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

  2389.             return 1;

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

  2391.             return -1;

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

  2393.             return -1;

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

  2395.             return 1;

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

  2397.             return 1;

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

  2399.             return -1;

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

  2401.             return -1;

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

  2403.             return -1;

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

  2405.             return 1;

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

  2407.             return -1;

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

  2409.             return -1;

  2410. 

  2411.         // unimplemented

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

  2413.         return 0;

  2414.     }

  2415. 

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

  2417.     {

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

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

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

  2421. #endif

  2422. 

  2423.         switch (opcode)

  2424.         {

  2425.         case audioMasterVersion:

  2426.             return kVstVersion;

  2427. 

  2428.         case audioMasterGetVendorString:

  2429.             CARLA_ASSERT(ptr != nullptr);

  2430. 

  2431.             if (ptr != nullptr)

  2432.             {

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

  2434.                 return 1;

  2435.             }

  2436.             else

  2437.             {

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

  2439.                 return 0;

  2440.             }

  2441. 

  2442.         case audioMasterGetProductString:

  2443.             CARLA_ASSERT(ptr != nullptr);

  2444. 

  2445.             if (ptr != nullptr)

  2446.             {

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

  2448.                 return 1;

  2449.             }

  2450.             else

  2451.             {

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

  2453.                 return 0;

  2454.             }

  2455. 

  2456.         case audioMasterGetVendorVersion:

  2457.             return 0x1000; // 1.0.0

  2458. 

  2459.         case audioMasterCanDo:

  2460.             CARLA_ASSERT(ptr != nullptr);

  2461. 

  2462.             if (ptr != nullptr)

  2463.             {

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

  2465.             }

  2466.             else

  2467.             {

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

  2469.                 return 0;

  2470.             }

  2471. 

  2472.         case audioMasterGetLanguage:

  2473.             return kVstLangEnglish;

  2474.         }

  2475. 

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

  2477.         VstPlugin* self = nullptr;

  2478. 

  2479.         if (effect != nullptr)

  2480.         {

  2481. #ifdef VESTIGE_HEADER

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

  2483.             {

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

  2485. #else

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

  2487.             {

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

  2489. #endif

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

  2491.                     self = nullptr;

  2492.             }

  2493. 

  2494.             if (self != nullptr)

  2495.             {

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

  2497.                     self->fEffect = effect;

  2498. 

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

  2500.                 {

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

  2502.                     self = nullptr;

  2503.                 }

  2504.             }

  2505.             else if (sLastVstPlugin != nullptr)

  2506.             {

  2507. #ifdef VESTIGE_HEADER

  2508.                 effect->ptr1 = sLastVstPlugin;

  2509. #else

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

  2511. #endif

  2512.                 self = sLastVstPlugin;

  2513.             }

  2514.         }

  2515. 

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

  2517.     }

  2518. 

  2519.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(VstPlugin)

  2520. };

  2521. 

  2522. VstPlugin* VstPlugin::sLastVstPlugin = nullptr;

  2523. 

  2524. CARLA_BACKEND_END_NAMESPACE

  2525. 

  2526. #else // WANT_VST

  2527. # warning Building without VST support

  2528. #endif

  2529. 

  2530. CARLA_BACKEND_START_NAMESPACE

  2531. 

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

  2533. {

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

  2535. 

  2536. #ifdef WANT_VST

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

  2538. 

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

  2540.     {

  2541.         delete plugin;

  2542.         return nullptr;

  2543.     }

  2544. 

  2545.     plugin->reload();

  2546. 

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

  2548.     {

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

  2550.         delete plugin;

  2551.         return nullptr;

  2552.     }

  2553. 

  2554.     return plugin;

  2555. #else

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

  2557.     return nullptr;

  2558. #endif

  2559. }

  2560. 

  2561. CARLA_BACKEND_END_NAMESPACE