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

1511 lines
52KB
Raw Blame History 

  1. /*

  2.  * Carla Juce Plugin

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

  4.  *

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

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

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

  8.  * the License, or any later version.

  9.  *

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

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

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

  13.  * GNU General Public License for more details.

  14.  *

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

  16.  */

  17. 

  18. #include "CarlaPluginInternal.hpp"

  19. #include "CarlaEngine.hpp"

  20. 

  21. #ifdef USING_JUCE

  22. 

  23. #include "CarlaBackendUtils.hpp"

  24. #include "CarlaMathUtils.hpp"

  25. #include "CarlaProcessUtils.hpp"

  26. #include "CarlaScopeUtils.hpp"

  27. 

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

  29. # pragma GCC diagnostic push

  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. #endif

  35. 

  36. #define JUCE_GUI_BASICS_INCLUDE_XHEADERS 1

  37. #include "AppConfig.h"

  38. #include "juce_audio_processors/juce_audio_processors.h"

  39. #include "juce_gui_basics/juce_gui_basics.h"

  40. 

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

  42. # pragma GCC diagnostic pop

  43. #endif

  44. 

  45. #include "JucePluginWindow.hpp"

  46. 

  47. CARLA_BACKEND_START_NAMESPACE

  48. 

  49. // -------------------------------------------------------------------------------------------------------------------

  50. // Fallback data

  51. 

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

  53. 

  54. // -------------------------------------------------------------------------------------------------------------------

  55. 

  56. class CarlaPluginJuce : public CarlaPlugin,

  57.                         private juce::AudioPlayHead,

  58.                         private juce::AudioProcessorListener

  59. {

  60. public:

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

  62.         : CarlaPlugin(engine, id),

  63.           fDesc(),

  64.           fFormatManager(),

  65.           fInstance(),

  66.           fAudioBuffer(),

  67.           fMidiBuffer(),

  68.           fPosInfo(),

  69.           fChunk(),

  70.           fFormatName(),

  71.           fWindow()

  72.     {

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

  74. 

  75.         fMidiBuffer.ensureSize(2048);

  76.         fMidiBuffer.clear();

  77.         fPosInfo.resetToDefault();

  78.     }

  79. 

  80.     ~CarlaPluginJuce() override

  81.     {

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

  83. 

  84.         // close UI

  85.         if (pData->hints & PLUGIN_HAS_CUSTOM_UI)

  86.             showCustomUI(false);

  87. 

  88.         pData->singleMutex.lock();

  89.         pData->masterMutex.lock();

  90. 

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

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

  93. 

  94.         if (pData->active)

  95.         {

  96.             deactivate();

  97.             pData->active = false;

  98.         }

  99. 

  100.         fInstance = nullptr;

  101.         clearBuffers();

  102.     }

  103. 

  104.     // -------------------------------------------------------------------

  105.     // Information (base)

  106. 

  107.     PluginType getType() const noexcept override

  108.     {

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

  110.     }

  111. 

  112.     PluginCategory getCategory() const noexcept override

  113.     {

  114.         if (fDesc.isInstrument)

  115.             return PLUGIN_CATEGORY_SYNTH;

  116. 

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

  118.                                          ? fDesc.category.toRawUTF8()

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

  120.     }

  121. 

  122.     int64_t getUniqueId() const noexcept override

  123.     {

  124.         return fDesc.uid;

  125.     }

  126. 

  127.     // -------------------------------------------------------------------

  128.     // Information (count)

  129. 

  130.     // nothing

  131. 

  132.     // -------------------------------------------------------------------

  133.     // Information (current data)

  134. 

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

  136.     {

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

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

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

  140. 

  141.         *dataPtr = nullptr;

  142. 

  143.         try {

  144.             fChunk.reset();

  145.             fInstance->getStateInformation(fChunk);

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

  147. 

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

  149.         {

  150.             *dataPtr = fChunk.getData();

  151.             return size;

  152.         }

  153. 

  154.         return 0;

  155.     }

  156. 

  157.     // -------------------------------------------------------------------

  158.     // Information (per-plugin data)

  159. 

  160.     uint getOptionsAvailable() const noexcept override

  161.     {

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

  163. 

  164.         uint options = 0x0;

  165. 

  166.         options |= PLUGIN_OPTION_MAP_PROGRAM_CHANGES;

  167.         options |= PLUGIN_OPTION_USE_CHUNKS;

  168. 

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

  170.             options |= PLUGIN_OPTION_MAP_PROGRAM_CHANGES;

  171. 

  172.         if (fInstance->acceptsMidi())

  173.         {

  174.             options |= PLUGIN_OPTION_SEND_CONTROL_CHANGES;

  175.             options |= PLUGIN_OPTION_SEND_CHANNEL_PRESSURE;

  176.             options |= PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH;

  177.             options |= PLUGIN_OPTION_SEND_PITCHBEND;

  178.             options |= PLUGIN_OPTION_SEND_ALL_SOUND_OFF;

  179.             options |= PLUGIN_OPTION_SEND_PROGRAM_CHANGES;

  180.         }

  181. 

  182.         return options;

  183.     }

  184. 

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

  186.     {

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

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

  189. 

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

  191.     }

  192. 

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

  194.     {

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

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

  197.         else

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

  199. 

  200.         return true;

  201.     }

  202. 

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

  204.     {

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

  206.         return true;

  207.     }

  208. 

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

  210.     {

  211.         return getMaker(strBuf);

  212.     }

  213. 

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

  215.     {

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

  217.         return true;

  218.     }

  219. 

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

  221.     {

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

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

  224. 

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

  226.         return true;

  227.     }

  228. 

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

  230.     {

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

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

  233. 

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

  235.         return true;

  236.     }

  237. 

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

  239.     {

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

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

  242. 

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

  244.         return true;

  245.     }

  246. 

  247.     // -------------------------------------------------------------------

  248.     // Set data (state)

  249. 

  250.     // nothing

  251. 

  252.     // -------------------------------------------------------------------

  253.     // Set data (internal stuff)

  254. 

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

  256.     {

  257.         CarlaPlugin::setName(newName);

  258. 

  259.         if (fWindow != nullptr)

  260.         {

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

  262.             uiName += " (GUI)";

  263.             fWindow->setName(uiName);

  264.         }

  265.     }

  266. 

  267.     // -------------------------------------------------------------------

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

  269. 

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

  271.     {

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

  273.         CARLA_SAFE_ASSERT_RETURN(fInstance != nullptr,);

  274. 

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

  276. 

  277.         try {

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

  279.         } CARLA_SAFE_EXCEPTION("setParameter");

  280. 

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

  282.     }

  283. 

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

  285.     {

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

  287.         CARLA_SAFE_ASSERT_RETURN(fInstance != nullptr,);

  288. 

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

  290. 

  291.         try {

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

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

  294. 

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

  296.     }

  297. 

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

  299.     {

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

  301.         CARLA_SAFE_ASSERT_RETURN(fInstance != nullptr,);

  302.         CARLA_SAFE_ASSERT_RETURN(data != nullptr,);

  303.         CARLA_SAFE_ASSERT_RETURN(dataSize > 0,);

  304. 

  305.         if (isJuceSaveFormat(data, dataSize))

  306.         {

  307.             const ScopedSingleProcessLocker spl(this, true);

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

  309.         }

  310.         else

  311.         {

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

  313.             CARLA_SAFE_ASSERT_RETURN(dataCompat != nullptr,);

  314. 

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

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

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

  318. 

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

  320. 

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

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

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

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

  325. 

  326.             {

  327.                 const ScopedSingleProcessLocker spl(this, true);

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

  329.             }

  330. 

  331.             std::free(dataCompat);

  332.         }

  333. 

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

  335.     }

  336. 

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

  338.     {

  339.         CARLA_SAFE_ASSERT_RETURN(fInstance != nullptr,);

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

  341. 

  342.         if (index >= 0)

  343.         {

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

  345. 

  346.             try {

  347.                 fInstance->setCurrentProgram(index);

  348.             } CARLA_SAFE_EXCEPTION("setCurrentProgram");

  349.         }

  350. 

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

  352.     }

  353. 

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

  355.     {

  356.         CARLA_SAFE_ASSERT_RETURN(fInstance != nullptr,);

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

  358. 

  359.         try {

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

  361.         } CARLA_SAFE_EXCEPTION("setCurrentProgram");

  362. 

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

  364.     }

  365. 

  366.     // -------------------------------------------------------------------

  367.     // Set ui stuff

  368. 

  369.     void showCustomUI(const bool yesNo) override

  370.     {

  371.         CARLA_SAFE_ASSERT_RETURN(fInstance != nullptr,);

  372. 

  373.         if (yesNo)

  374.         {

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

  376.             {

  377.                 const EngineOptions& opts(pData->engine->getOptions());

  378. 

  379.                 editor->setScaleFactor(opts.uiScale);

  380. 

  381.                 if (fWindow == nullptr)

  382.                 {

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

  384.                     uiName += " (GUI)";

  385. 

  386.                     fWindow = new JucePluginWindow(opts.frontendWinId);

  387.                     fWindow->setName(uiName);

  388.                 }

  389. 

  390.                 fWindow->show(editor);

  391.             }

  392.         }

  393.         else

  394.         {

  395.             if (fWindow != nullptr)

  396.                 fWindow->hide();

  397. 

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

  399.                 delete editor;

  400. 

  401.             fWindow = nullptr;

  402.         }

  403.     }

  404. 

  405.     void uiIdle() override

  406.     {

  407.         if (fWindow != nullptr)

  408.         {

  409.             if (fWindow->wasClosedByUser())

  410.             {

  411.                 showCustomUI(false);

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

  413.                                         ENGINE_CALLBACK_UI_STATE_CHANGED,

  414.                                         pData->id,

  415.                                         0,

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

  417.             }

  418.         }

  419. 

  420.         CarlaPlugin::uiIdle();

  421.     }

  422. 

  423.     // -------------------------------------------------------------------

  424.     // Plugin state

  425. 

  426.     void reload() override

  427.     {

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

  429.         CARLA_SAFE_ASSERT_RETURN(fInstance != nullptr,);

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

  431. 

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

  433. 

  434.         // Safely disable plugin for reload

  435.         const ScopedDisabler sd(this);

  436. 

  437.         if (pData->active)

  438.             deactivate();

  439. 

  440.         clearBuffers();

  441. 

  442.         fInstance->enableAllBuses();

  443.         fInstance->refreshParameterList();

  444. 

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

  446.         mIns = mOuts = 0;

  447. 

  448.         bool needsCtrlIn, needsCtrlOut;

  449.         needsCtrlIn = needsCtrlOut = false;

  450. 

  451.         aIns   = static_cast<uint32_t>(std::max(fInstance->getTotalNumInputChannels(), 0));

  452.         aOuts  = static_cast<uint32_t>(std::max(fInstance->getTotalNumOutputChannels(), 0));

  453.         params = static_cast<uint32_t>(std::max(fInstance->getNumParameters(), 0));

  454. 

  455.         if (fInstance->acceptsMidi())

  456.         {

  457.             mIns = 1;

  458.             needsCtrlIn = true;

  459.         }

  460. 

  461.         if (fInstance->producesMidi())

  462.         {

  463.             mOuts = 1;

  464.             needsCtrlOut = true;

  465.         }

  466. 

  467.         if (aIns > 0)

  468.         {

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

  470.         }

  471. 

  472.         if (aOuts > 0)

  473.         {

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

  475.             needsCtrlIn = true;

  476.         }

  477. 

  478.         if (params > 0)

  479.         {

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

  481.             needsCtrlIn = true;

  482.         }

  483. 

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

  485.         CarlaString portName;

  486. 

  487.         // Audio Ins

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

  489.         {

  490.             portName.clear();

  491. 

  492.             if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  493.             {

  494.                 portName  = pData->name;

  495.                 portName += ":";

  496.             }

  497. 

  498.             if (aIns > 1)

  499.             {

  500.                 portName += "input_";

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

  502.             }

  503.             else

  504.                 portName += "input";

  505. 

  506.             portName.truncate(portNameSize);

  507. 

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

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

  510.         }

  511. 

  512.         // Audio Outs

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

  514.         {

  515.             portName.clear();

  516. 

  517.             if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  518.             {

  519.                 portName  = pData->name;

  520.                 portName += ":";

  521.             }

  522. 

  523.             if (aOuts > 1)

  524.             {

  525.                 portName += "output_";

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

  527.             }

  528.             else

  529.                 portName += "output";

  530. 

  531.             portName.truncate(portNameSize);

  532. 

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

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

  535.         }

  536. 

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

  538.         {

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

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

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

  542. 

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

  544. 

  545.             // TODO

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

  547.             {

  548.                 min = 0.0f;

  549.                 max = 1.0f;

  550.                 step = 0.001f;

  551.                 stepSmall = 0.0001f;

  552.                 stepLarge = 0.1f;

  553.             }

  554. 

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

  556. #ifndef BUILD_BRIDGE

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

  558. #endif

  559. 

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

  561.             {

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

  563. 

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

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

  566.             }

  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. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  600. #endif

  601.         }

  602. 

  603.         if (needsCtrlOut)

  604.         {

  605.             portName.clear();

  606. 

  607.             if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  608.             {

  609.                 portName  = pData->name;

  610.                 portName += ":";

  611.             }

  612. 

  613.             portName += "events-out";

  614.             portName.truncate(portNameSize);

  615. 

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

  617.         }

  618. 

  619.         // plugin hints

  620.         pData->hints  = 0x0;

  621.         pData->hints |= PLUGIN_NEEDS_FIXED_BUFFERS;

  622. 

  623.         if (fDesc.isInstrument)

  624.             pData->hints |= PLUGIN_IS_SYNTH;

  625. 

  626.         if (fInstance->hasEditor())

  627.         {

  628.             pData->hints |= PLUGIN_HAS_CUSTOM_UI;

  629.             pData->hints |= PLUGIN_NEEDS_UI_MAIN_THREAD;

  630.         }

  631. 

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

  633.             pData->hints |= PLUGIN_CAN_DRYWET;

  634. 

  635.         if (aOuts > 0)

  636.             pData->hints |= PLUGIN_CAN_VOLUME;

  637. 

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

  639.             pData->hints |= PLUGIN_CAN_BALANCE;

  640. 

  641.         // extra plugin hints

  642.         pData->extraHints = 0x0;

  643. 

  644.         if (mIns > 0)

  645.             pData->extraHints |= PLUGIN_EXTRA_HINT_HAS_MIDI_IN;

  646. 

  647.         if (mOuts > 0)

  648.             pData->extraHints |= PLUGIN_EXTRA_HINT_HAS_MIDI_OUT;

  649. 

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

  651. 

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

  653.         reloadPrograms(true);

  654. 

  655.         if (pData->active)

  656.             activate();

  657. 

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

  659.     }

  660. 

  661.     void reloadPrograms(const bool doInit) override

  662.     {

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

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

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

  666. 

  667.         // Delete old programs

  668.         pData->prog.clear();

  669. 

  670.         // Query new programs

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

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

  673.                                 : 0;

  674. 

  675.         if (newCount > 0)

  676.         {

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

  678. 

  679.             // Update names

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

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

  682.         }

  683. 

  684.         if (doInit)

  685.         {

  686.             if (newCount > 0)

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

  688.         }

  689.         else

  690.         {

  691.             // Check if current program is invalid

  692.             bool programChanged = false;

  693. 

  694.             if (newCount == oldCount+1)

  695.             {

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

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

  698.                 programChanged = true;

  699.             }

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

  701.             {

  702.                 // programs exist now, but not before

  703.                 pData->prog.current = 0;

  704.                 programChanged = true;

  705.             }

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

  707.             {

  708.                 // programs existed before, but not anymore

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

  710.                 programChanged = true;

  711.             }

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

  713.             {

  714.                 // current program > count

  715.                 pData->prog.current = 0;

  716.                 programChanged = true;

  717.             }

  718.             else

  719.             {

  720.                 // no change

  721.                 pData->prog.current = current;

  722.             }

  723. 

  724.             if (programChanged)

  725.             {

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

  727.             }

  728.             else

  729.             {

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

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

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

  733.             }

  734. 

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

  736.         }

  737.     }

  738. 

  739.     // -------------------------------------------------------------------

  740.     // Plugin processing

  741. 

  742.     void activate() noexcept override

  743.     {

  744.         CARLA_SAFE_ASSERT_RETURN(fInstance != nullptr,);

  745. 

  746.         try {

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

  748.         } catch(...) {}

  749.     }

  750. 

  751.     void deactivate() noexcept override

  752.     {

  753.         CARLA_SAFE_ASSERT_RETURN(fInstance != nullptr,);

  754. 

  755.         try {

  756.             fInstance->releaseResources();

  757.         } catch(...) {}

  758.     }

  759. 

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

  761.                  float** const audioOut,

  762.                  const float* const* const cvIn,

  763.                  float**,

  764.                  const uint32_t frames) override

  765.     {

  766.         // --------------------------------------------------------------------------------------------------------

  767.         // Check if active

  768. 

  769.         if (! pData->active)

  770.         {

  771.             // disable any output sound

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

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

  774.             return;

  775.         }

  776. 

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

  778.         // Check if needs reset

  779. 

  780.         if (pData->needsReset)

  781.         {

  782.             fInstance->reset();

  783.             pData->needsReset = false;

  784.         }

  785. 

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

  787.         // Event Input

  788. 

  789.         fMidiBuffer.clear();

  790. 

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

  792.         {

  793.             // ----------------------------------------------------------------------------------------------------

  794.             // MIDI Input (External)

  795. 

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

  797.             {

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

  799.                 {

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

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

  802. 

  803.                     uint8_t midiEvent[3];

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

  805.                     midiEvent[1] = note.note;

  806.                     midiEvent[2] = note.velo;

  807. 

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

  809.                 }

  810. 

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

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

  813. 

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

  815. 

  816.             // ----------------------------------------------------------------------------------------------------

  817.             // Event Input (System)

  818. 

  819. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  820.             bool allNotesOffSent = false;

  821. 

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

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

  824. #endif

  825. 

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

  827.             {

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

  829. 

  830.                 if (event.time >= frames)

  831.                     continue;

  832. 

  833.                 switch (event.type)

  834.                 {

  835.                 case kEngineEventTypeNull:

  836.                     break;

  837. 

  838.                 case kEngineEventTypeControl: {

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

  840. 

  841.                     switch (ctrlEvent.type)

  842.                     {

  843.                     case kEngineControlEventTypeNull:

  844.                         break;

  845. 

  846.                     case kEngineControlEventTypeParameter: {

  847.                         float value;

  848. 

  849. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  850.                         // non-midi

  851.                         if (event.channel == kEngineEventNonMidiChannel)

  852.                         {

  853.                             const uint32_t k = ctrlEvent.param;

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

  855. 

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

  857.                             setParameterValueRT(k, value, true);

  858.                             continue;

  859.                         }

  860. 

  861.                         // Control backend stuff

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

  863.                         {

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

  865.                             {

  866.                                 value = ctrlEvent.value;

  867.                                 setDryWetRT(value, true);

  868.                             }

  869. 

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

  871.                             {

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

  873.                                 setVolumeRT(value, true);

  874.                             }

  875. 

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

  877.                             {

  878.                                 float left, right;

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

  880. 

  881.                                 if (value < 0.0f)

  882.                                 {

  883.                                     left  = -1.0f;

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

  885.                                 }

  886.                                 else if (value > 0.0f)

  887.                                 {

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

  889.                                     right = 1.0f;

  890.                                 }

  891.                                 else

  892.                                 {

  893.                                     left  = -1.0f;

  894.                                     right = 1.0f;

  895.                                 }

  896. 

  897.                                 setBalanceLeftRT(left, true);

  898.                                 setBalanceRightRT(right, true);

  899.                             }

  900.                         }

  901. #endif

  902.                         // Control plugin parameters

  903.                         uint32_t k;

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

  905.                         {

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

  907.                                 continue;

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

  909.                                 continue;

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

  911.                                 continue;

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

  913.                                 continue;

  914. 

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

  916.                             setParameterValueRT(k, value, true);

  917.                         }

  918. 

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

  920.                         {

  921.                             uint8_t midiData[3];

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

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

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

  925. 

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

  927.                         }

  928. 

  929.                         break;

  930.                     } // case kEngineControlEventTypeParameter

  931. 

  932.                     case kEngineControlEventTypeMidiBank:

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

  934.                         {

  935.                             uint8_t midiData[3];

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

  937.                             midiData[1] = MIDI_CONTROL_BANK_SELECT;

  938.                             midiData[2] = 0;

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

  940. 

  941.                             midiData[1] = MIDI_CONTROL_BANK_SELECT__LSB;

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

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

  944.                         }

  945.                         break;

  946. 

  947.                     case kEngineControlEventTypeMidiProgram:

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

  949.                         {

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

  951.                             {

  952.                                 setProgramRT(ctrlEvent.param, true);

  953.                             }

  954.                         }

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

  956.                         {

  957.                             uint8_t midiData[3];

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

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

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

  961.                         }

  962.                         break;

  963. 

  964.                     case kEngineControlEventTypeAllSoundOff:

  965.                         if (pData->options & PLUGIN_OPTION_SEND_ALL_SOUND_OFF)

  966.                         {

  967.                             uint8_t midiData[3];

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

  969.                             midiData[1] = MIDI_CONTROL_ALL_SOUND_OFF;

  970.                             midiData[2] = 0;

  971. 

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

  973.                         }

  974.                         break;

  975. 

  976.                     case kEngineControlEventTypeAllNotesOff:

  977.                         if (pData->options & PLUGIN_OPTION_SEND_ALL_SOUND_OFF)

  978.                         {

  979. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  981.                             {

  982.                                 allNotesOffSent = true;

  983.                                 postponeRtAllNotesOff();

  984.                             }

  985. #endif

  986. 

  987.                             uint8_t midiData[3];

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

  989.                             midiData[1] = MIDI_CONTROL_ALL_NOTES_OFF;

  990.                             midiData[2] = 0;

  991. 

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

  993.                         }

  994.                         break;

  995.                     } // switch (ctrlEvent.type)

  996.                     break;

  997.                 } // case kEngineEventTypeControl

  998. 

  999.                 case kEngineEventTypeMidi: {

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

  1001. 

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

  1003. 

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

  1005. 

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

  1007.                         continue;

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

  1009.                         continue;

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

  1011.                         continue;

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

  1013.                         continue;

  1014. 

  1015.                     // Fix bad note-off

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

  1017.                         status = MIDI_STATUS_NOTE_OFF;

  1018. 

  1019.                     // put back channel in data

  1020.                     uint8_t midiData2[midiEvent.size];

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

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

  1023. 

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

  1025. 

  1026.                     if (status == MIDI_STATUS_NOTE_ON)

  1027.                     {

  1028.                         pData->postponeRtEvent(kPluginPostRtEventNoteOn,

  1029.                                                true,

  1030.                                                event.channel,

  1031.                                                midiData[1],

  1032.                                                midiData[2],

  1033.                                                0.0f);

  1034.                     }

  1035.                     else if (status == MIDI_STATUS_NOTE_OFF)

  1036.                     {

  1037.                         pData->postponeRtEvent(kPluginPostRtEventNoteOff,

  1038.                                                true,

  1039.                                                event.channel,

  1040.                                                midiData[1],

  1041.                                                0, 0.0f);

  1042.                     }

  1043.                 } break;

  1044.                 } // switch (event.type)

  1045.             }

  1046. 

  1047.             pData->postRtEvents.trySplice();

  1048. 

  1049.         } // End of Event Input

  1050. 

  1051.         // --------------------------------------------------------------------------------------------------------

  1052.         // Set TimeInfo

  1053. 

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

  1055. 

  1056.         fPosInfo.isPlaying = timeInfo.playing;

  1057. 

  1058.         if (timeInfo.bbt.valid)

  1059.         {

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

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

  1062. 

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

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

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

  1066. 

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

  1068. 

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

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

  1071. 

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

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

  1074. 

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

  1076.             fPosInfo.ppqPositionOfLastBarStart = ppqBar;

  1077.         }

  1078. 

  1079.         // --------------------------------------------------------------------------------------------------------

  1080.         // Process

  1081. 

  1082.         processSingle(audioIn, audioOut, frames);

  1083. 

  1084.         // --------------------------------------------------------------------------------------------------------

  1085. 

  1086. #ifdef BUILD_BRIDGE_ALTERNATIVE_ARCH

  1087.         return;

  1088. 

  1089.         // unused

  1090.         (void)cvIn;

  1091. #endif

  1092.     }

  1093. 

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

  1095.     {

  1096.         CARLA_SAFE_ASSERT_RETURN(frames > 0, false);

  1097. 

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

  1099.         {

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

  1101.         }

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

  1103.         {

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

  1105.         }

  1106. 

  1107.         // --------------------------------------------------------------------------------------------------------

  1108.         // Try lock, silence otherwise

  1109. 

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

  1111.         {

  1112.             pData->singleMutex.lock();

  1113.         }

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

  1115.         {

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

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

  1118.             return false;

  1119.         }

  1120. 

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

  1122.         // Set audio in buffers

  1123. 

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

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

  1126. 

  1127.         // --------------------------------------------------------------------------------------------------------

  1128.         // Run plugin

  1129. 

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

  1131. 

  1132.         // --------------------------------------------------------------------------------------------------------

  1133.         // Set audio out buffers

  1134. 

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

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

  1137. 

  1138.         // --------------------------------------------------------------------------------------------------------

  1139.         // Midi out

  1140. 

  1141.         if (! fMidiBuffer.isEmpty())

  1142.         {

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

  1144.             {

  1145.                 const uint8_t* midiEventData;

  1146.                 int midiEventSize, midiEventPosition;

  1147. 

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

  1149.                 {

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

  1151.                     CARLA_SAFE_ASSERT_BREAK(midiEventSize > 0);

  1152. 

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

  1154.                         break;

  1155.                 }

  1156.             }

  1157. 

  1158.             fMidiBuffer.clear();

  1159.         }

  1160. 

  1161.         // --------------------------------------------------------------------------------------------------------

  1162. 

  1163.         pData->singleMutex.unlock();

  1164.         return true;

  1165.     }

  1166. 

  1167.     void bufferSizeChanged(const uint32_t newBufferSize) override

  1168.     {

  1169.         CARLA_ASSERT_INT(newBufferSize > 0, newBufferSize);

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

  1171. 

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

  1173. 

  1174.         if (pData->active)

  1175.         {

  1176.             deactivate();

  1177.             activate();

  1178.         }

  1179.     }

  1180. 

  1181.     void sampleRateChanged(const double newSampleRate) override

  1182.     {

  1183.         CARLA_ASSERT_INT(newSampleRate > 0.0, newSampleRate);

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

  1185. 

  1186.         if (pData->active)

  1187.         {

  1188.             deactivate();

  1189.             activate();

  1190.         }

  1191.     }

  1192. 

  1193.     // -------------------------------------------------------------------

  1194.     // Plugin buffers

  1195. 

  1196.     // nothing

  1197. 

  1198.     // -------------------------------------------------------------------

  1199.     // Post-poned UI Stuff

  1200. 

  1201.     // nothing

  1202. 

  1203.     // -------------------------------------------------------------------

  1204. 

  1205.     void* getNativeHandle() const noexcept override

  1206.     {

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

  1208.     }

  1209. 

  1210.     // -------------------------------------------------------------------

  1211. 

  1212. protected:

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

  1214.     {

  1215.         CARLA_SAFE_ASSERT_RETURN(index >= 0,);

  1216. 

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

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

  1219. 

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

  1221.     }

  1222. 

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

  1224.     {

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

  1226.     }

  1227. 

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

  1229.     {

  1230.         CARLA_SAFE_ASSERT_RETURN(index >= 0,);

  1231. 

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

  1233.     }

  1234. 

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

  1236.     {

  1237.         CARLA_SAFE_ASSERT_RETURN(index >= 0,);

  1238. 

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

  1240.     }

  1241. 

  1242.     bool getCurrentPosition(CurrentPositionInfo& result) override

  1243.     {

  1244.         carla_copyStruct(result, fPosInfo);

  1245.         return true;

  1246.     }

  1247. 

  1248.     // -------------------------------------------------------------------

  1249. 

  1250. public:

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

  1252.     {

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

  1254. 

  1255.         // ---------------------------------------------------------------

  1256.         // first checks

  1257. 

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

  1259.         {

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

  1261.             return false;

  1262.         }

  1263. 

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

  1265.         {

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

  1267.             return false;

  1268.         }

  1269. 

  1270.         // AU requires label

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

  1272.         {

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

  1274.             {

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

  1276.                 return false;

  1277.             }

  1278.         }

  1279. 

  1280.         juce::String fileOrIdentifier;

  1281. 

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

  1283.         {

  1284.             fileOrIdentifier = label;

  1285.         }

  1286.         else

  1287.         {

  1288.             // VST2 and VST3 require filename

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

  1290.             {

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

  1292.                 return false;

  1293.             }

  1294. 

  1295.             juce::String jfilename(filename);

  1296. 

  1297. #ifdef CARLA_OS_WIN

  1298.             // Fix for wine usage

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

  1300.             {

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

  1302.                 jfilename = "Z:" + jfilename;

  1303.             }

  1304. #endif

  1305. 

  1306.             fileOrIdentifier = jfilename;

  1307. 

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

  1309.                 fDesc.name = label;

  1310.         }

  1311. 

  1312.         fFormatManager.addDefaultFormats();

  1313. 

  1314.         {

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

  1316.             juce::KnownPluginList plist;

  1317. 

  1318.             {

  1319.                 const ScopedAbortCatcher sac;

  1320. 

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

  1322.                 {

  1323.                     try {

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

  1325.                     } CARLA_SAFE_EXCEPTION_CONTINUE("scanAndAddFile")

  1326. 

  1327.                     if (sac.wasTriggered())

  1328.                     {

  1329.                         pluginDescriptions.clearQuick(false);

  1330.                         break;

  1331.                     }

  1332.                 }

  1333.             }

  1334. 

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

  1336.             {

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

  1338.                 return false;

  1339.             }

  1340. 

  1341.             fDesc = *pluginDescriptions[0];

  1342.         }

  1343. 

  1344.         if (uniqueId != 0)

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

  1346. 

  1347.         juce::String error;

  1348. 

  1349.         {

  1350.             const ScopedAbortCatcher sac;

  1351. 

  1352.             try {

  1353.                 fInstance = fFormatManager.createPluginInstance(fDesc,

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

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

  1356.                                                                 error);

  1357.             } CARLA_SAFE_EXCEPTION("createPluginInstance")

  1358. 

  1359.             if (sac.wasTriggered())

  1360.                 fInstance = nullptr;

  1361.         }

  1362. 

  1363.         if (fInstance == nullptr)

  1364.         {

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

  1366.             return false;

  1367.         }

  1368. 

  1369.         fInstance->fillInPluginDescription(fDesc);

  1370.         fInstance->setPlayHead(this);

  1371.         fInstance->addListener(this);

  1372. 

  1373.         fFormatName = format;

  1374. 

  1375.         // ---------------------------------------------------------------

  1376.         // get info

  1377. 

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

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

  1380.         else

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

  1382. 

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

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

  1385. 

  1386.         // ---------------------------------------------------------------

  1387.         // register client

  1388. 

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

  1390. 

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

  1392.         {

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

  1394.             return false;

  1395.         }

  1396. 

  1397.         // ---------------------------------------------------------------

  1398.         // set options

  1399. 

  1400.         pData->options  = 0x0;

  1401.         pData->options |= PLUGIN_OPTION_FIXED_BUFFERS;

  1402.         pData->options |= PLUGIN_OPTION_USE_CHUNKS;

  1403. 

  1404.         if (fInstance->acceptsMidi())

  1405.         {

  1406.             if (isPluginOptionEnabled(options, PLUGIN_OPTION_SEND_CONTROL_CHANGES))

  1407.                 pData->options |= PLUGIN_OPTION_SEND_CONTROL_CHANGES;

  1408.             if (isPluginOptionEnabled(options, PLUGIN_OPTION_SEND_CHANNEL_PRESSURE))

  1409.                 pData->options |= PLUGIN_OPTION_SEND_CHANNEL_PRESSURE;

  1410.             if (isPluginOptionEnabled(options, PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH))

  1411.                 pData->options |= PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH;

  1412.             if (isPluginOptionEnabled(options, PLUGIN_OPTION_SEND_PITCHBEND))

  1413.                 pData->options |= PLUGIN_OPTION_SEND_PITCHBEND;

  1414.             if (isPluginOptionEnabled(options, PLUGIN_OPTION_SEND_ALL_SOUND_OFF))

  1415.                 pData->options |= PLUGIN_OPTION_SEND_ALL_SOUND_OFF;

  1416.             if (isPluginOptionEnabled(options, PLUGIN_OPTION_SEND_PROGRAM_CHANGES))

  1417.                 pData->options |= PLUGIN_OPTION_SEND_PROGRAM_CHANGES;

  1418.         }

  1419. 

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

  1421.         {

  1422.             if (isPluginOptionEnabled(options, PLUGIN_OPTION_MAP_PROGRAM_CHANGES))

  1423.                 pData->options |= PLUGIN_OPTION_MAP_PROGRAM_CHANGES;

  1424.         }

  1425. 

  1426.         return true;

  1427.     }

  1428. 

  1429. private:

  1430.     juce::PluginDescription    fDesc;

  1431.     juce::AudioPluginFormatManager fFormatManager;

  1432.     std::unique_ptr<juce::AudioPluginInstance> fInstance;

  1433. 

  1434.     juce::AudioSampleBuffer fAudioBuffer;

  1435.     juce::MidiBuffer        fMidiBuffer;

  1436.     CurrentPositionInfo     fPosInfo;

  1437.     juce::MemoryBlock       fChunk;

  1438.     juce::String            fFormatName;

  1439. 

  1440.     CarlaScopedPointer<JucePluginWindow> fWindow;

  1441. 

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

  1443.     {

  1444.         if (fFormatName != "VST2")

  1445.             return true;

  1446.         if (dataSize < 160)

  1447.             return false;

  1448. 

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

  1450. 

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

  1452.             return false;

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

  1454.             return false;

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

  1456.             return false;

  1457. 

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

  1459. 

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

  1461.     }

  1462. 

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

  1464.     {

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

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

  1467.     }

  1468. 

  1469.     static int32_t fxbSwap(const int32_t x) noexcept

  1470.     {

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

  1472.     }

  1473. 

  1474.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaPluginJuce)

  1475. };

  1476. 

  1477. CARLA_BACKEND_END_NAMESPACE

  1478. 

  1479. #endif // USING_JUCE

  1480. 

  1481. // -------------------------------------------------------------------------------------------------------------------

  1482. 

  1483. CARLA_BACKEND_START_NAMESPACE

  1484. 

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

  1486. {

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

  1488. 

  1489. #ifdef USING_JUCE

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

  1491. 

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

  1493.     {

  1494.         delete plugin;

  1495.         return nullptr;

  1496.     }

  1497. 

  1498.     return plugin;

  1499. #else

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

  1501.     return nullptr;

  1502. 

  1503.     // unused

  1504.     (void)format;

  1505. #endif

  1506. }

  1507. 

  1508. CARLA_BACKEND_END_NAMESPACE

  1509. 

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