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

1443 lines
49KB
Raw Blame History 

  1. /*

  2.  * Carla Juce Plugin

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

  4.  *

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

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

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

  8.  * the License, or any later version.

  9.  *

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

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

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

  13.  * GNU General Public License for more details.

  14.  *

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

  16.  */

  17. 

  18. #include "CarlaPluginInternal.hpp"

  19. #include "CarlaEngine.hpp"

  20. 

  21. #if defined(USING_JUCE)

  22. 

  23. #include "CarlaBackendUtils.hpp"

  24. #include "CarlaMathUtils.hpp"

  25. 

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

  27. # pragma GCC diagnostic push

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

  29. # pragma GCC diagnostic ignored "-Wconversion"

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

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

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

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

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

  35. # pragma GCC diagnostic ignored "-Wundef"

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

  37. # if __GNUC__ > 7

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

  39. # endif

  40. #endif

  41. 

  42. #include "AppConfig.h"

  43. #include "juce_audio_processors/juce_audio_processors.h"

  44. #include "juce_gui_basics/juce_gui_basics.h"

  45. 

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

  47. # pragma GCC diagnostic pop

  48. #endif

  49. 

  50. #include "JucePluginWindow.hpp"

  51. 

  52. namespace juce {

  53. extern bool juce_isRunningInWine();

  54. }

  55. 

  56. CARLA_BACKEND_START_NAMESPACE

  57. 

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

  59. // Fallback data

  60. 

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

  62. 

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

  64. 

  65. class CarlaPluginJuce : public CarlaPlugin,

  66.                         private juce::AudioPlayHead,

  67.                         private juce::AudioProcessorListener

  68. {

  69. public:

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

  71.         : CarlaPlugin(engine, id),

  72.           fDesc(),

  73.           fInstance(nullptr),

  74.           fFormatManager(),

  75.           fAudioBuffer(),

  76.           fMidiBuffer(),

  77.           fPosInfo(),

  78.           fChunk(),

  79.           fFormatName(),

  80.           fWindow()

  81.     {

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

  83. 

  84.         fMidiBuffer.ensureSize(2048);

  85.         fMidiBuffer.clear();

  86.         fPosInfo.resetToDefault();

  87.     }

  88. 

  89.     ~CarlaPluginJuce() override

  90.     {

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

  92. 

  93.         // close UI

  94.         if (pData->hints & PLUGIN_HAS_CUSTOM_UI)

  95.             showCustomUI(false);

  96. 

  97.         pData->singleMutex.lock();

  98.         pData->masterMutex.lock();

  99. 

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

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

  102. 

  103.         if (pData->active)

  104.         {

  105.             deactivate();

  106.             pData->active = false;

  107.         }

  108. 

  109.         if (fInstance != nullptr)

  110.         {

  111.             delete fInstance;

  112.             fInstance = nullptr;

  113.         }

  114. 

  115.         clearBuffers();

  116.     }

  117. 

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

  119.     // Information (base)

  120. 

  121.     PluginType getType() const noexcept override

  122.     {

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

  124.     }

  125. 

  126.     PluginCategory getCategory() const noexcept override

  127.     {

  128.         if (fDesc.isInstrument)

  129.             return PLUGIN_CATEGORY_SYNTH;

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

  131.     }

  132. 

  133.     int64_t getUniqueId() const noexcept override

  134.     {

  135.         return fDesc.uid;

  136.     }

  137. 

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

  139.     // Information (count)

  140. 

  141.     // nothing

  142. 

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

  144.     // Information (current data)

  145. 

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

  147.     {

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

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

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

  151. 

  152.         *dataPtr = nullptr;

  153. 

  154.         try {

  155.             fChunk.reset();

  156.             fInstance->getStateInformation(fChunk);

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

  158. 

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

  160.         {

  161.             *dataPtr = fChunk.getData();

  162.             return size;

  163.         }

  164. 

  165.         return 0;

  166.     }

  167. 

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

  169.     // Information (per-plugin data)

  170. 

  171.     uint getOptionsAvailable() const noexcept override

  172.     {

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

  174. 

  175.         uint options = 0x0;

  176. 

  177.         options |= PLUGIN_OPTION_MAP_PROGRAM_CHANGES;

  178.         options |= PLUGIN_OPTION_USE_CHUNKS;

  179. 

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

  181.             options |= PLUGIN_OPTION_MAP_PROGRAM_CHANGES;

  182. 

  183.         if (fInstance->acceptsMidi())

  184.         {

  185.             options |= PLUGIN_OPTION_SEND_CONTROL_CHANGES;

  186.             options |= PLUGIN_OPTION_SEND_CHANNEL_PRESSURE;

  187.             options |= PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH;

  188.             options |= PLUGIN_OPTION_SEND_PITCHBEND;

  189.             options |= PLUGIN_OPTION_SEND_ALL_SOUND_OFF;

  190.             options |= PLUGIN_OPTION_SEND_PROGRAM_CHANGES;

  191.         }

  192. 

  193.         return options;

  194.     }

  195. 

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

  197.     {

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

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

  200. 

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

  202.     }

  203. 

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

  205.     {

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

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

  208.         else

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

  210. 

  211.         return true;

  212.     }

  213. 

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

  215.     {

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

  217.         return true;

  218.     }

  219. 

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

  221.     {

  222.         return getMaker(strBuf);

  223.     }

  224. 

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

  226.     {

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

  228.         return true;

  229.     }

  230. 

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

  232.     {

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

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

  235. 

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

  237.         return true;

  238.     }

  239. 

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

  241.     {

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

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

  244. 

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

  246.         return true;

  247.     }

  248. 

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

  250.     {

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

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

  253. 

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

  255.         return true;

  256.     }

  257. 

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

  259.     // Set data (state)

  260. 

  261.     // nothing

  262. 

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

  264.     // Set data (internal stuff)

  265. 

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

  267.     {

  268.         CarlaPlugin::setName(newName);

  269. 

  270.         if (fWindow != nullptr)

  271.         {

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

  273.             uiName += " (GUI)";

  274.             fWindow->setName(uiName);

  275.         }

  276.     }

  277. 

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

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

  280. 

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

  282.     {

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

  284.         CARLA_SAFE_ASSERT_RETURN(fInstance != nullptr,);

  285. 

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

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

  288. 

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

  290.     }

  291. 

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

  293.     {

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

  295.         CARLA_SAFE_ASSERT_RETURN(fInstance != nullptr,);

  296. 

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

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

  299. 

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

  301.     }

  302. 

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

  304.     {

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

  306.         CARLA_SAFE_ASSERT_RETURN(fInstance != nullptr,);

  307.         CARLA_SAFE_ASSERT_RETURN(data != nullptr,);

  308.         CARLA_SAFE_ASSERT_RETURN(dataSize > 0,);

  309. 

  310.         if (isJuceSaveFormat(data, dataSize))

  311.         {

  312.             const ScopedSingleProcessLocker spl(this, true);

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

  314.         }

  315.         else

  316.         {

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

  318.             CARLA_SAFE_ASSERT_RETURN(dataCompat != nullptr,);

  319. 

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

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

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

  323. 

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

  325. 

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

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

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

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

  330. 

  331.             {

  332.                 const ScopedSingleProcessLocker spl(this, true);

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

  334.             }

  335. 

  336.             std::free(dataCompat);

  337.         }

  338. 

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

  340.     }

  341. 

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

  343.     {

  344.         CARLA_SAFE_ASSERT_RETURN(fInstance != nullptr,);

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

  346. 

  347.         if (index >= 0)

  348.         {

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

  350. 

  351.             try {

  352.                 fInstance->setCurrentProgram(index);

  353.             } CARLA_SAFE_EXCEPTION("setCurrentProgram");

  354.         }

  355. 

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

  357.     }

  358. 

  359.     // -------------------------------------------------------------------

  360.     // Set ui stuff

  361. 

  362.     void showCustomUI(const bool yesNo) override

  363.     {

  364.         CARLA_SAFE_ASSERT_RETURN(fInstance != nullptr,);

  365. 

  366.         if (yesNo)

  367.         {

  368.             if (fWindow == nullptr)

  369.             {

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

  371.                 uiName += " (GUI)";

  372. 

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

  374.                 fWindow->setName(uiName);

  375.             }

  376. 

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

  378.                 fWindow->show(editor);

  379.         }

  380.         else

  381.         {

  382.             if (fWindow != nullptr)

  383.                 fWindow->hide();

  384. 

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

  386.                 delete editor;

  387. 

  388.             fWindow = nullptr;

  389.         }

  390.     }

  391. 

  392.     void uiIdle() override

  393.     {

  394.         if (fWindow != nullptr)

  395.         {

  396.             if (fWindow->wasClosedByUser())

  397.             {

  398.                 showCustomUI(false);

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

  400.                                         ENGINE_CALLBACK_UI_STATE_CHANGED,

  401.                                         pData->id,

  402.                                         0,

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

  404.             }

  405.         }

  406. 

  407.         CarlaPlugin::uiIdle();

  408.     }

  409. 

  410.     // -------------------------------------------------------------------

  411.     // Plugin state

  412. 

  413.     void reload() override

  414.     {

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

  416.         CARLA_SAFE_ASSERT_RETURN(fInstance != nullptr,);

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

  418. 

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

  420. 

  421.         // Safely disable plugin for reload

  422.         const ScopedDisabler sd(this);

  423. 

  424.         if (pData->active)

  425.             deactivate();

  426. 

  427.         clearBuffers();

  428. 

  429.         fInstance->refreshParameterList();

  430. 

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

  432.         mIns = mOuts = 0;

  433. 

  434.         bool needsCtrlIn, needsCtrlOut;

  435.         needsCtrlIn = needsCtrlOut = false;

  436. 

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

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

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

  440. 

  441.         if (fInstance->acceptsMidi())

  442.         {

  443.             mIns = 1;

  444.             needsCtrlIn = true;

  445.         }

  446. 

  447.         if (fInstance->producesMidi())

  448.         {

  449.             mOuts = 1;

  450.             needsCtrlOut = true;

  451.         }

  452. 

  453.         if (aIns > 0)

  454.         {

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

  456.         }

  457. 

  458.         if (aOuts > 0)

  459.         {

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

  461.             needsCtrlIn = true;

  462.         }

  463. 

  464.         if (params > 0)

  465.         {

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

  467.             needsCtrlIn = true;

  468.         }

  469. 

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

  471.         CarlaString portName;

  472. 

  473.         // Audio Ins

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

  475.         {

  476.             portName.clear();

  477. 

  478.             if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  479.             {

  480.                 portName  = pData->name;

  481.                 portName += ":";

  482.             }

  483. 

  484.             if (aIns > 1)

  485.             {

  486.                 portName += "input_";

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

  488.             }

  489.             else

  490.                 portName += "input";

  491. 

  492.             portName.truncate(portNameSize);

  493. 

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

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

  496.         }

  497. 

  498.         // Audio Outs

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

  500.         {

  501.             portName.clear();

  502. 

  503.             if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  504.             {

  505.                 portName  = pData->name;

  506.                 portName += ":";

  507.             }

  508. 

  509.             if (aOuts > 1)

  510.             {

  511.                 portName += "output_";

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

  513.             }

  514.             else

  515.                 portName += "output";

  516. 

  517.             portName.truncate(portNameSize);

  518. 

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

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

  521.         }

  522. 

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

  524.         {

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

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

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

  528. 

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

  530. 

  531.             // TODO

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

  533.             {

  534.                 min = 0.0f;

  535.                 max = 1.0f;

  536.                 step = 0.001f;

  537.                 stepSmall = 0.0001f;

  538.                 stepLarge = 0.1f;

  539.             }

  540. 

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

  542. #ifndef BUILD_BRIDGE

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

  544. #endif

  545. 

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

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

  548. 

  549.             // FIXME?

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

  551. 

  552.             if (def < min)

  553.                 def = min;

  554.             else if (def > max)

  555.                 def = max;

  556. 

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

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

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

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

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

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

  563.         }

  564. 

  565.         if (needsCtrlIn)

  566.         {

  567.             portName.clear();

  568. 

  569.             if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  570.             {

  571.                 portName  = pData->name;

  572.                 portName += ":";

  573.             }

  574. 

  575.             portName += "events-in";

  576.             portName.truncate(portNameSize);

  577. 

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

  579.         }

  580. 

  581.         if (needsCtrlOut)

  582.         {

  583.             portName.clear();

  584. 

  585.             if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  586.             {

  587.                 portName  = pData->name;

  588.                 portName += ":";

  589.             }

  590. 

  591.             portName += "events-out";

  592.             portName.truncate(portNameSize);

  593. 

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

  595.         }

  596. 

  597.         // plugin hints

  598.         pData->hints  = 0x0;

  599.         pData->hints |= PLUGIN_NEEDS_FIXED_BUFFERS;

  600. 

  601.         if (fDesc.isInstrument)

  602.             pData->hints |= PLUGIN_IS_SYNTH;

  603. 

  604.         if (fInstance->hasEditor())

  605.         {

  606.             pData->hints |= PLUGIN_HAS_CUSTOM_UI;

  607.             pData->hints |= PLUGIN_NEEDS_UI_MAIN_THREAD;

  608.         }

  609. 

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

  611.             pData->hints |= PLUGIN_CAN_DRYWET;

  612. 

  613.         if (aOuts > 0)

  614.             pData->hints |= PLUGIN_CAN_VOLUME;

  615. 

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

  617.             pData->hints |= PLUGIN_CAN_BALANCE;

  618. 

  619.         // extra plugin hints

  620.         pData->extraHints = 0x0;

  621. 

  622.         if (mIns > 0)

  623.             pData->extraHints |= PLUGIN_EXTRA_HINT_HAS_MIDI_IN;

  624. 

  625.         if (mOuts > 0)

  626.             pData->extraHints |= PLUGIN_EXTRA_HINT_HAS_MIDI_OUT;

  627. 

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

  629. 

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

  631.         reloadPrograms(true);

  632. 

  633.         if (pData->active)

  634.             activate();

  635. 

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

  637.     }

  638. 

  639.     void reloadPrograms(const bool doInit) override

  640.     {

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

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

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

  644. 

  645.         // Delete old programs

  646.         pData->prog.clear();

  647. 

  648.         // Query new programs

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

  650. 

  651.         if (newCount > 0)

  652.         {

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

  654. 

  655.             // Update names

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

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

  658.         }

  659. 

  660.         if (doInit)

  661.         {

  662.             if (newCount > 0)

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

  664.         }

  665.         else

  666.         {

  667.             // Check if current program is invalid

  668.             bool programChanged = false;

  669. 

  670.             if (newCount == oldCount+1)

  671.             {

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

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

  674.                 programChanged = true;

  675.             }

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

  677.             {

  678.                 // programs exist now, but not before

  679.                 pData->prog.current = 0;

  680.                 programChanged = true;

  681.             }

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

  683.             {

  684.                 // programs existed before, but not anymore

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

  686.                 programChanged = true;

  687.             }

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

  689.             {

  690.                 // current program > count

  691.                 pData->prog.current = 0;

  692.                 programChanged = true;

  693.             }

  694.             else

  695.             {

  696.                 // no change

  697.                 pData->prog.current = current;

  698.             }

  699. 

  700.             if (programChanged)

  701.             {

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

  703.             }

  704.             else

  705.             {

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

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

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

  709.             }

  710. 

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

  712.         }

  713.     }

  714. 

  715.     // -------------------------------------------------------------------

  716.     // Plugin processing

  717. 

  718.     void activate() noexcept override

  719.     {

  720.         CARLA_SAFE_ASSERT_RETURN(fInstance != nullptr,);

  721. 

  722.         try {

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

  724.         } catch(...) {}

  725.     }

  726. 

  727.     void deactivate() noexcept override

  728.     {

  729.         CARLA_SAFE_ASSERT_RETURN(fInstance != nullptr,);

  730. 

  731.         try {

  732.             fInstance->releaseResources();

  733.         } catch(...) {}

  734.     }

  735. 

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

  737.     {

  738.         // --------------------------------------------------------------------------------------------------------

  739.         // Check if active

  740. 

  741.         if (! pData->active)

  742.         {

  743.             // disable any output sound

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

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

  746.             return;

  747.         }

  748. 

  749.         // --------------------------------------------------------------------------------------------------------

  750.         // Check if needs reset

  751. 

  752.         if (pData->needsReset)

  753.         {

  754.             fInstance->reset();

  755.             pData->needsReset = false;

  756.         }

  757. 

  758.         // --------------------------------------------------------------------------------------------------------

  759.         // Event Input

  760. 

  761.         fMidiBuffer.clear();

  762. 

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

  764.         {

  765.             // ----------------------------------------------------------------------------------------------------

  766.             // MIDI Input (External)

  767. 

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

  769.             {

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

  771.                 {

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

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

  774. 

  775.                     uint8_t midiEvent[3];

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

  777.                     midiEvent[1] = note.note;

  778.                     midiEvent[2] = note.velo;

  779. 

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

  781.                 }

  782. 

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

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

  785. 

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

  787. 

  788.             // ----------------------------------------------------------------------------------------------------

  789.             // Event Input (System)

  790. 

  791. #ifndef BUILD_BRIDGE

  792.             bool allNotesOffSent = false;

  793. #endif

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

  795.             {

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

  797. 

  798.                 if (event.time >= frames)

  799.                     continue;

  800. 

  801.                 switch (event.type)

  802.                 {

  803.                 case kEngineEventTypeNull:

  804.                     break;

  805. 

  806.                 case kEngineEventTypeControl: {

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

  808. 

  809.                     switch (ctrlEvent.type)

  810.                     {

  811.                     case kEngineControlEventTypeNull:

  812.                         break;

  813. 

  814.                     case kEngineControlEventTypeParameter: {

  815. #ifndef BUILD_BRIDGE

  816.                         // Control backend stuff

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

  818.                         {

  819.                             float value;

  820. 

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

  822.                             {

  823.                                 value = ctrlEvent.value;

  824.                                 setDryWetRT(value);

  825.                             }

  826. 

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

  828.                             {

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

  830.                                 setVolumeRT(value);

  831.                             }

  832. 

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

  834.                             {

  835.                                 float left, right;

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

  837. 

  838.                                 if (value < 0.0f)

  839.                                 {

  840.                                     left  = -1.0f;

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

  842.                                 }

  843.                                 else if (value > 0.0f)

  844.                                 {

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

  846.                                     right = 1.0f;

  847.                                 }

  848.                                 else

  849.                                 {

  850.                                     left  = -1.0f;

  851.                                     right = 1.0f;

  852.                                 }

  853. 

  854.                                 setBalanceLeftRT(left);

  855.                                 setBalanceRightRT(right);

  856.                             }

  857.                         }

  858. #endif

  859.                         // Control plugin parameters

  860.                         uint32_t k;

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

  862.                         {

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

  864.                                 continue;

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

  866.                                 continue;

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

  868.                                 continue;

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

  870.                                 continue;

  871. 

  872.                             float value;

  873. 

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

  875.                             {

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

  877.                             }

  878.                             else

  879.                             {

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

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

  882.                                 else

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

  884. 

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

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

  887.                             }

  888. 

  889.                             setParameterValueRT(k, value);

  890.                         }

  891. 

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

  893.                         {

  894.                             uint8_t midiData[3];

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

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

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

  898. 

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

  900.                         }

  901. 

  902.                         break;

  903.                     } // case kEngineControlEventTypeParameter

  904. 

  905.                     case kEngineControlEventTypeMidiBank:

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

  907.                         {

  908.                             uint8_t midiData[3];

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

  910.                             midiData[1] = MIDI_CONTROL_BANK_SELECT; 

  911.                             midiData[2] = 0;

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

  913. 

  914.                             midiData[1] = MIDI_CONTROL_BANK_SELECT__LSB;

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

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

  917.                         }

  918.                         break;

  919. 

  920.                     case kEngineControlEventTypeMidiProgram:

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

  922.                         {

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

  924.                             {

  925.                                 setProgramRT(ctrlEvent.param);

  926.                             }

  927.                         }

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

  929.                         {

  930.                             uint8_t midiData[3];

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

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

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

  934.                         }

  935.                         break;

  936. 

  937.                     case kEngineControlEventTypeAllSoundOff:

  938.                         if (pData->options & PLUGIN_OPTION_SEND_ALL_SOUND_OFF)

  939.                         {

  940.                             uint8_t midiData[3];

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

  942.                             midiData[1] = MIDI_CONTROL_ALL_SOUND_OFF;

  943.                             midiData[2] = 0;

  944. 

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

  946.                         }

  947.                         break;

  948. 

  949.                     case kEngineControlEventTypeAllNotesOff:

  950.                         if (pData->options & PLUGIN_OPTION_SEND_ALL_SOUND_OFF)

  951.                         {

  952. #ifndef BUILD_BRIDGE

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

  954.                             {

  955.                                 allNotesOffSent = true;

  956.                                 postponeRtAllNotesOff();

  957.                             }

  958. #endif

  959. 

  960.                             uint8_t midiData[3];

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

  962.                             midiData[1] = MIDI_CONTROL_ALL_NOTES_OFF;

  963.                             midiData[2] = 0;

  964. 

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

  966.                         }

  967.                         break;

  968.                     } // switch (ctrlEvent.type)

  969.                     break;

  970.                 } // case kEngineEventTypeControl

  971. 

  972.                 case kEngineEventTypeMidi: {

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

  974. 

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

  976. 

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

  978. 

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

  980.                         continue;

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

  982.                         continue;

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

  984.                         continue;

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

  986.                         continue;

  987. 

  988.                     // Fix bad note-off

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

  990.                         status = MIDI_STATUS_NOTE_OFF;

  991. 

  992.                     // put back channel in data

  993.                     uint8_t midiData2[midiEvent.size];

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

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

  996. 

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

  998. 

  999.                     if (status == MIDI_STATUS_NOTE_ON)

  1000.                     {

  1001.                         pData->postponeRtEvent(kPluginPostRtEventNoteOn,

  1002.                                                event.channel,

  1003.                                                midiData[1],

  1004.                                                midiData[2],

  1005.                                                0.0f);

  1006.                     }

  1007.                     else if (status == MIDI_STATUS_NOTE_OFF)

  1008.                     {

  1009.                         pData->postponeRtEvent(kPluginPostRtEventNoteOff,

  1010.                                                event.channel,

  1011.                                                midiData[1],

  1012.                                                0, 0.0f);

  1013.                     }

  1014.                 } break;

  1015.                 } // switch (event.type)

  1016.             }

  1017. 

  1018.             pData->postRtEvents.trySplice();

  1019. 

  1020.         } // End of Event Input

  1021. 

  1022.         // --------------------------------------------------------------------------------------------------------

  1023.         // Set TimeInfo

  1024. 

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

  1026. 

  1027.         fPosInfo.isPlaying = timeInfo.playing;

  1028. 

  1029.         if (timeInfo.bbt.valid)

  1030.         {

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

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

  1033. 

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

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

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

  1037. 

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

  1039. 

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

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

  1042. 

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

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

  1045. 

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

  1047.             fPosInfo.ppqPositionOfLastBarStart = ppqBar;

  1048.         }

  1049. 

  1050.         // --------------------------------------------------------------------------------------------------------

  1051.         // Process

  1052. 

  1053.         processSingle(audioIn, audioOut, frames);

  1054.     }

  1055. 

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

  1057.     {

  1058.         CARLA_SAFE_ASSERT_RETURN(frames > 0, false);

  1059. 

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

  1061.         {

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

  1063.         }

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

  1065.         {

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

  1067.         }

  1068. 

  1069.         // --------------------------------------------------------------------------------------------------------

  1070.         // Try lock, silence otherwise

  1071. 

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

  1073.         {

  1074.             pData->singleMutex.lock();

  1075.         }

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

  1077.         {

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

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

  1080.             return false;

  1081.         }

  1082. 

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

  1084.         // Set audio in buffers

  1085. 

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

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

  1088. 

  1089.         // --------------------------------------------------------------------------------------------------------

  1090.         // Run plugin

  1091. 

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

  1093. 

  1094.         // --------------------------------------------------------------------------------------------------------

  1095.         // Set audio out buffers

  1096. 

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

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

  1099. 

  1100.         // --------------------------------------------------------------------------------------------------------

  1101.         // Midi out

  1102. 

  1103.         if (! fMidiBuffer.isEmpty())

  1104.         {

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

  1106.             {

  1107.                 const uint8_t* midiEventData;

  1108.                 int midiEventSize, midiEventPosition;

  1109. 

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

  1111.                 {

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

  1113.                     CARLA_SAFE_ASSERT_BREAK(midiEventSize > 0);

  1114. 

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

  1116.                         break;

  1117.                 }

  1118.             }

  1119. 

  1120.             fMidiBuffer.clear();

  1121.         }

  1122. 

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

  1124. 

  1125.         pData->singleMutex.unlock();

  1126.         return true;

  1127.     }

  1128. 

  1129.     void bufferSizeChanged(const uint32_t newBufferSize) override

  1130.     {

  1131.         CARLA_ASSERT_INT(newBufferSize > 0, newBufferSize);

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

  1133. 

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

  1135. 

  1136.         if (pData->active)

  1137.         {

  1138.             deactivate();

  1139.             activate();

  1140.         }

  1141.     }

  1142. 

  1143.     void sampleRateChanged(const double newSampleRate) override

  1144.     {

  1145.         CARLA_ASSERT_INT(newSampleRate > 0.0, newSampleRate);

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

  1147. 

  1148.         if (pData->active)

  1149.         {

  1150.             deactivate();

  1151.             activate();

  1152.         }

  1153.     }

  1154. 

  1155.     // -------------------------------------------------------------------

  1156.     // Plugin buffers

  1157. 

  1158.     // nothing

  1159. 

  1160.     // -------------------------------------------------------------------

  1161.     // Post-poned UI Stuff

  1162. 

  1163.     // nothing

  1164. 

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

  1166. 

  1167.     void* getNativeHandle() const noexcept override

  1168.     {

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

  1170.     }

  1171. 

  1172.     // -------------------------------------------------------------------

  1173. 

  1174. protected:

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

  1176.     {

  1177.         CARLA_SAFE_ASSERT_RETURN(index >= 0,);

  1178. 

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

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

  1181. 

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

  1183.     }

  1184. 

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

  1186.     {

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

  1188.     }

  1189. 

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

  1191.     {

  1192.         CARLA_SAFE_ASSERT_RETURN(index >= 0,);

  1193. 

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

  1195.     }

  1196. 

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

  1198.     {

  1199.         CARLA_SAFE_ASSERT_RETURN(index >= 0,);

  1200. 

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

  1202.     }

  1203. 

  1204.     bool getCurrentPosition(CurrentPositionInfo& result) override

  1205.     {

  1206.         carla_copyStruct(result, fPosInfo);

  1207.         return true;

  1208.     }

  1209. 

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

  1211. 

  1212. public:

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

  1214.     {

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

  1216. 

  1217.         // ---------------------------------------------------------------

  1218.         // first checks

  1219. 

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

  1221.         {

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

  1223.             return false;

  1224.         }

  1225. 

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

  1227.         {

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

  1229.             return false;

  1230.         }

  1231. 

  1232.         // AU and VST3 require label

  1233.         if (std::strcmp(format, "AU") == 0 || std::strcmp(format, "VST3") == 0)

  1234.         {

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

  1236.             {

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

  1238.                 return false;

  1239.             }

  1240.         }

  1241. 

  1242.         juce::String fileOrIdentifier;

  1243. 

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

  1245.         {

  1246.             fileOrIdentifier = label;

  1247.         }

  1248.         else

  1249.         {

  1250.             // VST2 and VST3 require filename

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

  1252.             {

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

  1254.                 return false;

  1255.             }

  1256. 

  1257.             juce::String jfilename(filename);

  1258. 

  1259. #ifdef CARLA_OS_WIN

  1260.             // Fix for wine usage

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

  1262.             {

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

  1264.                 jfilename = "Z:" + jfilename;

  1265.             }

  1266. #endif

  1267. 

  1268.             fileOrIdentifier = jfilename;

  1269. 

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

  1271.                 fDesc.name = label;

  1272.         }

  1273. 

  1274.         fFormatManager.addDefaultFormats();

  1275. 

  1276.         {

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

  1278.             juce::KnownPluginList plist;

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

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

  1281. 

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

  1283.             {

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

  1285.                 return false;

  1286.             }

  1287. 

  1288.             fDesc = *pluginDescriptions[0];

  1289.         }

  1290. 

  1291.         if (uniqueId != 0)

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

  1293. 

  1294.         juce::String error;

  1295.         fInstance = fFormatManager.createPluginInstance(fDesc,

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

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

  1298.                                                         error);

  1299. 

  1300.         if (fInstance == nullptr)

  1301.         {

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

  1303.             return false;

  1304.         }

  1305. 

  1306.         fInstance->fillInPluginDescription(fDesc);

  1307.         fInstance->setPlayHead(this);

  1308.         fInstance->addListener(this);

  1309. 

  1310.         fFormatName = format;

  1311. 

  1312.         // ---------------------------------------------------------------

  1313.         // get info

  1314. 

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

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

  1317.         else

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

  1319. 

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

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

  1322. 

  1323.         // ---------------------------------------------------------------

  1324.         // register client

  1325. 

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

  1327. 

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

  1329.         {

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

  1331.             return false;

  1332.         }

  1333. 

  1334.         // ---------------------------------------------------------------

  1335.         // set default options

  1336. 

  1337.         pData->options  = 0x0;

  1338.         pData->options |= PLUGIN_OPTION_FIXED_BUFFERS;

  1339.         pData->options |= PLUGIN_OPTION_USE_CHUNKS;

  1340. 

  1341.         if (fInstance->acceptsMidi())

  1342.         {

  1343.             pData->options |= PLUGIN_OPTION_SEND_CHANNEL_PRESSURE;

  1344.             pData->options |= PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH;

  1345.             pData->options |= PLUGIN_OPTION_SEND_PITCHBEND;

  1346.             pData->options |= PLUGIN_OPTION_SEND_ALL_SOUND_OFF;

  1347. 

  1348.             if (options & PLUGIN_OPTION_SEND_CONTROL_CHANGES)

  1349.                 pData->options |= PLUGIN_OPTION_SEND_CONTROL_CHANGES;

  1350. 

  1351.             if (options & PLUGIN_OPTION_SEND_PROGRAM_CHANGES)

  1352.                 pData->options |= PLUGIN_OPTION_SEND_PROGRAM_CHANGES;   

  1353.         }

  1354. 

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

  1356.             pData->options |= PLUGIN_OPTION_MAP_PROGRAM_CHANGES;

  1357. 

  1358.         return true;

  1359.     }

  1360. 

  1361. private:

  1362.     juce::PluginDescription    fDesc;

  1363.     juce::AudioPluginInstance* fInstance;

  1364.     juce::AudioPluginFormatManager fFormatManager;

  1365. 

  1366.     juce::AudioSampleBuffer fAudioBuffer;

  1367.     juce::MidiBuffer        fMidiBuffer;

  1368.     CurrentPositionInfo     fPosInfo;

  1369.     juce::MemoryBlock       fChunk;

  1370.     juce::String            fFormatName;

  1371. 

  1372.     ScopedPointer<JucePluginWindow> fWindow;

  1373. 

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

  1375.     {

  1376.         if (fFormatName != "VST2")

  1377.             return true;

  1378.         if (dataSize < 160)

  1379.             return false;

  1380. 

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

  1382. 

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

  1384.             return false;

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

  1386.             return false;

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

  1388.             return false;

  1389. 

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

  1391. 

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

  1393.     }

  1394. 

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

  1396.     {

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

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

  1399.     }

  1400. 

  1401.     static int32_t fxbSwap(const int32_t x) noexcept

  1402.     {

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

  1404.     }

  1405. 

  1406.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaPluginJuce)

  1407. };

  1408. 

  1409. CARLA_BACKEND_END_NAMESPACE

  1410. 

  1411. #endif // USING_JUCE

  1412. 

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

  1414. 

  1415. CARLA_BACKEND_START_NAMESPACE

  1416. 

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

  1418. {

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

  1420. 

  1421. #ifdef USING_JUCE

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

  1423. 

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

  1425.     {

  1426.         delete plugin;

  1427.         return nullptr;

  1428.     }

  1429. 

  1430.     return plugin;

  1431. #else

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

  1433.     return nullptr;

  1434. 

  1435.     // unused

  1436.     (void)format;

  1437. #endif

  1438. }

  1439. 

  1440. CARLA_BACKEND_END_NAMESPACE

  1441. 

  1442. // -------------------------------------------------------------------------------------------------------------------