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

1471 lines
51KB
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. #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. namespace juce {

  54. extern bool juce_isRunningInWine();

  55. }

  56. 

  57. CARLA_BACKEND_START_NAMESPACE

  58. 

  59. // -------------------------------------------------------------------------------------------------------------------

  60. // Fallback data

  61. 

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

  63. 

  64. // -------------------------------------------------------------------------------------------------------------------

  65. 

  66. class CarlaPluginJuce : public CarlaPlugin,

  67.                         private juce::AudioPlayHead,

  68.                         private juce::AudioProcessorListener

  69. {

  70. public:

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

  72.         : CarlaPlugin(engine, id),

  73.           fDesc(),

  74.           fInstance(nullptr),

  75.           fFormatManager(),

  76.           fAudioBuffer(),

  77.           fMidiBuffer(),

  78.           fPosInfo(),

  79.           fChunk(),

  80.           fFormatName(),

  81.           fWindow()

  82.     {

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

  84. 

  85.         fMidiBuffer.ensureSize(2048);

  86.         fMidiBuffer.clear();

  87.         fPosInfo.resetToDefault();

  88.     }

  89. 

  90.     ~CarlaPluginJuce() override

  91.     {

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

  93. 

  94.         // close UI

  95.         if (pData->hints & PLUGIN_HAS_CUSTOM_UI)

  96.             showCustomUI(false);

  97. 

  98.         pData->singleMutex.lock();

  99.         pData->masterMutex.lock();

  100. 

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

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

  103. 

  104.         if (pData->active)

  105.         {

  106.             deactivate();

  107.             pData->active = false;

  108.         }

  109. 

  110.         if (fInstance != nullptr)

  111.         {

  112.             delete fInstance;

  113.             fInstance = nullptr;

  114.         }

  115. 

  116.         clearBuffers();

  117.     }

  118. 

  119.     // -------------------------------------------------------------------

  120.     // Information (base)

  121. 

  122.     PluginType getType() const noexcept override

  123.     {

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

  125.     }

  126. 

  127.     PluginCategory getCategory() const noexcept override

  128.     {

  129.         if (fDesc.isInstrument)

  130.             return PLUGIN_CATEGORY_SYNTH;

  131.         return getPluginCategoryFromName(fDesc.category.toRawUTF8());

  132.     }

  133. 

  134.     int64_t getUniqueId() const noexcept override

  135.     {

  136.         return fDesc.uid;

  137.     }

  138. 

  139.     // -------------------------------------------------------------------

  140.     // Information (count)

  141. 

  142.     // nothing

  143. 

  144.     // -------------------------------------------------------------------

  145.     // Information (current data)

  146. 

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

  148.     {

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

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

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

  152. 

  153.         *dataPtr = nullptr;

  154. 

  155.         try {

  156.             fChunk.reset();

  157.             fInstance->getStateInformation(fChunk);

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

  159. 

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

  161.         {

  162.             *dataPtr = fChunk.getData();

  163.             return size;

  164.         }

  165. 

  166.         return 0;

  167.     }

  168. 

  169.     // -------------------------------------------------------------------

  170.     // Information (per-plugin data)

  171. 

  172.     uint getOptionsAvailable() const noexcept override

  173.     {

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

  175. 

  176.         uint options = 0x0;

  177. 

  178.         options |= PLUGIN_OPTION_MAP_PROGRAM_CHANGES;

  179.         options |= PLUGIN_OPTION_USE_CHUNKS;

  180. 

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

  182.             options |= PLUGIN_OPTION_MAP_PROGRAM_CHANGES;

  183. 

  184.         if (fInstance->acceptsMidi())

  185.         {

  186.             options |= PLUGIN_OPTION_SEND_CONTROL_CHANGES;

  187.             options |= PLUGIN_OPTION_SEND_CHANNEL_PRESSURE;

  188.             options |= PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH;

  189.             options |= PLUGIN_OPTION_SEND_PITCHBEND;

  190.             options |= PLUGIN_OPTION_SEND_ALL_SOUND_OFF;

  191.             options |= PLUGIN_OPTION_SEND_PROGRAM_CHANGES;

  192.         }

  193. 

  194.         return options;

  195.     }

  196. 

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

  198.     {

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

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

  201. 

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

  203.     }

  204. 

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

  206.     {

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

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

  209.         else

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

  211. 

  212.         return true;

  213.     }

  214. 

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

  216.     {

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

  218.         return true;

  219.     }

  220. 

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

  222.     {

  223.         return getMaker(strBuf);

  224.     }

  225. 

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

  227.     {

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

  229.         return true;

  230.     }

  231. 

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

  233.     {

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

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

  236. 

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

  238.         return true;

  239.     }

  240. 

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

  242.     {

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

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

  245. 

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

  247.         return true;

  248.     }

  249. 

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

  251.     {

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

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

  254. 

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

  256.         return true;

  257.     }

  258. 

  259.     // -------------------------------------------------------------------

  260.     // Set data (state)

  261. 

  262.     // nothing

  263. 

  264.     // -------------------------------------------------------------------

  265.     // Set data (internal stuff)

  266. 

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

  268.     {

  269.         CarlaPlugin::setName(newName);

  270. 

  271.         if (fWindow != nullptr)

  272.         {

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

  274.             uiName += " (GUI)";

  275.             fWindow->setName(uiName);

  276.         }

  277.     }

  278. 

  279.     // -------------------------------------------------------------------

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

  281. 

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

  283.     {

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

  285.         CARLA_SAFE_ASSERT_RETURN(fInstance != nullptr,);

  286. 

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

  288. 

  289.         try {

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

  291.         } CARLA_SAFE_EXCEPTION("setParameter");

  292. 

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

  294.     }

  295. 

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

  297.     {

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

  299.         CARLA_SAFE_ASSERT_RETURN(fInstance != nullptr,);

  300. 

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

  302. 

  303.         try {

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

  305.         } CARLA_SAFE_EXCEPTION("setParameter");

  306. 

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

  308.     }

  309. 

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

  311.     {

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

  313.         CARLA_SAFE_ASSERT_RETURN(fInstance != nullptr,);

  314.         CARLA_SAFE_ASSERT_RETURN(data != nullptr,);

  315.         CARLA_SAFE_ASSERT_RETURN(dataSize > 0,);

  316. 

  317.         if (isJuceSaveFormat(data, dataSize))

  318.         {

  319.             const ScopedSingleProcessLocker spl(this, true);

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

  321.         }

  322.         else

  323.         {

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

  325.             CARLA_SAFE_ASSERT_RETURN(dataCompat != nullptr,);

  326. 

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

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

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

  330. 

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

  332. 

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

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

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

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

  337. 

  338.             {

  339.                 const ScopedSingleProcessLocker spl(this, true);

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

  341.             }

  342. 

  343.             std::free(dataCompat);

  344.         }

  345. 

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

  347.     }

  348. 

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

  350.     {

  351.         CARLA_SAFE_ASSERT_RETURN(fInstance != nullptr,);

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

  353. 

  354.         if (index >= 0)

  355.         {

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

  357. 

  358.             try {

  359.                 fInstance->setCurrentProgram(index);

  360.             } CARLA_SAFE_EXCEPTION("setCurrentProgram");

  361.         }

  362. 

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

  364.     }

  365. 

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

  367.     {

  368.         CARLA_SAFE_ASSERT_RETURN(fInstance != nullptr,);

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

  370. 

  371.         try {

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

  373.         } CARLA_SAFE_EXCEPTION("setCurrentProgram");

  374. 

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

  376.     }

  377. 

  378.     // -------------------------------------------------------------------

  379.     // Set ui stuff

  380. 

  381.     void showCustomUI(const bool yesNo) override

  382.     {

  383.         CARLA_SAFE_ASSERT_RETURN(fInstance != nullptr,);

  384. 

  385.         if (yesNo)

  386.         {

  387.             if (fWindow == nullptr)

  388.             {

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

  390.                 uiName += " (GUI)";

  391. 

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

  393.                 fWindow->setName(uiName);

  394.             }

  395. 

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

  397.                 fWindow->show(editor);

  398.         }

  399.         else

  400.         {

  401.             if (fWindow != nullptr)

  402.                 fWindow->hide();

  403. 

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

  405.                 delete editor;

  406. 

  407.             fWindow = nullptr;

  408.         }

  409.     }

  410. 

  411.     void uiIdle() override

  412.     {

  413.         if (fWindow != nullptr)

  414.         {

  415.             if (fWindow->wasClosedByUser())

  416.             {

  417.                 showCustomUI(false);

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

  419.                                         ENGINE_CALLBACK_UI_STATE_CHANGED,

  420.                                         pData->id,

  421.                                         0,

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

  423.             }

  424.         }

  425. 

  426.         CarlaPlugin::uiIdle();

  427.     }

  428. 

  429.     // -------------------------------------------------------------------

  430.     // Plugin state

  431. 

  432.     void reload() override

  433.     {

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

  435.         CARLA_SAFE_ASSERT_RETURN(fInstance != nullptr,);

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

  437. 

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

  439. 

  440.         // Safely disable plugin for reload

  441.         const ScopedDisabler sd(this);

  442. 

  443.         if (pData->active)

  444.             deactivate();

  445. 

  446.         clearBuffers();

  447. 

  448.         fInstance->refreshParameterList();

  449. 

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

  451.         mIns = mOuts = 0;

  452. 

  453.         bool needsCtrlIn, needsCtrlOut;

  454.         needsCtrlIn = needsCtrlOut = false;

  455. 

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

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

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

  459. 

  460.         if (fInstance->acceptsMidi())

  461.         {

  462.             mIns = 1;

  463.             needsCtrlIn = true;

  464.         }

  465. 

  466.         if (fInstance->producesMidi())

  467.         {

  468.             mOuts = 1;

  469.             needsCtrlOut = true;

  470.         }

  471. 

  472.         if (aIns > 0)

  473.         {

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

  475.         }

  476. 

  477.         if (aOuts > 0)

  478.         {

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

  480.             needsCtrlIn = true;

  481.         }

  482. 

  483.         if (params > 0)

  484.         {

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

  486.             needsCtrlIn = true;

  487.         }

  488. 

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

  490.         CarlaString portName;

  491. 

  492.         // Audio Ins

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

  494.         {

  495.             portName.clear();

  496. 

  497.             if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  498.             {

  499.                 portName  = pData->name;

  500.                 portName += ":";

  501.             }

  502. 

  503.             if (aIns > 1)

  504.             {

  505.                 portName += "input_";

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

  507.             }

  508.             else

  509.                 portName += "input";

  510. 

  511.             portName.truncate(portNameSize);

  512. 

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

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

  515.         }

  516. 

  517.         // Audio Outs

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

  519.         {

  520.             portName.clear();

  521. 

  522.             if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  523.             {

  524.                 portName  = pData->name;

  525.                 portName += ":";

  526.             }

  527. 

  528.             if (aOuts > 1)

  529.             {

  530.                 portName += "output_";

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

  532.             }

  533.             else

  534.                 portName += "output";

  535. 

  536.             portName.truncate(portNameSize);

  537. 

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

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

  540.         }

  541. 

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

  543.         {

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

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

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

  547. 

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

  549. 

  550.             // TODO

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

  552.             {

  553.                 min = 0.0f;

  554.                 max = 1.0f;

  555.                 step = 0.001f;

  556.                 stepSmall = 0.0001f;

  557.                 stepLarge = 0.1f;

  558.             }

  559. 

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

  561. #ifndef BUILD_BRIDGE

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

  563. #endif

  564. 

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

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

  567. 

  568.             // FIXME?

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

  570. 

  571.             if (def < min)

  572.                 def = min;

  573.             else if (def > max)

  574.                 def = max;

  575. 

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

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

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

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

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

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

  582.         }

  583. 

  584.         if (needsCtrlIn)

  585.         {

  586.             portName.clear();

  587. 

  588.             if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  589.             {

  590.                 portName  = pData->name;

  591.                 portName += ":";

  592.             }

  593. 

  594.             portName += "events-in";

  595.             portName.truncate(portNameSize);

  596. 

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

  598.         }

  599. 

  600.         if (needsCtrlOut)

  601.         {

  602.             portName.clear();

  603. 

  604.             if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  605.             {

  606.                 portName  = pData->name;

  607.                 portName += ":";

  608.             }

  609. 

  610.             portName += "events-out";

  611.             portName.truncate(portNameSize);

  612. 

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

  614.         }

  615. 

  616.         // plugin hints

  617.         pData->hints  = 0x0;

  618.         pData->hints |= PLUGIN_NEEDS_FIXED_BUFFERS;

  619. 

  620.         if (fDesc.isInstrument)

  621.             pData->hints |= PLUGIN_IS_SYNTH;

  622. 

  623.         if (fInstance->hasEditor())

  624.         {

  625.             pData->hints |= PLUGIN_HAS_CUSTOM_UI;

  626.             pData->hints |= PLUGIN_NEEDS_UI_MAIN_THREAD;

  627.         }

  628. 

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

  630.             pData->hints |= PLUGIN_CAN_DRYWET;

  631. 

  632.         if (aOuts > 0)

  633.             pData->hints |= PLUGIN_CAN_VOLUME;

  634. 

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

  636.             pData->hints |= PLUGIN_CAN_BALANCE;

  637. 

  638.         // extra plugin hints

  639.         pData->extraHints = 0x0;

  640. 

  641.         if (mIns > 0)

  642.             pData->extraHints |= PLUGIN_EXTRA_HINT_HAS_MIDI_IN;

  643. 

  644.         if (mOuts > 0)

  645.             pData->extraHints |= PLUGIN_EXTRA_HINT_HAS_MIDI_OUT;

  646. 

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

  648. 

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

  650.         reloadPrograms(true);

  651. 

  652.         if (pData->active)

  653.             activate();

  654. 

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

  656.     }

  657. 

  658.     void reloadPrograms(const bool doInit) override

  659.     {

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

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

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

  663. 

  664.         // Delete old programs

  665.         pData->prog.clear();

  666. 

  667.         // Query new programs

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

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

  670.                                 : 0;

  671. 

  672.         if (newCount > 0)

  673.         {

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

  675. 

  676.             // Update names

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

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

  679.         }

  680. 

  681.         if (doInit)

  682.         {

  683.             if (newCount > 0)

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

  685.         }

  686.         else

  687.         {

  688.             // Check if current program is invalid

  689.             bool programChanged = false;

  690. 

  691.             if (newCount == oldCount+1)

  692.             {

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

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

  695.                 programChanged = true;

  696.             }

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

  698.             {

  699.                 // programs exist now, but not before

  700.                 pData->prog.current = 0;

  701.                 programChanged = true;

  702.             }

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

  704.             {

  705.                 // programs existed before, but not anymore

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

  707.                 programChanged = true;

  708.             }

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

  710.             {

  711.                 // current program > count

  712.                 pData->prog.current = 0;

  713.                 programChanged = true;

  714.             }

  715.             else

  716.             {

  717.                 // no change

  718.                 pData->prog.current = current;

  719.             }

  720. 

  721.             if (programChanged)

  722.             {

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

  724.             }

  725.             else

  726.             {

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

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

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

  730.             }

  731. 

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

  733.         }

  734.     }

  735. 

  736.     // -------------------------------------------------------------------

  737.     // Plugin processing

  738. 

  739.     void activate() noexcept override

  740.     {

  741.         CARLA_SAFE_ASSERT_RETURN(fInstance != nullptr,);

  742. 

  743.         try {

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

  745.         } catch(...) {}

  746.     }

  747. 

  748.     void deactivate() noexcept override

  749.     {

  750.         CARLA_SAFE_ASSERT_RETURN(fInstance != nullptr,);

  751. 

  752.         try {

  753.             fInstance->releaseResources();

  754.         } catch(...) {}

  755.     }

  756. 

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

  758.     {

  759.         // --------------------------------------------------------------------------------------------------------

  760.         // Check if active

  761. 

  762.         if (! pData->active)

  763.         {

  764.             // disable any output sound

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

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

  767.             return;

  768.         }

  769. 

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

  771.         // Check if needs reset

  772. 

  773.         if (pData->needsReset)

  774.         {

  775.             fInstance->reset();

  776.             pData->needsReset = false;

  777.         }

  778. 

  779.         // --------------------------------------------------------------------------------------------------------

  780.         // Event Input

  781. 

  782.         fMidiBuffer.clear();

  783. 

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

  785.         {

  786.             // ----------------------------------------------------------------------------------------------------

  787.             // MIDI Input (External)

  788. 

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

  790.             {

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

  792.                 {

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

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

  795. 

  796.                     uint8_t midiEvent[3];

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

  798.                     midiEvent[1] = note.note;

  799.                     midiEvent[2] = note.velo;

  800. 

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

  802.                 }

  803. 

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

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

  806. 

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

  808. 

  809.             // ----------------------------------------------------------------------------------------------------

  810.             // Event Input (System)

  811. 

  812. #ifndef BUILD_BRIDGE

  813.             bool allNotesOffSent = false;

  814. #endif

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

  816.             {

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

  818. 

  819.                 if (event.time >= frames)

  820.                     continue;

  821. 

  822.                 switch (event.type)

  823.                 {

  824.                 case kEngineEventTypeNull:

  825.                     break;

  826. 

  827.                 case kEngineEventTypeControl: {

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

  829. 

  830.                     switch (ctrlEvent.type)

  831.                     {

  832.                     case kEngineControlEventTypeNull:

  833.                         break;

  834. 

  835.                     case kEngineControlEventTypeParameter: {

  836. #ifndef BUILD_BRIDGE

  837.                         // Control backend stuff

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

  839.                         {

  840.                             float value;

  841. 

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

  843.                             {

  844.                                 value = ctrlEvent.value;

  845.                                 setDryWetRT(value, true);

  846.                             }

  847. 

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

  849.                             {

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

  851.                                 setVolumeRT(value, true);

  852.                             }

  853. 

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

  855.                             {

  856.                                 float left, right;

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

  858. 

  859.                                 if (value < 0.0f)

  860.                                 {

  861.                                     left  = -1.0f;

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

  863.                                 }

  864.                                 else if (value > 0.0f)

  865.                                 {

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

  867.                                     right = 1.0f;

  868.                                 }

  869.                                 else

  870.                                 {

  871.                                     left  = -1.0f;

  872.                                     right = 1.0f;

  873.                                 }

  874. 

  875.                                 setBalanceLeftRT(left, true);

  876.                                 setBalanceRightRT(right, true);

  877.                             }

  878.                         }

  879. #endif

  880.                         // Control plugin parameters

  881.                         uint32_t k;

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

  883.                         {

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

  885.                                 continue;

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

  887.                                 continue;

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

  889.                                 continue;

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

  891.                                 continue;

  892. 

  893.                             float value;

  894. 

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

  896.                             {

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

  898.                             }

  899.                             else

  900.                             {

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

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

  903.                                 else

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

  905. 

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

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

  908.                             }

  909. 

  910.                             setParameterValueRT(k, value, true);

  911.                         }

  912. 

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

  914.                         {

  915.                             uint8_t midiData[3];

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

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

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

  919. 

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

  921.                         }

  922. 

  923.                         break;

  924.                     } // case kEngineControlEventTypeParameter

  925. 

  926.                     case kEngineControlEventTypeMidiBank:

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

  928.                         {

  929.                             uint8_t midiData[3];

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

  931.                             midiData[1] = MIDI_CONTROL_BANK_SELECT;

  932.                             midiData[2] = 0;

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

  934. 

  935.                             midiData[1] = MIDI_CONTROL_BANK_SELECT__LSB;

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

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

  938.                         }

  939.                         break;

  940. 

  941.                     case kEngineControlEventTypeMidiProgram:

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

  943.                         {

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

  945.                             {

  946.                                 setProgramRT(ctrlEvent.param, true);

  947.                             }

  948.                         }

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

  950.                         {

  951.                             uint8_t midiData[3];

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

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

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

  955.                         }

  956.                         break;

  957. 

  958.                     case kEngineControlEventTypeAllSoundOff:

  959.                         if (pData->options & PLUGIN_OPTION_SEND_ALL_SOUND_OFF)

  960.                         {

  961.                             uint8_t midiData[3];

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

  963.                             midiData[1] = MIDI_CONTROL_ALL_SOUND_OFF;

  964.                             midiData[2] = 0;

  965. 

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

  967.                         }

  968.                         break;

  969. 

  970.                     case kEngineControlEventTypeAllNotesOff:

  971.                         if (pData->options & PLUGIN_OPTION_SEND_ALL_SOUND_OFF)

  972.                         {

  973. #ifndef BUILD_BRIDGE

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

  975.                             {

  976.                                 allNotesOffSent = true;

  977.                                 postponeRtAllNotesOff();

  978.                             }

  979. #endif

  980. 

  981.                             uint8_t midiData[3];

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

  983.                             midiData[1] = MIDI_CONTROL_ALL_NOTES_OFF;

  984.                             midiData[2] = 0;

  985. 

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

  987.                         }

  988.                         break;

  989.                     } // switch (ctrlEvent.type)

  990.                     break;

  991.                 } // case kEngineEventTypeControl

  992. 

  993.                 case kEngineEventTypeMidi: {

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

  995. 

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

  997. 

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

  999. 

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

  1001.                         continue;

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

  1003.                         continue;

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

  1005.                         continue;

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

  1007.                         continue;

  1008. 

  1009.                     // Fix bad note-off

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

  1011.                         status = MIDI_STATUS_NOTE_OFF;

  1012. 

  1013.                     // put back channel in data

  1014.                     uint8_t midiData2[midiEvent.size];

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

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

  1017. 

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

  1019. 

  1020.                     if (status == MIDI_STATUS_NOTE_ON)

  1021.                     {

  1022.                         pData->postponeRtEvent(kPluginPostRtEventNoteOn,

  1023.                                                true,

  1024.                                                event.channel,

  1025.                                                midiData[1],

  1026.                                                midiData[2],

  1027.                                                0.0f);

  1028.                     }

  1029.                     else if (status == MIDI_STATUS_NOTE_OFF)

  1030.                     {

  1031.                         pData->postponeRtEvent(kPluginPostRtEventNoteOff,

  1032.                                                true,

  1033.                                                event.channel,

  1034.                                                midiData[1],

  1035.                                                0, 0.0f);

  1036.                     }

  1037.                 } break;

  1038.                 } // switch (event.type)

  1039.             }

  1040. 

  1041.             pData->postRtEvents.trySplice();

  1042. 

  1043.         } // End of Event Input

  1044. 

  1045.         // --------------------------------------------------------------------------------------------------------

  1046.         // Set TimeInfo

  1047. 

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

  1049. 

  1050.         fPosInfo.isPlaying = timeInfo.playing;

  1051. 

  1052.         if (timeInfo.bbt.valid)

  1053.         {

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

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

  1056. 

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

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

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

  1060. 

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

  1062. 

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

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

  1065. 

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

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

  1068. 

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

  1070.             fPosInfo.ppqPositionOfLastBarStart = ppqBar;

  1071.         }

  1072. 

  1073.         // --------------------------------------------------------------------------------------------------------

  1074.         // Process

  1075. 

  1076.         processSingle(audioIn, audioOut, frames);

  1077.     }

  1078. 

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

  1080.     {

  1081.         CARLA_SAFE_ASSERT_RETURN(frames > 0, false);

  1082. 

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

  1084.         {

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

  1086.         }

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

  1088.         {

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

  1090.         }

  1091. 

  1092.         // --------------------------------------------------------------------------------------------------------

  1093.         // Try lock, silence otherwise

  1094. 

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

  1096.         {

  1097.             pData->singleMutex.lock();

  1098.         }

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

  1100.         {

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

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

  1103.             return false;

  1104.         }

  1105. 

  1106.         // --------------------------------------------------------------------------------------------------------

  1107.         // Set audio in buffers

  1108. 

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

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

  1111. 

  1112.         // --------------------------------------------------------------------------------------------------------

  1113.         // Run plugin

  1114. 

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

  1116. 

  1117.         // --------------------------------------------------------------------------------------------------------

  1118.         // Set audio out buffers

  1119. 

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

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

  1122. 

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

  1124.         // Midi out

  1125. 

  1126.         if (! fMidiBuffer.isEmpty())

  1127.         {

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

  1129.             {

  1130.                 const uint8_t* midiEventData;

  1131.                 int midiEventSize, midiEventPosition;

  1132. 

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

  1134.                 {

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

  1136.                     CARLA_SAFE_ASSERT_BREAK(midiEventSize > 0);

  1137. 

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

  1139.                         break;

  1140.                 }

  1141.             }

  1142. 

  1143.             fMidiBuffer.clear();

  1144.         }

  1145. 

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

  1147. 

  1148.         pData->singleMutex.unlock();

  1149.         return true;

  1150.     }

  1151. 

  1152.     void bufferSizeChanged(const uint32_t newBufferSize) override

  1153.     {

  1154.         CARLA_ASSERT_INT(newBufferSize > 0, newBufferSize);

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

  1156. 

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

  1158. 

  1159.         if (pData->active)

  1160.         {

  1161.             deactivate();

  1162.             activate();

  1163.         }

  1164.     }

  1165. 

  1166.     void sampleRateChanged(const double newSampleRate) override

  1167.     {

  1168.         CARLA_ASSERT_INT(newSampleRate > 0.0, newSampleRate);

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

  1170. 

  1171.         if (pData->active)

  1172.         {

  1173.             deactivate();

  1174.             activate();

  1175.         }

  1176.     }

  1177. 

  1178.     // -------------------------------------------------------------------

  1179.     // Plugin buffers

  1180. 

  1181.     // nothing

  1182. 

  1183.     // -------------------------------------------------------------------

  1184.     // Post-poned UI Stuff

  1185. 

  1186.     // nothing

  1187. 

  1188.     // -------------------------------------------------------------------

  1189. 

  1190.     void* getNativeHandle() const noexcept override

  1191.     {

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

  1193.     }

  1194. 

  1195.     // -------------------------------------------------------------------

  1196. 

  1197. protected:

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

  1199.     {

  1200.         CARLA_SAFE_ASSERT_RETURN(index >= 0,);

  1201. 

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

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

  1204. 

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

  1206.     }

  1207. 

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

  1209.     {

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

  1211.     }

  1212. 

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

  1214.     {

  1215.         CARLA_SAFE_ASSERT_RETURN(index >= 0,);

  1216. 

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

  1218.     }

  1219. 

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

  1221.     {

  1222.         CARLA_SAFE_ASSERT_RETURN(index >= 0,);

  1223. 

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

  1225.     }

  1226. 

  1227.     bool getCurrentPosition(CurrentPositionInfo& result) override

  1228.     {

  1229.         carla_copyStruct(result, fPosInfo);

  1230.         return true;

  1231.     }

  1232. 

  1233.     // -------------------------------------------------------------------

  1234. 

  1235. public:

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

  1237.     {

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

  1239. 

  1240.         // ---------------------------------------------------------------

  1241.         // first checks

  1242. 

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

  1244.         {

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

  1246.             return false;

  1247.         }

  1248. 

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

  1250.         {

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

  1252.             return false;

  1253.         }

  1254. 

  1255.         // AU requires label

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

  1257.         {

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

  1259.             {

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

  1261.                 return false;

  1262.             }

  1263.         }

  1264. 

  1265.         juce::String fileOrIdentifier;

  1266. 

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

  1268.         {

  1269.             fileOrIdentifier = label;

  1270.         }

  1271.         else

  1272.         {

  1273.             // VST2 and VST3 require filename

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

  1275.             {

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

  1277.                 return false;

  1278.             }

  1279. 

  1280.             juce::String jfilename(filename);

  1281. 

  1282. #ifdef CARLA_OS_WIN

  1283.             // Fix for wine usage

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

  1285.             {

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

  1287.                 jfilename = "Z:" + jfilename;

  1288.             }

  1289. #endif

  1290. 

  1291.             fileOrIdentifier = jfilename;

  1292. 

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

  1294.                 fDesc.name = label;

  1295.         }

  1296. 

  1297.         fFormatManager.addDefaultFormats();

  1298. 

  1299.         {

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

  1301.             juce::KnownPluginList plist;

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

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

  1304. 

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

  1306.             {

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

  1308.                 return false;

  1309.             }

  1310. 

  1311.             fDesc = *pluginDescriptions[0];

  1312.         }

  1313. 

  1314.         if (uniqueId != 0)

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

  1316. 

  1317.         juce::String error;

  1318.         fInstance = fFormatManager.createPluginInstance(fDesc,

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

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

  1321.                                                         error);

  1322. 

  1323.         if (fInstance == nullptr)

  1324.         {

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

  1326.             return false;

  1327.         }

  1328. 

  1329.         fInstance->fillInPluginDescription(fDesc);

  1330.         fInstance->setPlayHead(this);

  1331.         fInstance->addListener(this);

  1332. 

  1333.         fFormatName = format;

  1334. 

  1335.         // ---------------------------------------------------------------

  1336.         // get info

  1337. 

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

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

  1340.         else

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

  1342. 

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

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

  1345. 

  1346.         // ---------------------------------------------------------------

  1347.         // register client

  1348. 

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

  1350. 

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

  1352.         {

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

  1354.             return false;

  1355.         }

  1356. 

  1357.         // ---------------------------------------------------------------

  1358.         // set options

  1359. 

  1360.         pData->options  = 0x0;

  1361.         pData->options |= PLUGIN_OPTION_FIXED_BUFFERS;

  1362.         pData->options |= PLUGIN_OPTION_USE_CHUNKS;

  1363. 

  1364.         if (fInstance->acceptsMidi())

  1365.         {

  1366.             if (isPluginOptionEnabled(options, PLUGIN_OPTION_SEND_CONTROL_CHANGES))

  1367.                 pData->options |= PLUGIN_OPTION_SEND_CONTROL_CHANGES;

  1368.             if (isPluginOptionEnabled(options, PLUGIN_OPTION_SEND_CHANNEL_PRESSURE))

  1369.                 pData->options |= PLUGIN_OPTION_SEND_CHANNEL_PRESSURE;

  1370.             if (isPluginOptionEnabled(options, PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH))

  1371.                 pData->options |= PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH;

  1372.             if (isPluginOptionEnabled(options, PLUGIN_OPTION_SEND_PITCHBEND))

  1373.                 pData->options |= PLUGIN_OPTION_SEND_PITCHBEND;

  1374.             if (isPluginOptionEnabled(options, PLUGIN_OPTION_SEND_ALL_SOUND_OFF))

  1375.                 pData->options |= PLUGIN_OPTION_SEND_ALL_SOUND_OFF;

  1376.             if (isPluginOptionEnabled(options, PLUGIN_OPTION_SEND_PROGRAM_CHANGES))

  1377.                 pData->options |= PLUGIN_OPTION_SEND_PROGRAM_CHANGES;

  1378.         }

  1379. 

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

  1381.         {

  1382.             if (isPluginOptionEnabled(options, PLUGIN_OPTION_MAP_PROGRAM_CHANGES))

  1383.                 pData->options |= PLUGIN_OPTION_MAP_PROGRAM_CHANGES;

  1384.         }

  1385. 

  1386.         return true;

  1387.     }

  1388. 

  1389. private:

  1390.     juce::PluginDescription    fDesc;

  1391.     juce::AudioPluginInstance* fInstance;

  1392.     juce::AudioPluginFormatManager fFormatManager;

  1393. 

  1394.     juce::AudioSampleBuffer fAudioBuffer;

  1395.     juce::MidiBuffer        fMidiBuffer;

  1396.     CurrentPositionInfo     fPosInfo;

  1397.     juce::MemoryBlock       fChunk;

  1398.     juce::String            fFormatName;

  1399. 

  1400.     CarlaScopedPointer<JucePluginWindow> fWindow;

  1401. 

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

  1403.     {

  1404.         if (fFormatName != "VST2")

  1405.             return true;

  1406.         if (dataSize < 160)

  1407.             return false;

  1408. 

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

  1410. 

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

  1412.             return false;

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

  1414.             return false;

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

  1416.             return false;

  1417. 

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

  1419. 

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

  1421.     }

  1422. 

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

  1424.     {

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

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

  1427.     }

  1428. 

  1429.     static int32_t fxbSwap(const int32_t x) noexcept

  1430.     {

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

  1432.     }

  1433. 

  1434.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaPluginJuce)

  1435. };

  1436. 

  1437. CARLA_BACKEND_END_NAMESPACE

  1438. 

  1439. #endif // USING_JUCE

  1440. 

  1441. // -------------------------------------------------------------------------------------------------------------------

  1442. 

  1443. CARLA_BACKEND_START_NAMESPACE

  1444. 

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

  1446. {

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

  1448. 

  1449. #ifdef USING_JUCE

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

  1451. 

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

  1453.     {

  1454.         delete plugin;

  1455.         return nullptr;

  1456.     }

  1457. 

  1458.     return plugin;

  1459. #else

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

  1461.     return nullptr;

  1462. 

  1463.     // unused

  1464.     (void)format;

  1465. #endif

  1466. }

  1467. 

  1468. CARLA_BACKEND_END_NAMESPACE

  1469. 

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