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.
5334 Commits
16 Branches
310MB
Tree: 0f9dc2c9f1
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '0f9dc2c9f1'
${ noResults }
Carla/source/backend/plugin/CarlaPluginJuce.cpp

1490 lines
51KB
Raw Blame History 

  1. /*

  2.  * Carla Juce Plugin

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

  4.  *

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

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

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

  8.  * the License, or any later version.

  9.  *

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

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

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

  13.  * GNU General Public License for more details.

  14.  *

  15.  * For a full copy of the GNU General Public License see the doc/GPL.txt file.

  16.  */

  17. 

  18. #include "CarlaPluginInternal.hpp"

  19. #include "CarlaEngine.hpp"

  20. 

  21. #if defined(USING_JUCE)

  22. 

  23. #include "CarlaBackendUtils.hpp"

  24. #include "CarlaMathUtils.hpp"

  25. #include "CarlaScopeUtils.hpp"

  26. 

  27. #if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))

  28. # pragma GCC diagnostic push

  29. # pragma GCC diagnostic ignored "-Wcast-qual"

  30. # pragma GCC diagnostic ignored "-Wconversion"

  31. # pragma GCC diagnostic ignored "-Wdouble-promotion"

  32. # pragma GCC diagnostic ignored "-Weffc++"

  33. # pragma GCC diagnostic ignored "-Wfloat-equal"

  34. # pragma GCC diagnostic ignored "-Woverloaded-virtual"

  35. # pragma GCC diagnostic ignored "-Wsign-conversion"

  36. # pragma GCC diagnostic ignored "-Wundef"

  37. # pragma GCC diagnostic ignored "-Wzero-as-null-pointer-constant"

  38. # if __GNUC__ > 7

  39. #  pragma GCC diagnostic ignored "-Wclass-memaccess"

  40. # endif

  41. #endif

  42. 

  43. #include "AppConfig.h"

  44. #include "juce_audio_processors/juce_audio_processors.h"

  45. #include "juce_gui_basics/juce_gui_basics.h"

  46. 

  47. #if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))

  48. # pragma GCC diagnostic pop

  49. #endif

  50. 

  51. #include "JucePluginWindow.hpp"

  52. 

  53. CARLA_BACKEND_START_NAMESPACE

  54. 

  55. // -------------------------------------------------------------------------------------------------------------------

  56. // Fallback data

  57. 

  58. static const ExternalMidiNote kExternalMidiNoteFallback = { -1, 0, 0 };

  59. 

  60. // -------------------------------------------------------------------------------------------------------------------

  61. 

  62. class CarlaPluginJuce : public CarlaPlugin,

  63.                         private juce::AudioPlayHead,

  64.                         private juce::AudioProcessorListener

  65. {

  66. public:

  67.     CarlaPluginJuce(CarlaEngine* const engine, const uint id)

  68.         : CarlaPlugin(engine, id),

  69.           fDesc(),

  70.           fInstance(nullptr),

  71.           fFormatManager(),

  72.           fAudioBuffer(),

  73.           fMidiBuffer(),

  74.           fPosInfo(),

  75.           fChunk(),

  76.           fFormatName(),

  77.           fWindow()

  78.     {

  79.         carla_debug("CarlaPluginJuce::CarlaPluginJuce(%p, %i)", engine, id);

  80. 

  81.         fMidiBuffer.ensureSize(2048);

  82.         fMidiBuffer.clear();

  83.         fPosInfo.resetToDefault();

  84.     }

  85. 

  86.     ~CarlaPluginJuce() override

  87.     {

  88.         carla_debug("CarlaPluginJuce::~CarlaPluginJuce()");

  89. 

  90.         // close UI

  91.         if (pData->hints & PLUGIN_HAS_CUSTOM_UI)

  92.             showCustomUI(false);

  93. 

  94.         pData->singleMutex.lock();

  95.         pData->masterMutex.lock();

  96. 

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

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

  99. 

  100.         if (pData->active)

  101.         {

  102.             deactivate();

  103.             pData->active = false;

  104.         }

  105. 

  106.         if (fInstance != nullptr)

  107.         {

  108.             delete fInstance;

  109.             fInstance = nullptr;

  110.         }

  111. 

  112.         clearBuffers();

  113.     }

  114. 

  115.     // -------------------------------------------------------------------

  116.     // Information (base)

  117. 

  118.     PluginType getType() const noexcept override

  119.     {

  120.         return getPluginTypeFromString(fDesc.pluginFormatName.toRawUTF8());

  121.     }

  122. 

  123.     PluginCategory getCategory() const noexcept override

  124.     {

  125.         if (fDesc.isInstrument)

  126.             return PLUGIN_CATEGORY_SYNTH;

  127. 

  128.         return getPluginCategoryFromName(fDesc.category.isNotEmpty()

  129.                                          ? fDesc.category.toRawUTF8()

  130.                                          : fDesc.name.toRawUTF8());

  131.     }

  132. 

  133.     int64_t getUniqueId() const noexcept override

  134.     {

  135.         return fDesc.uid;

  136.     }

  137. 

  138.     // -------------------------------------------------------------------

  139.     // Information (count)

  140. 

  141.     // nothing

  142. 

  143.     // -------------------------------------------------------------------

  144.     // Information (current data)

  145. 

  146.     std::size_t getChunkData(void** const dataPtr) noexcept override

  147.     {

  148.         CARLA_SAFE_ASSERT_RETURN(pData->options & PLUGIN_OPTION_USE_CHUNKS, 0);

  149.         CARLA_SAFE_ASSERT_RETURN(fInstance != nullptr, 0);

  150.         CARLA_SAFE_ASSERT_RETURN(dataPtr != nullptr, 0);

  151. 

  152.         *dataPtr = nullptr;

  153. 

  154.         try {

  155.             fChunk.reset();

  156.             fInstance->getStateInformation(fChunk);

  157.         } CARLA_SAFE_EXCEPTION_RETURN("CarlaPluginJuce::getChunkData", 0);

  158. 

  159.         if (const std::size_t size = fChunk.getSize())

  160.         {

  161.             *dataPtr = fChunk.getData();

  162.             return size;

  163.         }

  164. 

  165.         return 0;

  166.     }

  167. 

  168.     // -------------------------------------------------------------------

  169.     // Information (per-plugin data)

  170. 

  171.     uint getOptionsAvailable() const noexcept override

  172.     {

  173.         CARLA_SAFE_ASSERT_RETURN(fInstance != nullptr, 0x0);

  174. 

  175.         uint options = 0x0;

  176. 

  177.         options |= PLUGIN_OPTION_MAP_PROGRAM_CHANGES;

  178.         options |= PLUGIN_OPTION_USE_CHUNKS;

  179. 

  180.         if (fInstance->getNumPrograms() > 1)

  181.             options |= PLUGIN_OPTION_MAP_PROGRAM_CHANGES;

  182. 

  183.         if (fInstance->acceptsMidi())

  184.         {

  185.             options |= PLUGIN_OPTION_SEND_CONTROL_CHANGES;

  186.             options |= PLUGIN_OPTION_SEND_CHANNEL_PRESSURE;

  187.             options |= PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH;

  188.             options |= PLUGIN_OPTION_SEND_PITCHBEND;

  189.             options |= PLUGIN_OPTION_SEND_ALL_SOUND_OFF;

  190.             options |= PLUGIN_OPTION_SEND_PROGRAM_CHANGES;

  191.         }

  192. 

  193.         return options;

  194.     }

  195. 

  196.     float getParameterValue(const uint32_t parameterId) const noexcept override

  197.     {

  198.         CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count, 0.0f);

  199.         CARLA_SAFE_ASSERT_RETURN(fInstance != nullptr, 0.0f);

  200. 

  201.         return fInstance->getParameter(static_cast<int>(parameterId));

  202.     }

  203. 

  204.     bool getLabel(char* const strBuf) const noexcept override

  205.     {

  206.         if (fDesc.pluginFormatName == "AU" || fDesc.pluginFormatName == "AudioUnit")

  207.             std::strncpy(strBuf, fDesc.fileOrIdentifier.toRawUTF8(), STR_MAX);

  208.         else

  209.             std::strncpy(strBuf, fDesc.name.toRawUTF8(), STR_MAX);

  210. 

  211.         return true;

  212.     }

  213. 

  214.     bool getMaker(char* const strBuf) const noexcept override

  215.     {

  216.         std::strncpy(strBuf, fDesc.manufacturerName.toRawUTF8(), STR_MAX);

  217.         return true;

  218.     }

  219. 

  220.     bool getCopyright(char* const strBuf) const noexcept override

  221.     {

  222.         return getMaker(strBuf);

  223.     }

  224. 

  225.     bool getRealName(char* const strBuf) const noexcept override

  226.     {

  227.         std::strncpy(strBuf, fDesc.descriptiveName.toRawUTF8(), STR_MAX);

  228.         return true;

  229.     }

  230. 

  231.     bool getParameterName(const uint32_t parameterId, char* const strBuf) const noexcept override

  232.     {

  233.         CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count, false);

  234.         CARLA_SAFE_ASSERT_RETURN(fInstance != nullptr, false);

  235. 

  236.         std::strncpy(strBuf, fInstance->getParameterName(static_cast<int>(parameterId), STR_MAX).toRawUTF8(), STR_MAX);

  237.         return true;

  238.     }

  239. 

  240.     bool getParameterText(const uint32_t parameterId, char* const strBuf) noexcept override

  241.     {

  242.         CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count, false);

  243.         CARLA_SAFE_ASSERT_RETURN(fInstance != nullptr, false);

  244. 

  245.         std::strncpy(strBuf, fInstance->getParameterText(static_cast<int>(parameterId), STR_MAX).toRawUTF8(), STR_MAX);

  246.         return true;

  247.     }

  248. 

  249.     bool getParameterUnit(const uint32_t parameterId, char* const strBuf) const noexcept override

  250.     {

  251.         CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count, false);

  252.         CARLA_SAFE_ASSERT_RETURN(fInstance != nullptr, false);

  253. 

  254.         std::strncpy(strBuf, fInstance->getParameterLabel(static_cast<int>(parameterId)).toRawUTF8(), STR_MAX);

  255.         return true;

  256.     }

  257. 

  258.     // -------------------------------------------------------------------

  259.     // Set data (state)

  260. 

  261.     // nothing

  262. 

  263.     // -------------------------------------------------------------------

  264.     // Set data (internal stuff)

  265. 

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

  267.     {

  268.         CarlaPlugin::setName(newName);

  269. 

  270.         if (fWindow != nullptr)

  271.         {

  272.             juce::String uiName(pData->name);

  273.             uiName += " (GUI)";

  274.             fWindow->setName(uiName);

  275.         }

  276.     }

  277. 

  278.     // -------------------------------------------------------------------

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

  280. 

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

  282.     {

  283.         CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count,);

  284.         CARLA_SAFE_ASSERT_RETURN(fInstance != nullptr,);

  285. 

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

  287. 

  288.         try {

  289.             fInstance->setParameter(static_cast<int>(parameterId), value);

  290.         } CARLA_SAFE_EXCEPTION("setParameter");

  291. 

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

  293.     }

  294. 

  295.     void setParameterValueRT(const uint32_t parameterId, const float value, const bool sendCallbackLater) noexcept override

  296.     {

  297.         CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count,);

  298.         CARLA_SAFE_ASSERT_RETURN(fInstance != nullptr,);

  299. 

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

  301. 

  302.         try {

  303.             fInstance->setParameter(static_cast<int>(parameterId), value);

  304.         } CARLA_SAFE_EXCEPTION("setParameter(RT)");

  305. 

  306.         CarlaPlugin::setParameterValueRT(parameterId, fixedValue, sendCallbackLater);

  307.     }

  308. 

  309.     void setChunkData(const void* const data, const std::size_t dataSize) override

  310.     {

  311.         CARLA_SAFE_ASSERT_RETURN(pData->options & PLUGIN_OPTION_USE_CHUNKS,);

  312.         CARLA_SAFE_ASSERT_RETURN(fInstance != nullptr,);

  313.         CARLA_SAFE_ASSERT_RETURN(data != nullptr,);

  314.         CARLA_SAFE_ASSERT_RETURN(dataSize > 0,);

  315. 

  316.         if (isJuceSaveFormat(data, dataSize))

  317.         {

  318.             const ScopedSingleProcessLocker spl(this, true);

  319.             fInstance->setStateInformation(data, static_cast<int>(dataSize));

  320.         }

  321.         else

  322.         {

  323.             uint8_t* const dataCompat = (uint8_t*)std::malloc(dataSize + 160);

  324.             CARLA_SAFE_ASSERT_RETURN(dataCompat != nullptr,);

  325. 

  326.             carla_stdout("NOTE: Loading plugin state in Carla JUCE/VST2 compatibility mode");

  327.             std::memset(dataCompat, 0, 160);

  328.             std::memcpy(dataCompat+160, data, dataSize);

  329. 

  330.             int32_t* const set = (int32_t*)dataCompat;

  331. 

  332.             set[0]  = (int32_t)juce::ByteOrder::littleEndianInt("CcnK");

  333.             set[2]  = (int32_t)juce::ByteOrder::littleEndianInt("FBCh");

  334.             set[3]  = fxbSwap(1);

  335.             set[39] = fxbSwap(static_cast<int32_t>(dataSize));

  336. 

  337.             {

  338.                 const ScopedSingleProcessLocker spl(this, true);

  339.                 fInstance->setStateInformation(dataCompat, static_cast<int>(dataSize+160));

  340.             }

  341. 

  342.             std::free(dataCompat);

  343.         }

  344. 

  345.         pData->updateParameterValues(this, true, true, false);

  346.     }

  347. 

  348.     void setProgram(const int32_t index, const bool sendGui, const bool sendOsc, const bool sendCallback, const bool doingInit) noexcept override

  349.     {

  350.         CARLA_SAFE_ASSERT_RETURN(fInstance != nullptr,);

  351.         CARLA_SAFE_ASSERT_RETURN(index >= -1 && index < static_cast<int32_t>(pData->prog.count),);

  352. 

  353.         if (index >= 0)

  354.         {

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

  356. 

  357.             try {

  358.                 fInstance->setCurrentProgram(index);

  359.             } CARLA_SAFE_EXCEPTION("setCurrentProgram");

  360.         }

  361. 

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

  363.     }

  364. 

  365.     void setProgramRT(const uint32_t index, const bool sendCallbackLater) noexcept override

  366.     {

  367.         CARLA_SAFE_ASSERT_RETURN(fInstance != nullptr,);

  368.         CARLA_SAFE_ASSERT_RETURN(index < pData->prog.count,);

  369. 

  370.         try {

  371.             fInstance->setCurrentProgram(static_cast<int32_t>(index));

  372.         } CARLA_SAFE_EXCEPTION("setCurrentProgram");

  373. 

  374.         CarlaPlugin::setProgramRT(index, sendCallbackLater);

  375.     }

  376. 

  377.     // -------------------------------------------------------------------

  378.     // Set ui stuff

  379. 

  380.     void showCustomUI(const bool yesNo) override

  381.     {

  382.         CARLA_SAFE_ASSERT_RETURN(fInstance != nullptr,);

  383. 

  384.         if (yesNo)

  385.         {

  386.             if (fWindow == nullptr)

  387.             {

  388.                 juce::String uiName(pData->name);

  389.                 uiName += " (GUI)";

  390. 

  391.                 fWindow = new JucePluginWindow(pData->engine->getOptions().frontendWinId);

  392.                 fWindow->setName(uiName);

  393.             }

  394. 

  395.             if (juce::AudioProcessorEditor* const editor = fInstance->createEditorIfNeeded())

  396.                 fWindow->show(editor);

  397.         }

  398.         else

  399.         {

  400.             if (fWindow != nullptr)

  401.                 fWindow->hide();

  402. 

  403.             if (juce::AudioProcessorEditor* const editor = fInstance->getActiveEditor())

  404.                 delete editor;

  405. 

  406.             fWindow = nullptr;

  407.         }

  408.     }

  409. 

  410.     void uiIdle() override

  411.     {

  412.         if (fWindow != nullptr)

  413.         {

  414.             if (fWindow->wasClosedByUser())

  415.             {

  416.                 showCustomUI(false);

  417.                 pData->engine->callback(true, true,

  418.                                         ENGINE_CALLBACK_UI_STATE_CHANGED,

  419.                                         pData->id,

  420.                                         0,

  421.                                         0, 0, 0.0f, nullptr);

  422.             }

  423.         }

  424. 

  425.         CarlaPlugin::uiIdle();

  426.     }

  427. 

  428.     // -------------------------------------------------------------------

  429.     // Plugin state

  430. 

  431.     void reload() override

  432.     {

  433.         CARLA_SAFE_ASSERT_RETURN(pData->engine != nullptr,);

  434.         CARLA_SAFE_ASSERT_RETURN(fInstance != nullptr,);

  435.         carla_debug("CarlaPluginJuce::reload() - start");

  436. 

  437.         const EngineProcessMode processMode(pData->engine->getProccessMode());

  438. 

  439.         // Safely disable plugin for reload

  440.         const ScopedDisabler sd(this);

  441. 

  442.         if (pData->active)

  443.             deactivate();

  444. 

  445.         clearBuffers();

  446. 

  447.         fInstance->refreshParameterList();

  448. 

  449.         uint32_t aIns, aOuts, mIns, mOuts, params;

  450.         mIns = mOuts = 0;

  451. 

  452.         bool needsCtrlIn, needsCtrlOut;

  453.         needsCtrlIn = needsCtrlOut = false;

  454. 

  455.         aIns   = (fInstance->getTotalNumInputChannels() > 0)  ? static_cast<uint32_t>(fInstance->getTotalNumInputChannels())  : 0;

  456.         aOuts  = (fInstance->getTotalNumOutputChannels() > 0) ? static_cast<uint32_t>(fInstance->getTotalNumOutputChannels()) : 0;

  457.         params = (fInstance->getNumParameters() > 0)          ? static_cast<uint32_t>(fInstance->getNumParameters())          : 0;

  458. 

  459.         if (fInstance->acceptsMidi())

  460.         {

  461.             mIns = 1;

  462.             needsCtrlIn = true;

  463.         }

  464. 

  465.         if (fInstance->producesMidi())

  466.         {

  467.             mOuts = 1;

  468.             needsCtrlOut = true;

  469.         }

  470. 

  471.         if (aIns > 0)

  472.         {

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

  474.         }

  475. 

  476.         if (aOuts > 0)

  477.         {

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

  479.             needsCtrlIn = true;

  480.         }

  481. 

  482.         if (params > 0)

  483.         {

  484.             pData->param.createNew(params, false);

  485.             needsCtrlIn = true;

  486.         }

  487. 

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

  489.         CarlaString portName;

  490. 

  491.         // Audio Ins

  492.         for (uint32_t j=0; j < aIns; ++j)

  493.         {

  494.             portName.clear();

  495. 

  496.             if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  497.             {

  498.                 portName  = pData->name;

  499.                 portName += ":";

  500.             }

  501. 

  502.             if (aIns > 1)

  503.             {

  504.                 portName += "input_";

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

  506.             }

  507.             else

  508.                 portName += "input";

  509. 

  510.             portName.truncate(portNameSize);

  511. 

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

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

  514.         }

  515. 

  516.         // Audio Outs

  517.         for (uint32_t j=0; j < aOuts; ++j)

  518.         {

  519.             portName.clear();

  520. 

  521.             if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  522.             {

  523.                 portName  = pData->name;

  524.                 portName += ":";

  525.             }

  526. 

  527.             if (aOuts > 1)

  528.             {

  529.                 portName += "output_";

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

  531.             }

  532.             else

  533.                 portName += "output";

  534. 

  535.             portName.truncate(portNameSize);

  536. 

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

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

  539.         }

  540. 

  541.         for (uint32_t j=0; j < params; ++j)

  542.         {

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

  544.             pData->param.data[j].index  = static_cast<int32_t>(j);

  545.             pData->param.data[j].rindex = static_cast<int32_t>(j);

  546. 

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

  548. 

  549.             // TODO

  550.             //const int numSteps(fInstance->getParameterNumSteps(static_cast<int>(j)));

  551.             {

  552.                 min = 0.0f;

  553.                 max = 1.0f;

  554.                 step = 0.001f;

  555.                 stepSmall = 0.0001f;

  556.                 stepLarge = 0.1f;

  557.             }

  558. 

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

  560. #ifndef BUILD_BRIDGE

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

  562. #endif

  563. 

  564.             if (fInstance->isParameterAutomatable(static_cast<int>(j)))

  565.             {

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

  567. 

  568.                 if (fInstance->isMetaParameter(static_cast<int>(j)))

  569.                     pData->param.data[j].hints |= PARAMETER_CAN_BE_CV_CONTROLLED;

  570.             }

  571. 

  572.             // FIXME?

  573.             def = fInstance->getParameterDefaultValue(static_cast<int>(j));

  574. 

  575.             if (def < min)

  576.                 def = min;

  577.             else if (def > max)

  578.                 def = max;

  579. 

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

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

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

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

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

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

  586.         }

  587. 

  588.         if (needsCtrlIn)

  589.         {

  590.             portName.clear();

  591. 

  592.             if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  593.             {

  594.                 portName  = pData->name;

  595.                 portName += ":";

  596.             }

  597. 

  598.             portName += "events-in";

  599.             portName.truncate(portNameSize);

  600. 

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

  602. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  603.             pData->event.cvSourcePorts = pData->client->createCVSourcePorts();

  604. #endif

  605.         }

  606. 

  607.         if (needsCtrlOut)

  608.         {

  609.             portName.clear();

  610. 

  611.             if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  612.             {

  613.                 portName  = pData->name;

  614.                 portName += ":";

  615.             }

  616. 

  617.             portName += "events-out";

  618.             portName.truncate(portNameSize);

  619. 

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

  621.         }

  622. 

  623.         // plugin hints

  624.         pData->hints  = 0x0;

  625.         pData->hints |= PLUGIN_NEEDS_FIXED_BUFFERS;

  626. 

  627.         if (fDesc.isInstrument)

  628.             pData->hints |= PLUGIN_IS_SYNTH;

  629. 

  630.         if (fInstance->hasEditor())

  631.         {

  632.             pData->hints |= PLUGIN_HAS_CUSTOM_UI;

  633.             pData->hints |= PLUGIN_NEEDS_UI_MAIN_THREAD;

  634.         }

  635. 

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

  637.             pData->hints |= PLUGIN_CAN_DRYWET;

  638. 

  639.         if (aOuts > 0)

  640.             pData->hints |= PLUGIN_CAN_VOLUME;

  641. 

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

  643.             pData->hints |= PLUGIN_CAN_BALANCE;

  644. 

  645.         // extra plugin hints

  646.         pData->extraHints = 0x0;

  647. 

  648.         if (mIns > 0)

  649.             pData->extraHints |= PLUGIN_EXTRA_HINT_HAS_MIDI_IN;

  650. 

  651.         if (mOuts > 0)

  652.             pData->extraHints |= PLUGIN_EXTRA_HINT_HAS_MIDI_OUT;

  653. 

  654.         fInstance->setPlayConfigDetails(static_cast<int>(aIns), static_cast<int>(aOuts), pData->engine->getSampleRate(), static_cast<int>(pData->engine->getBufferSize()));

  655. 

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

  657.         reloadPrograms(true);

  658. 

  659.         if (pData->active)

  660.             activate();

  661. 

  662.         carla_debug("CarlaPluginJuce::reload() - end");

  663.     }

  664. 

  665.     void reloadPrograms(const bool doInit) override

  666.     {

  667.         carla_debug("CarlaPluginJuce::reloadPrograms(%s)", bool2str(doInit));

  668.         const uint32_t oldCount = pData->prog.count;

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

  670. 

  671.         // Delete old programs

  672.         pData->prog.clear();

  673. 

  674.         // Query new programs

  675.         const uint32_t newCount = (fInstance->getNumPrograms() > 0)

  676.                                 ? static_cast<uint32_t>(fInstance->getNumPrograms())

  677.                                 : 0;

  678. 

  679.         if (newCount > 0)

  680.         {

  681.             pData->prog.createNew(newCount);

  682. 

  683.             // Update names

  684.             for (uint32_t i=0; i < newCount; ++i)

  685.                 pData->prog.names[i] = carla_strdup(fInstance->getProgramName(static_cast<int>(i)).toRawUTF8());

  686.         }

  687. 

  688.         if (doInit)

  689.         {

  690.             if (newCount > 0)

  691.                 setProgram(0, false, false, false, true);

  692.         }

  693.         else

  694.         {

  695.             // Check if current program is invalid

  696.             bool programChanged = false;

  697. 

  698.             if (newCount == oldCount+1)

  699.             {

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

  701.                 pData->prog.current = static_cast<int32_t>(oldCount);

  702.                 programChanged = true;

  703.             }

  704.             else if (current < 0 && newCount > 0)

  705.             {

  706.                 // programs exist now, but not before

  707.                 pData->prog.current = 0;

  708.                 programChanged = true;

  709.             }

  710.             else if (current >= 0 && newCount == 0)

  711.             {

  712.                 // programs existed before, but not anymore

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

  714.                 programChanged = true;

  715.             }

  716.             else if (current >= static_cast<int32_t>(newCount))

  717.             {

  718.                 // current program > count

  719.                 pData->prog.current = 0;

  720.                 programChanged = true;

  721.             }

  722.             else

  723.             {

  724.                 // no change

  725.                 pData->prog.current = current;

  726.             }

  727. 

  728.             if (programChanged)

  729.             {

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

  731.             }

  732.             else

  733.             {

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

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

  736.                     fInstance->setCurrentProgram(pData->prog.current);

  737.             }

  738. 

  739.             pData->engine->callback(true, true, ENGINE_CALLBACK_RELOAD_PROGRAMS, pData->id, 0, 0, 0, 0.0f, nullptr);

  740.         }

  741.     }

  742. 

  743.     // -------------------------------------------------------------------

  744.     // Plugin processing

  745. 

  746.     void activate() noexcept override

  747.     {

  748.         CARLA_SAFE_ASSERT_RETURN(fInstance != nullptr,);

  749. 

  750.         try {

  751.             fInstance->prepareToPlay(pData->engine->getSampleRate(), static_cast<int>(pData->engine->getBufferSize()));

  752.         } catch(...) {}

  753.     }

  754. 

  755.     void deactivate() noexcept override

  756.     {

  757.         CARLA_SAFE_ASSERT_RETURN(fInstance != nullptr,);

  758. 

  759.         try {

  760.             fInstance->releaseResources();

  761.         } catch(...) {}

  762.     }

  763. 

  764.     void process(const float* const* const audioIn,

  765.                  float** const audioOut,

  766.                  const float* const* const cvIn,

  767.                  float**,

  768.                  const uint32_t frames) override

  769.     {

  770.         // --------------------------------------------------------------------------------------------------------

  771.         // Check if active

  772. 

  773.         if (! pData->active)

  774.         {

  775.             // disable any output sound

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

  777.                 carla_zeroFloats(audioOut[i], frames);

  778.             return;

  779.         }

  780. 

  781.         // --------------------------------------------------------------------------------------------------------

  782.         // Check if needs reset

  783. 

  784.         if (pData->needsReset)

  785.         {

  786.             fInstance->reset();

  787.             pData->needsReset = false;

  788.         }

  789. 

  790.         // --------------------------------------------------------------------------------------------------------

  791.         // Event Input

  792. 

  793.         fMidiBuffer.clear();

  794. 

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

  796.         {

  797.             // ----------------------------------------------------------------------------------------------------

  798.             // MIDI Input (External)

  799. 

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

  801.             {

  802.                 for (RtLinkedList<ExternalMidiNote>::Itenerator it = pData->extNotes.data.begin2(); it.valid(); it.next())

  803.                 {

  804.                     const ExternalMidiNote& note(it.getValue(kExternalMidiNoteFallback));

  805.                     CARLA_SAFE_ASSERT_CONTINUE(note.channel >= 0 && note.channel < MAX_MIDI_CHANNELS);

  806. 

  807.                     uint8_t midiEvent[3];

  808.                     midiEvent[0] = uint8_t((note.velo > 0 ? MIDI_STATUS_NOTE_ON : MIDI_STATUS_NOTE_OFF) | (note.channel & MIDI_CHANNEL_BIT));

  809.                     midiEvent[1] = note.note;

  810.                     midiEvent[2] = note.velo;

  811. 

  812.                     fMidiBuffer.addEvent(midiEvent, 3, 0);

  813.                 }

  814. 

  815.                 pData->extNotes.data.clear();

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

  817. 

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

  819. 

  820.             // ----------------------------------------------------------------------------------------------------

  821.             // Event Input (System)

  822. 

  823. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  824.             bool allNotesOffSent = false;

  825. 

  826.             if (cvIn != nullptr && pData->event.cvSourcePorts != nullptr)

  827.                 pData->event.cvSourcePorts->initPortBuffers(cvIn, frames, false, pData->event.portIn);

  828. #endif

  829. 

  830.             for (uint32_t i=0, numEvents=pData->event.portIn->getEventCount(); i < numEvents; ++i)

  831.             {

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

  833. 

  834.                 if (event.time >= frames)

  835.                     continue;

  836. 

  837.                 switch (event.type)

  838.                 {

  839.                 case kEngineEventTypeNull:

  840.                     break;

  841. 

  842.                 case kEngineEventTypeControl: {

  843.                     const EngineControlEvent& ctrlEvent(event.ctrl);

  844. 

  845.                     switch (ctrlEvent.type)

  846.                     {

  847.                     case kEngineControlEventTypeNull:

  848.                         break;

  849. 

  850.                     case kEngineControlEventTypeParameter: {

  851.                         float value;

  852. 

  853. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  854.                         // non-midi

  855.                         if (event.channel == kEngineEventNonMidiChannel)

  856.                         {

  857.                             const uint32_t k = ctrlEvent.param;

  858.                             CARLA_SAFE_ASSERT_CONTINUE(k < pData->param.count);

  859. 

  860.                             value = pData->param.getFinalUnnormalizedValue(k, ctrlEvent.value);

  861.                             setParameterValueRT(k, value, true);

  862.                             continue;

  863.                         }

  864. 

  865.                         // Control backend stuff

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

  867.                         {

  868.                             if (MIDI_IS_CONTROL_BREATH_CONTROLLER(ctrlEvent.param) && (pData->hints & PLUGIN_CAN_DRYWET) != 0)

  869.                             {

  870.                                 value = ctrlEvent.value;

  871.                                 setDryWetRT(value, true);

  872.                             }

  873. 

  874.                             if (MIDI_IS_CONTROL_CHANNEL_VOLUME(ctrlEvent.param) && (pData->hints & PLUGIN_CAN_VOLUME) != 0)

  875.                             {

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

  877.                                 setVolumeRT(value, true);

  878.                             }

  879. 

  880.                             if (MIDI_IS_CONTROL_BALANCE(ctrlEvent.param) && (pData->hints & PLUGIN_CAN_BALANCE) != 0)

  881.                             {

  882.                                 float left, right;

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

  884. 

  885.                                 if (value < 0.0f)

  886.                                 {

  887.                                     left  = -1.0f;

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

  889.                                 }

  890.                                 else if (value > 0.0f)

  891.                                 {

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

  893.                                     right = 1.0f;

  894.                                 }

  895.                                 else

  896.                                 {

  897.                                     left  = -1.0f;

  898.                                     right = 1.0f;

  899.                                 }

  900. 

  901.                                 setBalanceLeftRT(left, true);

  902.                                 setBalanceRightRT(right, true);

  903.                             }

  904.                         }

  905. #endif

  906.                         // Control plugin parameters

  907.                         uint32_t k;

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

  909.                         {

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

  911.                                 continue;

  912.                             if (pData->param.data[k].mappedControlIndex != ctrlEvent.param)

  913.                                 continue;

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

  915.                                 continue;

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

  917.                                 continue;

  918. 

  919.                             value = pData->param.getFinalUnnormalizedValue(k, ctrlEvent.value);

  920.                             setParameterValueRT(k, value, true);

  921.                         }

  922. 

  923.                         if ((pData->options & PLUGIN_OPTION_SEND_CONTROL_CHANGES) != 0 && ctrlEvent.param < MAX_MIDI_VALUE)

  924.                         {

  925.                             uint8_t midiData[3];

  926.                             midiData[0] = uint8_t(MIDI_STATUS_CONTROL_CHANGE | (event.channel & MIDI_CHANNEL_BIT));

  927.                             midiData[1] = uint8_t(ctrlEvent.param);

  928.                             midiData[2] = uint8_t(ctrlEvent.value*127.0f);

  929. 

  930.                             fMidiBuffer.addEvent(midiData, 3, static_cast<int>(event.time));

  931.                         }

  932. 

  933.                         break;

  934.                     } // case kEngineControlEventTypeParameter

  935. 

  936.                     case kEngineControlEventTypeMidiBank:

  937.                         if ((pData->options & PLUGIN_OPTION_SEND_PROGRAM_CHANGES) != 0)

  938.                         {

  939.                             uint8_t midiData[3];

  940.                             midiData[0] = uint8_t(MIDI_STATUS_CONTROL_CHANGE | (event.channel & MIDI_CHANNEL_BIT));

  941.                             midiData[1] = MIDI_CONTROL_BANK_SELECT;

  942.                             midiData[2] = 0;

  943.                             fMidiBuffer.addEvent(midiData, 3, static_cast<int>(event.time));

  944. 

  945.                             midiData[1] = MIDI_CONTROL_BANK_SELECT__LSB;

  946.                             midiData[2] = uint8_t(ctrlEvent.value*127.0f);

  947.                             fMidiBuffer.addEvent(midiData, 3, static_cast<int>(event.time));

  948.                         }

  949.                         break;

  950. 

  951.                     case kEngineControlEventTypeMidiProgram:

  952.                         if (event.channel == pData->ctrlChannel && (pData->options & PLUGIN_OPTION_MAP_PROGRAM_CHANGES) != 0)

  953.                         {

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

  955.                             {

  956.                                 setProgramRT(ctrlEvent.param, true);

  957.                             }

  958.                         }

  959.                         else if ((pData->options & PLUGIN_OPTION_SEND_PROGRAM_CHANGES) != 0)

  960.                         {

  961.                             uint8_t midiData[3];

  962.                             midiData[0] = uint8_t(MIDI_STATUS_PROGRAM_CHANGE | (event.channel & MIDI_CHANNEL_BIT));

  963.                             midiData[1] = uint8_t(ctrlEvent.value*127.0f);

  964.                             fMidiBuffer.addEvent(midiData, 2, static_cast<int>(event.time));

  965.                         }

  966.                         break;

  967. 

  968.                     case kEngineControlEventTypeAllSoundOff:

  969.                         if (pData->options & PLUGIN_OPTION_SEND_ALL_SOUND_OFF)

  970.                         {

  971.                             uint8_t midiData[3];

  972.                             midiData[0] = uint8_t(MIDI_STATUS_CONTROL_CHANGE | (event.channel & MIDI_CHANNEL_BIT));

  973.                             midiData[1] = MIDI_CONTROL_ALL_SOUND_OFF;

  974.                             midiData[2] = 0;

  975. 

  976.                             fMidiBuffer.addEvent(midiData, 3, static_cast<int>(event.time));

  977.                         }

  978.                         break;

  979. 

  980.                     case kEngineControlEventTypeAllNotesOff:

  981.                         if (pData->options & PLUGIN_OPTION_SEND_ALL_SOUND_OFF)

  982.                         {

  983. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  985.                             {

  986.                                 allNotesOffSent = true;

  987.                                 postponeRtAllNotesOff();

  988.                             }

  989. #endif

  990. 

  991.                             uint8_t midiData[3];

  992.                             midiData[0] = uint8_t(MIDI_STATUS_CONTROL_CHANGE | (event.channel & MIDI_CHANNEL_BIT));

  993.                             midiData[1] = MIDI_CONTROL_ALL_NOTES_OFF;

  994.                             midiData[2] = 0;

  995. 

  996.                             fMidiBuffer.addEvent(midiData, 3, static_cast<int>(event.time));

  997.                         }

  998.                         break;

  999.                     } // switch (ctrlEvent.type)

  1000.                     break;

  1001.                 } // case kEngineEventTypeControl

  1002. 

  1003.                 case kEngineEventTypeMidi: {

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

  1005. 

  1006.                     const uint8_t* const midiData(midiEvent.size > EngineMidiEvent::kDataSize ? midiEvent.dataExt : midiEvent.data);

  1007. 

  1008.                     uint8_t status = uint8_t(MIDI_GET_STATUS_FROM_DATA(midiData));

  1009. 

  1010.                     if (status == MIDI_STATUS_CHANNEL_PRESSURE && (pData->options & PLUGIN_OPTION_SEND_CHANNEL_PRESSURE) == 0)

  1011.                         continue;

  1012.                     if (status == MIDI_STATUS_CONTROL_CHANGE && (pData->options & PLUGIN_OPTION_SEND_CONTROL_CHANGES) == 0)

  1013.                         continue;

  1014.                     if (status == MIDI_STATUS_POLYPHONIC_AFTERTOUCH && (pData->options & PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH) == 0)

  1015.                         continue;

  1016.                     if (status == MIDI_STATUS_PITCH_WHEEL_CONTROL && (pData->options & PLUGIN_OPTION_SEND_PITCHBEND) == 0)

  1017.                         continue;

  1018. 

  1019.                     // Fix bad note-off

  1020.                     if (status == MIDI_STATUS_NOTE_ON && midiData[2] == 0)

  1021.                         status = MIDI_STATUS_NOTE_OFF;

  1022. 

  1023.                     // put back channel in data

  1024.                     uint8_t midiData2[midiEvent.size];

  1025.                     midiData2[0] = uint8_t(status | (event.channel & MIDI_CHANNEL_BIT));

  1026.                     std::memcpy(midiData2+1, midiData+1, static_cast<std::size_t>(midiEvent.size-1));

  1027. 

  1028.                     fMidiBuffer.addEvent(midiData2, midiEvent.size, static_cast<int>(event.time));

  1029. 

  1030.                     if (status == MIDI_STATUS_NOTE_ON)

  1031.                     {

  1032.                         pData->postponeRtEvent(kPluginPostRtEventNoteOn,

  1033.                                                true,

  1034.                                                event.channel,

  1035.                                                midiData[1],

  1036.                                                midiData[2],

  1037.                                                0.0f);

  1038.                     }

  1039.                     else if (status == MIDI_STATUS_NOTE_OFF)

  1040.                     {

  1041.                         pData->postponeRtEvent(kPluginPostRtEventNoteOff,

  1042.                                                true,

  1043.                                                event.channel,

  1044.                                                midiData[1],

  1045.                                                0, 0.0f);

  1046.                     }

  1047.                 } break;

  1048.                 } // switch (event.type)

  1049.             }

  1050. 

  1051.             pData->postRtEvents.trySplice();

  1052. 

  1053.         } // End of Event Input

  1054. 

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

  1056.         // Set TimeInfo

  1057. 

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

  1059. 

  1060.         fPosInfo.isPlaying = timeInfo.playing;

  1061. 

  1062.         if (timeInfo.bbt.valid)

  1063.         {

  1064.             CARLA_SAFE_ASSERT_INT(timeInfo.bbt.bar > 0, timeInfo.bbt.bar);

  1065.             CARLA_SAFE_ASSERT_INT(timeInfo.bbt.beat > 0, timeInfo.bbt.beat);

  1066. 

  1067.             const double ppqBar  = static_cast<double>(timeInfo.bbt.beatsPerBar) * (timeInfo.bbt.bar - 1);

  1068.             const double ppqBeat = static_cast<double>(timeInfo.bbt.beat - 1);

  1069.             const double ppqTick = timeInfo.bbt.tick / timeInfo.bbt.ticksPerBeat;

  1070. 

  1071.             fPosInfo.bpm = timeInfo.bbt.beatsPerMinute;

  1072. 

  1073.             fPosInfo.timeSigNumerator   = static_cast<int>(timeInfo.bbt.beatsPerBar);

  1074.             fPosInfo.timeSigDenominator = static_cast<int>(timeInfo.bbt.beatType);

  1075. 

  1076.             fPosInfo.timeInSamples = static_cast<int64_t>(timeInfo.frame);

  1077.             fPosInfo.timeInSeconds = static_cast<double>(fPosInfo.timeInSamples)/pData->engine->getSampleRate();

  1078. 

  1079.             fPosInfo.ppqPosition = ppqBar + ppqBeat + ppqTick;

  1080.             fPosInfo.ppqPositionOfLastBarStart = ppqBar;

  1081.         }

  1082. 

  1083.         // --------------------------------------------------------------------------------------------------------

  1084.         // Process

  1085. 

  1086.         processSingle(audioIn, audioOut, frames);

  1087. 

  1088.         // --------------------------------------------------------------------------------------------------------

  1089. 

  1090. #ifdef BUILD_BRIDGE_ALTERNATIVE_ARCH

  1091.         return;

  1092. 

  1093.         // unused

  1094.         (void)cvIn;

  1095. #endif

  1096.     }

  1097. 

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

  1099.     {

  1100.         CARLA_SAFE_ASSERT_RETURN(frames > 0, false);

  1101. 

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

  1103.         {

  1104.             CARLA_SAFE_ASSERT_RETURN(inBuffer != nullptr, false);

  1105.         }

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

  1107.         {

  1108.             CARLA_SAFE_ASSERT_RETURN(outBuffer != nullptr, false);

  1109.         }

  1110. 

  1111.         // --------------------------------------------------------------------------------------------------------

  1112.         // Try lock, silence otherwise

  1113. 

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

  1115.         {

  1116.             pData->singleMutex.lock();

  1117.         }

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

  1119.         {

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

  1121.                 carla_zeroFloats(outBuffer[i], frames);

  1122.             return false;

  1123.         }

  1124. 

  1125.         // --------------------------------------------------------------------------------------------------------

  1126.         // Set audio in buffers

  1127. 

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

  1129.             fAudioBuffer.copyFrom(static_cast<int>(i), 0, inBuffer[i], static_cast<int>(frames));

  1130. 

  1131.         // --------------------------------------------------------------------------------------------------------

  1132.         // Run plugin

  1133. 

  1134.         fInstance->processBlock(fAudioBuffer, fMidiBuffer);

  1135. 

  1136.         // --------------------------------------------------------------------------------------------------------

  1137.         // Set audio out buffers

  1138. 

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

  1140.             carla_copyFloats(outBuffer[i], fAudioBuffer.getReadPointer(static_cast<int>(i)), frames);

  1141. 

  1142.         // --------------------------------------------------------------------------------------------------------

  1143.         // Midi out

  1144. 

  1145.         if (! fMidiBuffer.isEmpty())

  1146.         {

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

  1148.             {

  1149.                 const uint8_t* midiEventData;

  1150.                 int midiEventSize, midiEventPosition;

  1151. 

  1152.                 for (juce::MidiBuffer::Iterator i(fMidiBuffer); i.getNextEvent(midiEventData, midiEventSize, midiEventPosition);)

  1153.                 {

  1154.                     CARLA_SAFE_ASSERT_BREAK(midiEventPosition >= 0 && midiEventPosition < static_cast<int>(frames));

  1155.                     CARLA_SAFE_ASSERT_BREAK(midiEventSize > 0);

  1156. 

  1157.                     if (! pData->event.portOut->writeMidiEvent(static_cast<uint32_t>(midiEventPosition), static_cast<uint8_t>(midiEventSize), midiEventData))

  1158.                         break;

  1159.                 }

  1160.             }

  1161. 

  1162.             fMidiBuffer.clear();

  1163.         }

  1164. 

  1165.         // --------------------------------------------------------------------------------------------------------

  1166. 

  1167.         pData->singleMutex.unlock();

  1168.         return true;

  1169.     }

  1170. 

  1171.     void bufferSizeChanged(const uint32_t newBufferSize) override

  1172.     {

  1173.         CARLA_ASSERT_INT(newBufferSize > 0, newBufferSize);

  1174.         carla_debug("CarlaPluginJuce::bufferSizeChanged(%i)", newBufferSize);

  1175. 

  1176.         fAudioBuffer.setSize(static_cast<int>(std::max<uint32_t>(pData->audioIn.count, pData->audioOut.count)), static_cast<int>(newBufferSize));

  1177. 

  1178.         if (pData->active)

  1179.         {

  1180.             deactivate();

  1181.             activate();

  1182.         }

  1183.     }

  1184. 

  1185.     void sampleRateChanged(const double newSampleRate) override

  1186.     {

  1187.         CARLA_ASSERT_INT(newSampleRate > 0.0, newSampleRate);

  1188.         carla_debug("CarlaPluginJuce::sampleRateChanged(%g)", newSampleRate);

  1189. 

  1190.         if (pData->active)

  1191.         {

  1192.             deactivate();

  1193.             activate();

  1194.         }

  1195.     }

  1196. 

  1197.     // -------------------------------------------------------------------

  1198.     // Plugin buffers

  1199. 

  1200.     // nothing

  1201. 

  1202.     // -------------------------------------------------------------------

  1203.     // Post-poned UI Stuff

  1204. 

  1205.     // nothing

  1206. 

  1207.     // -------------------------------------------------------------------

  1208. 

  1209.     void* getNativeHandle() const noexcept override

  1210.     {

  1211.         return (fInstance != nullptr) ? fInstance->getPlatformSpecificData() : nullptr;

  1212.     }

  1213. 

  1214.     // -------------------------------------------------------------------

  1215. 

  1216. protected:

  1217.     void audioProcessorParameterChanged(juce::AudioProcessor*, int index, float value) override

  1218.     {

  1219.         CARLA_SAFE_ASSERT_RETURN(index >= 0,);

  1220. 

  1221.         const uint32_t uindex(static_cast<uint32_t>(index));

  1222.         const float fixedValue(pData->param.getFixedValue(uindex, value));

  1223. 

  1224.         CarlaPlugin::setParameterValue(static_cast<uint32_t>(index), fixedValue, false, true, true);

  1225.     }

  1226. 

  1227.     void audioProcessorChanged(juce::AudioProcessor*) override

  1228.     {

  1229.         pData->engine->callback(true, true, ENGINE_CALLBACK_UPDATE, pData->id, 0, 0, 0, 0.0f, nullptr);

  1230.     }

  1231. 

  1232.     void audioProcessorParameterChangeGestureBegin(juce::AudioProcessor*, int index) override

  1233.     {

  1234.         CARLA_SAFE_ASSERT_RETURN(index >= 0,);

  1235. 

  1236.         pData->engine->touchPluginParameter(pData->id, static_cast<uint32_t>(index), true);

  1237.     }

  1238. 

  1239.     void audioProcessorParameterChangeGestureEnd(juce::AudioProcessor*, int index) override

  1240.     {

  1241.         CARLA_SAFE_ASSERT_RETURN(index >= 0,);

  1242. 

  1243.         pData->engine->touchPluginParameter(pData->id, static_cast<uint32_t>(index), false);

  1244.     }

  1245. 

  1246.     bool getCurrentPosition(CurrentPositionInfo& result) override

  1247.     {

  1248.         carla_copyStruct(result, fPosInfo);

  1249.         return true;

  1250.     }

  1251. 

  1252.     // -------------------------------------------------------------------

  1253. 

  1254. public:

  1255.     bool init(const char* const filename, const char* const name, const char* const label, const int64_t uniqueId, const uint options, const char* const format)

  1256.     {

  1257.         CARLA_SAFE_ASSERT_RETURN(pData->engine != nullptr, false);

  1258. 

  1259.         // ---------------------------------------------------------------

  1260.         // first checks

  1261. 

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

  1263.         {

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

  1265.             return false;

  1266.         }

  1267. 

  1268.         if (format == nullptr || format[0] == '\0')

  1269.         {

  1270.             pData->engine->setLastError("null format");

  1271.             return false;

  1272.         }

  1273. 

  1274.         // AU requires label

  1275.         if (std::strcmp(format, "AU") == 0)

  1276.         {

  1277.             if (label == nullptr || label[0] == '\0')

  1278.             {

  1279.                 pData->engine->setLastError("null label");

  1280.                 return false;

  1281.             }

  1282.         }

  1283. 

  1284.         juce::String fileOrIdentifier;

  1285. 

  1286.         if (std::strcmp(format, "AU") == 0)

  1287.         {

  1288.             fileOrIdentifier = label;

  1289.         }

  1290.         else

  1291.         {

  1292.             // VST2 and VST3 require filename

  1293.             if (filename == nullptr || filename[0] == '\0')

  1294.             {

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

  1296.                 return false;

  1297.             }

  1298. 

  1299.             juce::String jfilename(filename);

  1300. 

  1301. #ifdef CARLA_OS_WIN

  1302.             // Fix for wine usage

  1303.             if (juce::File("Z:\\usr\\").existsAsFolder() && filename[0] == '/')

  1304.             {

  1305.                 jfilename.replace("/", "\\");

  1306.                 jfilename = "Z:" + jfilename;

  1307.             }

  1308. #endif

  1309. 

  1310.             fileOrIdentifier = jfilename;

  1311. 

  1312.             if (label != nullptr && label[0] != '\0')

  1313.                 fDesc.name = label;

  1314.         }

  1315. 

  1316.         fFormatManager.addDefaultFormats();

  1317. 

  1318.         {

  1319.             juce::OwnedArray<juce::PluginDescription> pluginDescriptions;

  1320.             juce::KnownPluginList plist;

  1321.             for (int i = 0; i < fFormatManager.getNumFormats(); ++i)

  1322.                 plist.scanAndAddFile(fileOrIdentifier, true, pluginDescriptions, *fFormatManager.getFormat(i));

  1323. 

  1324.             if (pluginDescriptions.size() == 0)

  1325.             {

  1326.                 pData->engine->setLastError("Failed to get plugin description");

  1327.                 return false;

  1328.             }

  1329. 

  1330.             fDesc = *pluginDescriptions[0];

  1331.         }

  1332. 

  1333.         if (uniqueId != 0)

  1334.             fDesc.uid = static_cast<int>(uniqueId);

  1335. 

  1336.         juce::String error;

  1337.         fInstance = fFormatManager.createPluginInstance(fDesc,

  1338.                                                         pData->engine->getSampleRate(),

  1339.                                                         static_cast<int>(pData->engine->getBufferSize()),

  1340.                                                         error);

  1341. 

  1342.         if (fInstance == nullptr)

  1343.         {

  1344.             pData->engine->setLastError(error.toRawUTF8());

  1345.             return false;

  1346.         }

  1347. 

  1348.         fInstance->fillInPluginDescription(fDesc);

  1349.         fInstance->setPlayHead(this);

  1350.         fInstance->addListener(this);

  1351. 

  1352.         fFormatName = format;

  1353. 

  1354.         // ---------------------------------------------------------------

  1355.         // get info

  1356. 

  1357.         if (name != nullptr && name[0] != '\0')

  1358.             pData->name = pData->engine->getUniquePluginName(name);

  1359.         else

  1360.             pData->name = pData->engine->getUniquePluginName(fInstance->getName().toRawUTF8());

  1361. 

  1362.         if (filename != nullptr && filename[0] != '\0')

  1363.             pData->filename = carla_strdup(filename);

  1364. 

  1365.         // ---------------------------------------------------------------

  1366.         // register client

  1367. 

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

  1369. 

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

  1371.         {

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

  1373.             return false;

  1374.         }

  1375. 

  1376.         // ---------------------------------------------------------------

  1377.         // set options

  1378. 

  1379.         pData->options  = 0x0;

  1380.         pData->options |= PLUGIN_OPTION_FIXED_BUFFERS;

  1381.         pData->options |= PLUGIN_OPTION_USE_CHUNKS;

  1382. 

  1383.         if (fInstance->acceptsMidi())

  1384.         {

  1385.             if (isPluginOptionEnabled(options, PLUGIN_OPTION_SEND_CONTROL_CHANGES))

  1386.                 pData->options |= PLUGIN_OPTION_SEND_CONTROL_CHANGES;

  1387.             if (isPluginOptionEnabled(options, PLUGIN_OPTION_SEND_CHANNEL_PRESSURE))

  1388.                 pData->options |= PLUGIN_OPTION_SEND_CHANNEL_PRESSURE;

  1389.             if (isPluginOptionEnabled(options, PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH))

  1390.                 pData->options |= PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH;

  1391.             if (isPluginOptionEnabled(options, PLUGIN_OPTION_SEND_PITCHBEND))

  1392.                 pData->options |= PLUGIN_OPTION_SEND_PITCHBEND;

  1393.             if (isPluginOptionEnabled(options, PLUGIN_OPTION_SEND_ALL_SOUND_OFF))

  1394.                 pData->options |= PLUGIN_OPTION_SEND_ALL_SOUND_OFF;

  1395.             if (isPluginOptionEnabled(options, PLUGIN_OPTION_SEND_PROGRAM_CHANGES))

  1396.                 pData->options |= PLUGIN_OPTION_SEND_PROGRAM_CHANGES;

  1397.         }

  1398. 

  1399.         if (fInstance->getNumPrograms() > 1 && ((pData->options & PLUGIN_OPTION_SEND_PROGRAM_CHANGES) == 0))

  1400.         {

  1401.             if (isPluginOptionEnabled(options, PLUGIN_OPTION_MAP_PROGRAM_CHANGES))

  1402.                 pData->options |= PLUGIN_OPTION_MAP_PROGRAM_CHANGES;

  1403.         }

  1404. 

  1405.         return true;

  1406.     }

  1407. 

  1408. private:

  1409.     juce::PluginDescription    fDesc;

  1410.     juce::AudioPluginInstance* fInstance;

  1411.     juce::AudioPluginFormatManager fFormatManager;

  1412. 

  1413.     juce::AudioSampleBuffer fAudioBuffer;

  1414.     juce::MidiBuffer        fMidiBuffer;

  1415.     CurrentPositionInfo     fPosInfo;

  1416.     juce::MemoryBlock       fChunk;

  1417.     juce::String            fFormatName;

  1418. 

  1419.     CarlaScopedPointer<JucePluginWindow> fWindow;

  1420. 

  1421.     bool isJuceSaveFormat(const void* const data, const std::size_t dataSize)

  1422.     {

  1423.         if (fFormatName != "VST2")

  1424.             return true;

  1425.         if (dataSize < 160)

  1426.             return false;

  1427. 

  1428.         const int32_t* const set = (const int32_t*)data;

  1429. 

  1430.         if (! compareMagic(set[0], "CcnK"))

  1431.             return false;

  1432.         if (! compareMagic(set[2], "FBCh") && ! compareMagic(set[2], "FJuc"))

  1433.             return false;

  1434.         if (fxbSwap(set[3]) > 1)

  1435.             return false;

  1436. 

  1437.         const int32_t chunkSize = fxbSwap(set[39]);

  1438. 

  1439.         return static_cast<std::size_t>(chunkSize + 160) == dataSize;

  1440.     }

  1441. 

  1442.     static bool compareMagic(int32_t magic, const char* name) noexcept

  1443.     {

  1444.         return magic == (int32_t)juce::ByteOrder::littleEndianInt (name)

  1445.             || magic == (int32_t)juce::ByteOrder::bigEndianInt (name);

  1446.     }

  1447. 

  1448.     static int32_t fxbSwap(const int32_t x) noexcept

  1449.     {

  1450.         return (int32_t)juce::ByteOrder::swapIfLittleEndian ((uint32_t) x);

  1451.     }

  1452. 

  1453.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaPluginJuce)

  1454. };

  1455. 

  1456. CARLA_BACKEND_END_NAMESPACE

  1457. 

  1458. #endif // USING_JUCE

  1459. 

  1460. // -------------------------------------------------------------------------------------------------------------------

  1461. 

  1462. CARLA_BACKEND_START_NAMESPACE

  1463. 

  1464. CarlaPlugin* CarlaPlugin::newJuce(const Initializer& init, const char* const format)

  1465. {

  1466.     carla_debug("CarlaPlugin::newJuce({%p, \"%s\", \"%s\", \"%s\", " P_INT64 "}, %s)", init.engine, init.filename, init.name, init.label, init.uniqueId, format);

  1467. 

  1468. #ifdef USING_JUCE

  1469.     CarlaPluginJuce* const plugin(new CarlaPluginJuce(init.engine, init.id));

  1470. 

  1471.     if (! plugin->init(init.filename, init.name, init.label, init.uniqueId, init.options, format))

  1472.     {

  1473.         delete plugin;

  1474.         return nullptr;

  1475.     }

  1476. 

  1477.     return plugin;

  1478. #else

  1479.     init.engine->setLastError("Juce-based plugin not available");

  1480.     return nullptr;

  1481. 

  1482.     // unused

  1483.     (void)format;

  1484. #endif

  1485. }

  1486. 

  1487. CARLA_BACKEND_END_NAMESPACE

  1488. 

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