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

1457 lines
50KB
Raw Blame History 

  1. /*

  2.  * Carla Juce Plugin

  3.  * Copyright (C) 2013-2019 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. 

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

  27. # pragma GCC diagnostic push

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

  29. # pragma GCC diagnostic ignored "-Wconversion"

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

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

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

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

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

  35. # pragma GCC diagnostic ignored "-Wundef"

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

  37. # if __GNUC__ > 7

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

  39. # endif

  40. #endif

  41. 

  42. #include "AppConfig.h"

  43. #include "juce_audio_processors/juce_audio_processors.h"

  44. #include "juce_gui_basics/juce_gui_basics.h"

  45. 

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

  47. # pragma GCC diagnostic pop

  48. #endif

  49. 

  50. #include "JucePluginWindow.hpp"

  51. 

  52. namespace juce {

  53. extern bool juce_isRunningInWine();

  54. }

  55. 

  56. CARLA_BACKEND_START_NAMESPACE

  57. 

  58. // -------------------------------------------------------------------------------------------------------------------

  59. // Fallback data

  60. 

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

  62. 

  63. // -------------------------------------------------------------------------------------------------------------------

  64. 

  65. class CarlaPluginJuce : public CarlaPlugin,

  66.                         private juce::AudioPlayHead,

  67.                         private juce::AudioProcessorListener

  68. {

  69. public:

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

  71.         : CarlaPlugin(engine, id),

  72.           fDesc(),

  73.           fInstance(nullptr),

  74.           fFormatManager(),

  75.           fAudioBuffer(),

  76.           fMidiBuffer(),

  77.           fPosInfo(),

  78.           fChunk(),

  79.           fFormatName(),

  80.           fWindow()

  81.     {

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

  83. 

  84.         fMidiBuffer.ensureSize(2048);

  85.         fMidiBuffer.clear();

  86.         fPosInfo.resetToDefault();

  87.     }

  88. 

  89.     ~CarlaPluginJuce() override

  90.     {

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

  92. 

  93.         // close UI

  94.         if (pData->hints & PLUGIN_HAS_CUSTOM_UI)

  95.             showCustomUI(false);

  96. 

  97.         pData->singleMutex.lock();

  98.         pData->masterMutex.lock();

  99. 

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

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

  102. 

  103.         if (pData->active)

  104.         {

  105.             deactivate();

  106.             pData->active = false;

  107.         }

  108. 

  109.         if (fInstance != nullptr)

  110.         {

  111.             delete fInstance;

  112.             fInstance = nullptr;

  113.         }

  114. 

  115.         clearBuffers();

  116.     }

  117. 

  118.     // -------------------------------------------------------------------

  119.     // Information (base)

  120. 

  121.     PluginType getType() const noexcept override

  122.     {

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

  124.     }

  125. 

  126.     PluginCategory getCategory() const noexcept override

  127.     {

  128.         if (fDesc.isInstrument)

  129.             return PLUGIN_CATEGORY_SYNTH;

  130.         return getPluginCategoryFromName(fDesc.category.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.         fInstance->setParameter(static_cast<int>(parameterId), value);

  288. 

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

  290.     }

  291. 

  292.     void setParameterValueRT(const uint32_t parameterId, const float value) noexcept override

  293.     {

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

  295.         CARLA_SAFE_ASSERT_RETURN(fInstance != nullptr,);

  296. 

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

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

  299. 

  300.         CarlaPlugin::setParameterValueRT(parameterId, fixedValue);

  301.     }

  302. 

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

  304.     {

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

  306.         CARLA_SAFE_ASSERT_RETURN(fInstance != nullptr,);

  307.         CARLA_SAFE_ASSERT_RETURN(data != nullptr,);

  308.         CARLA_SAFE_ASSERT_RETURN(dataSize > 0,);

  309. 

  310.         if (isJuceSaveFormat(data, dataSize))

  311.         {

  312.             const ScopedSingleProcessLocker spl(this, true);

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

  314.         }

  315.         else

  316.         {

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

  318.             CARLA_SAFE_ASSERT_RETURN(dataCompat != nullptr,);

  319. 

  320.             carla_stdout("NOTE: Loading plugin state in Carla compatibiity mode");

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

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

  323. 

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

  325. 

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

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

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

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

  330. 

  331.             {

  332.                 const ScopedSingleProcessLocker spl(this, true);

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

  334.             }

  335. 

  336.             std::free(dataCompat);

  337.         }

  338. 

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

  340.     }

  341. 

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

  343.     {

  344.         CARLA_SAFE_ASSERT_RETURN(fInstance != nullptr,);

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

  346. 

  347.         if (index >= 0)

  348.         {

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

  350. 

  351.             try {

  352.                 fInstance->setCurrentProgram(index);

  353.             } CARLA_SAFE_EXCEPTION("setCurrentProgram");

  354.         }

  355. 

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

  357.     }

  358. 

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

  360.     {

  361.         CARLA_SAFE_ASSERT_RETURN(fInstance != nullptr,);

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

  363. 

  364.         try {

  365.             fInstance->setCurrentProgram(index);

  366.         } CARLA_SAFE_EXCEPTION("setCurrentProgram");

  367. 

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

  369.     }

  370. 

  371.     // -------------------------------------------------------------------

  372.     // Set ui stuff

  373. 

  374.     void showCustomUI(const bool yesNo) override

  375.     {

  376.         CARLA_SAFE_ASSERT_RETURN(fInstance != nullptr,);

  377. 

  378.         if (yesNo)

  379.         {

  380.             if (fWindow == nullptr)

  381.             {

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

  383.                 uiName += " (GUI)";

  384. 

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

  386.                 fWindow->setName(uiName);

  387.             }

  388. 

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

  390.                 fWindow->show(editor);

  391.         }

  392.         else

  393.         {

  394.             if (fWindow != nullptr)

  395.                 fWindow->hide();

  396. 

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

  398.                 delete editor;

  399. 

  400.             fWindow = nullptr;

  401.         }

  402.     }

  403. 

  404.     void uiIdle() override

  405.     {

  406.         if (fWindow != nullptr)

  407.         {

  408.             if (fWindow->wasClosedByUser())

  409.             {

  410.                 showCustomUI(false);

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

  412.                                         ENGINE_CALLBACK_UI_STATE_CHANGED,

  413.                                         pData->id,

  414.                                         0,

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

  416.             }

  417.         }

  418. 

  419.         CarlaPlugin::uiIdle();

  420.     }

  421. 

  422.     // -------------------------------------------------------------------

  423.     // Plugin state

  424. 

  425.     void reload() override

  426.     {

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

  428.         CARLA_SAFE_ASSERT_RETURN(fInstance != nullptr,);

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

  430. 

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

  432. 

  433.         // Safely disable plugin for reload

  434.         const ScopedDisabler sd(this);

  435. 

  436.         if (pData->active)

  437.             deactivate();

  438. 

  439.         clearBuffers();

  440. 

  441.         fInstance->refreshParameterList();

  442. 

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

  444.         mIns = mOuts = 0;

  445. 

  446.         bool needsCtrlIn, needsCtrlOut;

  447.         needsCtrlIn = needsCtrlOut = false;

  448. 

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

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

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

  452. 

  453.         if (fInstance->acceptsMidi())

  454.         {

  455.             mIns = 1;

  456.             needsCtrlIn = true;

  457.         }

  458. 

  459.         if (fInstance->producesMidi())

  460.         {

  461.             mOuts = 1;

  462.             needsCtrlOut = true;

  463.         }

  464. 

  465.         if (aIns > 0)

  466.         {

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

  468.         }

  469. 

  470.         if (aOuts > 0)

  471.         {

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

  473.             needsCtrlIn = true;

  474.         }

  475. 

  476.         if (params > 0)

  477.         {

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

  479.             needsCtrlIn = true;

  480.         }

  481. 

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

  483.         CarlaString portName;

  484. 

  485.         // Audio Ins

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

  487.         {

  488.             portName.clear();

  489. 

  490.             if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  491.             {

  492.                 portName  = pData->name;

  493.                 portName += ":";

  494.             }

  495. 

  496.             if (aIns > 1)

  497.             {

  498.                 portName += "input_";

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

  500.             }

  501.             else

  502.                 portName += "input";

  503. 

  504.             portName.truncate(portNameSize);

  505. 

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

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

  508.         }

  509. 

  510.         // Audio Outs

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

  512.         {

  513.             portName.clear();

  514. 

  515.             if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  516.             {

  517.                 portName  = pData->name;

  518.                 portName += ":";

  519.             }

  520. 

  521.             if (aOuts > 1)

  522.             {

  523.                 portName += "output_";

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

  525.             }

  526.             else

  527.                 portName += "output";

  528. 

  529.             portName.truncate(portNameSize);

  530. 

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

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

  533.         }

  534. 

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

  536.         {

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

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

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

  540. 

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

  542. 

  543.             // TODO

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

  545.             {

  546.                 min = 0.0f;

  547.                 max = 1.0f;

  548.                 step = 0.001f;

  549.                 stepSmall = 0.0001f;

  550.                 stepLarge = 0.1f;

  551.             }

  552. 

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

  554. #ifndef BUILD_BRIDGE

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

  556. #endif

  557. 

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

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

  560. 

  561.             // FIXME?

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

  563. 

  564.             if (def < min)

  565.                 def = min;

  566.             else if (def > max)

  567.                 def = max;

  568. 

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

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

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

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

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

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

  575.         }

  576. 

  577.         if (needsCtrlIn)

  578.         {

  579.             portName.clear();

  580. 

  581.             if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  582.             {

  583.                 portName  = pData->name;

  584.                 portName += ":";

  585.             }

  586. 

  587.             portName += "events-in";

  588.             portName.truncate(portNameSize);

  589. 

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

  591.         }

  592. 

  593.         if (needsCtrlOut)

  594.         {

  595.             portName.clear();

  596. 

  597.             if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  598.             {

  599.                 portName  = pData->name;

  600.                 portName += ":";

  601.             }

  602. 

  603.             portName += "events-out";

  604.             portName.truncate(portNameSize);

  605. 

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

  607.         }

  608. 

  609.         // plugin hints

  610.         pData->hints  = 0x0;

  611.         pData->hints |= PLUGIN_NEEDS_FIXED_BUFFERS;

  612. 

  613.         if (fDesc.isInstrument)

  614.             pData->hints |= PLUGIN_IS_SYNTH;

  615. 

  616.         if (fInstance->hasEditor())

  617.         {

  618.             pData->hints |= PLUGIN_HAS_CUSTOM_UI;

  619.             pData->hints |= PLUGIN_NEEDS_UI_MAIN_THREAD;

  620.         }

  621. 

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

  623.             pData->hints |= PLUGIN_CAN_DRYWET;

  624. 

  625.         if (aOuts > 0)

  626.             pData->hints |= PLUGIN_CAN_VOLUME;

  627. 

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

  629.             pData->hints |= PLUGIN_CAN_BALANCE;

  630. 

  631.         // extra plugin hints

  632.         pData->extraHints = 0x0;

  633. 

  634.         if (mIns > 0)

  635.             pData->extraHints |= PLUGIN_EXTRA_HINT_HAS_MIDI_IN;

  636. 

  637.         if (mOuts > 0)

  638.             pData->extraHints |= PLUGIN_EXTRA_HINT_HAS_MIDI_OUT;

  639. 

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

  641. 

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

  643.         reloadPrograms(true);

  644. 

  645.         if (pData->active)

  646.             activate();

  647. 

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

  649.     }

  650. 

  651.     void reloadPrograms(const bool doInit) override

  652.     {

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

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

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

  656. 

  657.         // Delete old programs

  658.         pData->prog.clear();

  659. 

  660.         // Query new programs

  661.         uint32_t newCount = (fInstance->getNumPrograms() > 0) ? static_cast<uint32_t>(fInstance->getNumPrograms()) : 0;

  662. 

  663.         if (newCount > 0)

  664.         {

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

  666. 

  667.             // Update names

  668.             for (int i=0, count=fInstance->getNumPrograms(); i<count; ++i)

  669.                 pData->prog.names[i] = carla_strdup(fInstance->getProgramName(i).toRawUTF8());

  670.         }

  671. 

  672.         if (doInit)

  673.         {

  674.             if (newCount > 0)

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

  676.         }

  677.         else

  678.         {

  679.             // Check if current program is invalid

  680.             bool programChanged = false;

  681. 

  682.             if (newCount == oldCount+1)

  683.             {

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

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

  686.                 programChanged = true;

  687.             }

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

  689.             {

  690.                 // programs exist now, but not before

  691.                 pData->prog.current = 0;

  692.                 programChanged = true;

  693.             }

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

  695.             {

  696.                 // programs existed before, but not anymore

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

  698.                 programChanged = true;

  699.             }

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

  701.             {

  702.                 // current program > count

  703.                 pData->prog.current = 0;

  704.                 programChanged = true;

  705.             }

  706.             else

  707.             {

  708.                 // no change

  709.                 pData->prog.current = current;

  710.             }

  711. 

  712.             if (programChanged)

  713.             {

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

  715.             }

  716.             else

  717.             {

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

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

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

  721.             }

  722. 

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

  724.         }

  725.     }

  726. 

  727.     // -------------------------------------------------------------------

  728.     // Plugin processing

  729. 

  730.     void activate() noexcept override

  731.     {

  732.         CARLA_SAFE_ASSERT_RETURN(fInstance != nullptr,);

  733. 

  734.         try {

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

  736.         } catch(...) {}

  737.     }

  738. 

  739.     void deactivate() noexcept override

  740.     {

  741.         CARLA_SAFE_ASSERT_RETURN(fInstance != nullptr,);

  742. 

  743.         try {

  744.             fInstance->releaseResources();

  745.         } catch(...) {}

  746.     }

  747. 

  748.     void process(const float** const audioIn, float** const audioOut, const float** const, float** const, const uint32_t frames) override

  749.     {

  750.         // --------------------------------------------------------------------------------------------------------

  751.         // Check if active

  752. 

  753.         if (! pData->active)

  754.         {

  755.             // disable any output sound

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

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

  758.             return;

  759.         }

  760. 

  761.         // --------------------------------------------------------------------------------------------------------

  762.         // Check if needs reset

  763. 

  764.         if (pData->needsReset)

  765.         {

  766.             fInstance->reset();

  767.             pData->needsReset = false;

  768.         }

  769. 

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

  771.         // Event Input

  772. 

  773.         fMidiBuffer.clear();

  774. 

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

  776.         {

  777.             // ----------------------------------------------------------------------------------------------------

  778.             // MIDI Input (External)

  779. 

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

  781.             {

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

  783.                 {

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

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

  786. 

  787.                     uint8_t midiEvent[3];

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

  789.                     midiEvent[1] = note.note;

  790.                     midiEvent[2] = note.velo;

  791. 

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

  793.                 }

  794. 

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

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

  797. 

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

  799. 

  800.             // ----------------------------------------------------------------------------------------------------

  801.             // Event Input (System)

  802. 

  803. #ifndef BUILD_BRIDGE

  804.             bool allNotesOffSent = false;

  805. #endif

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

  807.             {

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

  809. 

  810.                 if (event.time >= frames)

  811.                     continue;

  812. 

  813.                 switch (event.type)

  814.                 {

  815.                 case kEngineEventTypeNull:

  816.                     break;

  817. 

  818.                 case kEngineEventTypeControl: {

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

  820. 

  821.                     switch (ctrlEvent.type)

  822.                     {

  823.                     case kEngineControlEventTypeNull:

  824.                         break;

  825. 

  826.                     case kEngineControlEventTypeParameter: {

  827. #ifndef BUILD_BRIDGE

  828.                         // Control backend stuff

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

  830.                         {

  831.                             float value;

  832. 

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

  834.                             {

  835.                                 value = ctrlEvent.value;

  836.                                 setDryWetRT(value, true);

  837.                             }

  838. 

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

  840.                             {

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

  842.                                 setVolumeRT(value, true);

  843.                             }

  844. 

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

  846.                             {

  847.                                 float left, right;

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

  849. 

  850.                                 if (value < 0.0f)

  851.                                 {

  852.                                     left  = -1.0f;

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

  854.                                 }

  855.                                 else if (value > 0.0f)

  856.                                 {

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

  858.                                     right = 1.0f;

  859.                                 }

  860.                                 else

  861.                                 {

  862.                                     left  = -1.0f;

  863.                                     right = 1.0f;

  864.                                 }

  865. 

  866.                                 setBalanceLeftRT(left, true);

  867.                                 setBalanceRightRT(right, true);

  868.                             }

  869.                         }

  870. #endif

  871.                         // Control plugin parameters

  872.                         uint32_t k;

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

  874.                         {

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

  876.                                 continue;

  877.                             if (pData->param.data[k].midiCC != ctrlEvent.param)

  878.                                 continue;

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

  880.                                 continue;

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

  882.                                 continue;

  883. 

  884.                             float value;

  885. 

  886.                             if (pData->param.data[k].hints & PARAMETER_IS_BOOLEAN)

  887.                             {

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

  889.                             }

  890.                             else

  891.                             {

  892.                                 if (pData->param.data[k].hints & PARAMETER_IS_LOGARITHMIC)

  893.                                     value = pData->param.ranges[k].getUnnormalizedLogValue(ctrlEvent.value);

  894.                                 else

  895.                                     value = pData->param.ranges[k].getUnnormalizedValue(ctrlEvent.value);

  896. 

  897.                                 if (pData->param.data[k].hints & PARAMETER_IS_INTEGER)

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

  899.                             }

  900. 

  901.                             setParameterValueRT(k, value, true);

  902.                         }

  903. 

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

  905.                         {

  906.                             uint8_t midiData[3];

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

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

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

  910. 

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

  912.                         }

  913. 

  914.                         break;

  915.                     } // case kEngineControlEventTypeParameter

  916. 

  917.                     case kEngineControlEventTypeMidiBank:

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

  919.                         {

  920.                             uint8_t midiData[3];

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

  922.                             midiData[1] = MIDI_CONTROL_BANK_SELECT; 

  923.                             midiData[2] = 0;

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

  925. 

  926.                             midiData[1] = MIDI_CONTROL_BANK_SELECT__LSB;

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

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

  929.                         }

  930.                         break;

  931. 

  932.                     case kEngineControlEventTypeMidiProgram:

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

  934.                         {

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

  936.                             {

  937.                                 setProgramRT(ctrlEvent.param, true);

  938.                             }

  939.                         }

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

  941.                         {

  942.                             uint8_t midiData[3];

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

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

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

  946.                         }

  947.                         break;

  948. 

  949.                     case kEngineControlEventTypeAllSoundOff:

  950.                         if (pData->options & PLUGIN_OPTION_SEND_ALL_SOUND_OFF)

  951.                         {

  952.                             uint8_t midiData[3];

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

  954.                             midiData[1] = MIDI_CONTROL_ALL_SOUND_OFF;

  955.                             midiData[2] = 0;

  956. 

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

  958.                         }

  959.                         break;

  960. 

  961.                     case kEngineControlEventTypeAllNotesOff:

  962.                         if (pData->options & PLUGIN_OPTION_SEND_ALL_SOUND_OFF)

  963.                         {

  964. #ifndef BUILD_BRIDGE

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

  966.                             {

  967.                                 allNotesOffSent = true;

  968.                                 postponeRtAllNotesOff();

  969.                             }

  970. #endif

  971. 

  972.                             uint8_t midiData[3];

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

  974.                             midiData[1] = MIDI_CONTROL_ALL_NOTES_OFF;

  975.                             midiData[2] = 0;

  976. 

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

  978.                         }

  979.                         break;

  980.                     } // switch (ctrlEvent.type)

  981.                     break;

  982.                 } // case kEngineEventTypeControl

  983. 

  984.                 case kEngineEventTypeMidi: {

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

  986. 

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

  988. 

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

  990. 

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

  992.                         continue;

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

  994.                         continue;

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

  996.                         continue;

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

  998.                         continue;

  999. 

  1000.                     // Fix bad note-off

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

  1002.                         status = MIDI_STATUS_NOTE_OFF;

  1003. 

  1004.                     // put back channel in data

  1005.                     uint8_t midiData2[midiEvent.size];

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

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

  1008. 

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

  1010. 

  1011.                     if (status == MIDI_STATUS_NOTE_ON)

  1012.                     {

  1013.                         pData->postponeRtEvent(kPluginPostRtEventNoteOn,

  1014.                                                true,

  1015.                                                event.channel,

  1016.                                                midiData[1],

  1017.                                                midiData[2],

  1018.                                                0.0f);

  1019.                     }

  1020.                     else if (status == MIDI_STATUS_NOTE_OFF)

  1021.                     {

  1022.                         pData->postponeRtEvent(kPluginPostRtEventNoteOff,

  1023.                                                true,

  1024.                                                event.channel,

  1025.                                                midiData[1],

  1026.                                                0, 0.0f);

  1027.                     }

  1028.                 } break;

  1029.                 } // switch (event.type)

  1030.             }

  1031. 

  1032.             pData->postRtEvents.trySplice();

  1033. 

  1034.         } // End of Event Input

  1035. 

  1036.         // --------------------------------------------------------------------------------------------------------

  1037.         // Set TimeInfo

  1038. 

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

  1040. 

  1041.         fPosInfo.isPlaying = timeInfo.playing;

  1042. 

  1043.         if (timeInfo.bbt.valid)

  1044.         {

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

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

  1047. 

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

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

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

  1051. 

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

  1053. 

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

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

  1056. 

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

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

  1059. 

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

  1061.             fPosInfo.ppqPositionOfLastBarStart = ppqBar;

  1062.         }

  1063. 

  1064.         // --------------------------------------------------------------------------------------------------------

  1065.         // Process

  1066. 

  1067.         processSingle(audioIn, audioOut, frames);

  1068.     }

  1069. 

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

  1071.     {

  1072.         CARLA_SAFE_ASSERT_RETURN(frames > 0, false);

  1073. 

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

  1075.         {

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

  1077.         }

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

  1079.         {

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

  1081.         }

  1082. 

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

  1084.         // Try lock, silence otherwise

  1085. 

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

  1087.         {

  1088.             pData->singleMutex.lock();

  1089.         }

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

  1091.         {

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

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

  1094.             return false;

  1095.         }

  1096. 

  1097.         // --------------------------------------------------------------------------------------------------------

  1098.         // Set audio in buffers

  1099. 

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

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

  1102. 

  1103.         // --------------------------------------------------------------------------------------------------------

  1104.         // Run plugin

  1105. 

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

  1107. 

  1108.         // --------------------------------------------------------------------------------------------------------

  1109.         // Set audio out buffers

  1110. 

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

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

  1113. 

  1114.         // --------------------------------------------------------------------------------------------------------

  1115.         // Midi out

  1116. 

  1117.         if (! fMidiBuffer.isEmpty())

  1118.         {

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

  1120.             {

  1121.                 const uint8_t* midiEventData;

  1122.                 int midiEventSize, midiEventPosition;

  1123. 

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

  1125.                 {

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

  1127.                     CARLA_SAFE_ASSERT_BREAK(midiEventSize > 0);

  1128. 

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

  1130.                         break;

  1131.                 }

  1132.             }

  1133. 

  1134.             fMidiBuffer.clear();

  1135.         }

  1136. 

  1137.         // --------------------------------------------------------------------------------------------------------

  1138. 

  1139.         pData->singleMutex.unlock();

  1140.         return true;

  1141.     }

  1142. 

  1143.     void bufferSizeChanged(const uint32_t newBufferSize) override

  1144.     {

  1145.         CARLA_ASSERT_INT(newBufferSize > 0, newBufferSize);

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

  1147. 

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

  1149. 

  1150.         if (pData->active)

  1151.         {

  1152.             deactivate();

  1153.             activate();

  1154.         }

  1155.     }

  1156. 

  1157.     void sampleRateChanged(const double newSampleRate) override

  1158.     {

  1159.         CARLA_ASSERT_INT(newSampleRate > 0.0, newSampleRate);

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

  1161. 

  1162.         if (pData->active)

  1163.         {

  1164.             deactivate();

  1165.             activate();

  1166.         }

  1167.     }

  1168. 

  1169.     // -------------------------------------------------------------------

  1170.     // Plugin buffers

  1171. 

  1172.     // nothing

  1173. 

  1174.     // -------------------------------------------------------------------

  1175.     // Post-poned UI Stuff

  1176. 

  1177.     // nothing

  1178. 

  1179.     // -------------------------------------------------------------------

  1180. 

  1181.     void* getNativeHandle() const noexcept override

  1182.     {

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

  1184.     }

  1185. 

  1186.     // -------------------------------------------------------------------

  1187. 

  1188. protected:

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

  1190.     {

  1191.         CARLA_SAFE_ASSERT_RETURN(index >= 0,);

  1192. 

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

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

  1195. 

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

  1197.     }

  1198. 

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

  1200.     {

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

  1202.     }

  1203. 

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

  1205.     {

  1206.         CARLA_SAFE_ASSERT_RETURN(index >= 0,);

  1207. 

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

  1209.     }

  1210. 

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

  1212.     {

  1213.         CARLA_SAFE_ASSERT_RETURN(index >= 0,);

  1214. 

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

  1216.     }

  1217. 

  1218.     bool getCurrentPosition(CurrentPositionInfo& result) override

  1219.     {

  1220.         carla_copyStruct(result, fPosInfo);

  1221.         return true;

  1222.     }

  1223. 

  1224.     // -------------------------------------------------------------------

  1225. 

  1226. public:

  1227.     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)

  1228.     {

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

  1230. 

  1231.         // ---------------------------------------------------------------

  1232.         // first checks

  1233. 

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

  1235.         {

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

  1237.             return false;

  1238.         }

  1239. 

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

  1241.         {

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

  1243.             return false;

  1244.         }

  1245. 

  1246.         // AU requires label

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

  1248.         {

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

  1250.             {

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

  1252.                 return false;

  1253.             }

  1254.         }

  1255. 

  1256.         juce::String fileOrIdentifier;

  1257. 

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

  1259.         {

  1260.             fileOrIdentifier = label;

  1261.         }

  1262.         else

  1263.         {

  1264.             // VST2 and VST3 require filename

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

  1266.             {

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

  1268.                 return false;

  1269.             }

  1270. 

  1271.             juce::String jfilename(filename);

  1272. 

  1273. #ifdef CARLA_OS_WIN

  1274.             // Fix for wine usage

  1275.             if (juce::juce_isRunningInWine() && filename[0] == '/')

  1276.             {

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

  1278.                 jfilename = "Z:" + jfilename;

  1279.             }

  1280. #endif

  1281. 

  1282.             fileOrIdentifier = jfilename;

  1283. 

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

  1285.                 fDesc.name = label;

  1286.         }

  1287. 

  1288.         fFormatManager.addDefaultFormats();

  1289. 

  1290.         {

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

  1292.             juce::KnownPluginList plist;

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

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

  1295. 

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

  1297.             {

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

  1299.                 return false;

  1300.             }

  1301. 

  1302.             fDesc = *pluginDescriptions[0];

  1303.         }

  1304. 

  1305.         if (uniqueId != 0)

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

  1307. 

  1308.         juce::String error;

  1309.         fInstance = fFormatManager.createPluginInstance(fDesc,

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

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

  1312.                                                         error);

  1313. 

  1314.         if (fInstance == nullptr)

  1315.         {

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

  1317.             return false;

  1318.         }

  1319. 

  1320.         fInstance->fillInPluginDescription(fDesc);

  1321.         fInstance->setPlayHead(this);

  1322.         fInstance->addListener(this);

  1323. 

  1324.         fFormatName = format;

  1325. 

  1326.         // ---------------------------------------------------------------

  1327.         // get info

  1328. 

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

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

  1331.         else

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

  1333. 

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

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

  1336. 

  1337.         // ---------------------------------------------------------------

  1338.         // register client

  1339. 

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

  1341. 

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

  1343.         {

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

  1345.             return false;

  1346.         }

  1347. 

  1348.         // ---------------------------------------------------------------

  1349.         // set default options

  1350. 

  1351.         pData->options  = 0x0;

  1352.         pData->options |= PLUGIN_OPTION_FIXED_BUFFERS;

  1353.         pData->options |= PLUGIN_OPTION_USE_CHUNKS;

  1354. 

  1355.         if (fInstance->acceptsMidi())

  1356.         {

  1357.             pData->options |= PLUGIN_OPTION_SEND_CHANNEL_PRESSURE;

  1358.             pData->options |= PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH;

  1359.             pData->options |= PLUGIN_OPTION_SEND_PITCHBEND;

  1360.             pData->options |= PLUGIN_OPTION_SEND_ALL_SOUND_OFF;

  1361. 

  1362.             if (options & PLUGIN_OPTION_SEND_CONTROL_CHANGES)

  1363.                 pData->options |= PLUGIN_OPTION_SEND_CONTROL_CHANGES;

  1364. 

  1365.             if (options & PLUGIN_OPTION_SEND_PROGRAM_CHANGES)

  1366.                 pData->options |= PLUGIN_OPTION_SEND_PROGRAM_CHANGES;   

  1367.         }

  1368. 

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

  1370.             pData->options |= PLUGIN_OPTION_MAP_PROGRAM_CHANGES;

  1371. 

  1372.         return true;

  1373.     }

  1374. 

  1375. private:

  1376.     juce::PluginDescription    fDesc;

  1377.     juce::AudioPluginInstance* fInstance;

  1378.     juce::AudioPluginFormatManager fFormatManager;

  1379. 

  1380.     juce::AudioSampleBuffer fAudioBuffer;

  1381.     juce::MidiBuffer        fMidiBuffer;

  1382.     CurrentPositionInfo     fPosInfo;

  1383.     juce::MemoryBlock       fChunk;

  1384.     juce::String            fFormatName;

  1385. 

  1386.     ScopedPointer<JucePluginWindow> fWindow;

  1387. 

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

  1389.     {

  1390.         if (fFormatName != "VST2")

  1391.             return true;

  1392.         if (dataSize < 160)

  1393.             return false;

  1394. 

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

  1396. 

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

  1398.             return false;

  1399.         if (! compareMagic(set[2], "FBCh"))

  1400.             return false;

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

  1402.             return false;

  1403. 

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

  1405. 

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

  1407.     }

  1408. 

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

  1410.     {

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

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

  1413.     }

  1414. 

  1415.     static int32_t fxbSwap(const int32_t x) noexcept

  1416.     {

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

  1418.     }

  1419. 

  1420.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaPluginJuce)

  1421. };

  1422. 

  1423. CARLA_BACKEND_END_NAMESPACE

  1424. 

  1425. #endif // USING_JUCE

  1426. 

  1427. // -------------------------------------------------------------------------------------------------------------------

  1428. 

  1429. CARLA_BACKEND_START_NAMESPACE

  1430. 

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

  1432. {

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

  1434. 

  1435. #ifdef USING_JUCE

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

  1437. 

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

  1439.     {

  1440.         delete plugin;

  1441.         return nullptr;

  1442.     }

  1443. 

  1444.     return plugin;

  1445. #else

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

  1447.     return nullptr;

  1448. 

  1449.     // unused

  1450.     (void)format;

  1451. #endif

  1452. }

  1453. 

  1454. CARLA_BACKEND_END_NAMESPACE

  1455. 

  1456. // -------------------------------------------------------------------------------------------------------------------