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.
2476 Commits
16 Branches
210MB
Tree: c0d40ed9ae
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'c0d40ed9ae'
${ noResults }
Carla/source/backend/engine/CarlaEngineNative.cpp

1946 lines
66KB
Raw Blame History 

  1. /*

  2.  * Carla Plugin Host

  3.  * Copyright (C) 2011-2014 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 "CarlaDefines.h"

  19. 

  20. #ifdef BUILD_BRIDGE

  21. # error This file should not be compiled if building bridge

  22. #endif

  23. #ifdef CARLA_OS_WIN

  24. # error This file should not be compiled for Windows

  25. #endif

  26. 

  27. #include "CarlaEngineInternal.hpp"

  28. #include "CarlaPlugin.hpp"

  29. 

  30. #include "CarlaBackendUtils.hpp"

  31. #include "CarlaBase64Utils.hpp"

  32. #include "CarlaBinaryUtils.hpp"

  33. #include "CarlaMathUtils.hpp"

  34. #include "CarlaStateUtils.hpp"

  35. 

  36. #include "CarlaExternalUI.hpp"

  37. #include "CarlaNative.hpp"

  38. 

  39. #include "juce_audio_basics.h"

  40. 

  41. #if defined(CARLA_OS_MAC) || defined(CARLA_OS_WIN)

  42. # include "juce_gui_basics.h"

  43. #else

  44. namespace juce {

  45. # include "juce_events/messages/juce_Initialisation.h"

  46. } // namespace juce

  47. #endif

  48. 

  49. using juce::File;

  50. using juce::FloatVectorOperations;

  51. using juce::MemoryOutputStream;

  52. using juce::ScopedPointer;

  53. using juce::String;

  54. using juce::XmlDocument;

  55. using juce::XmlElement;

  56. 

  57. static bool gNeedsJuceHandling = false;

  58. static int  gJuceReferenceCounter = 0;

  59. 

  60. CARLA_BACKEND_START_NAMESPACE

  61. 

  62. // -----------------------------------------------------------------------

  63. 

  64. class CarlaEngineNativeUI : public CarlaExternalUI

  65. {

  66. public:

  67.     CarlaEngineNativeUI(CarlaEngine* const engine)

  68.         : fEngine(engine),

  69.           leakDetector_CarlaEngineNativeUI()

  70.     {

  71.         carla_debug("CarlaEngineNativeUI::CarlaEngineNativeUI(%p)", engine);

  72.     }

  73. 

  74.     ~CarlaEngineNativeUI() override

  75.     {

  76.         carla_debug("CarlaEngineNativeUI::~CarlaEngineNativeUI()");

  77.     }

  78. 

  79.     void show() noexcept

  80.     {

  81.         const CarlaMutexLocker cml(getLock());

  82.         writeMsg("show\n", 5);

  83.     }

  84. 

  85. protected:

  86.     bool msgReceived(const char* const msg) noexcept override

  87.     {

  88.         if (CarlaExternalUI::msgReceived(msg))

  89.             return true;

  90. 

  91.         bool ok = true;

  92. 

  93.         if (std::strcmp(msg, "set_engine_option") == 0)

  94.         {

  95.             uint32_t option;

  96.             int32_t value;

  97.             const char* valueStr = nullptr;

  98. 

  99.             CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(option), true);

  100.             CARLA_SAFE_ASSERT_RETURN(readNextLineAsInt(value), true);

  101.             readNextLineAsString(valueStr); // can be null

  102. 

  103.             try {

  104.                 fEngine->setOption(static_cast<EngineOption>(option), value, valueStr);

  105.             } CARLA_SAFE_EXCEPTION("setOption");

  106. 

  107.             if (valueStr != nullptr)

  108.                 delete[] valueStr;

  109.         }

  110.         else if (std::strcmp(msg, "load_file") == 0)

  111.         {

  112.             const char* filename;

  113. 

  114.             CARLA_SAFE_ASSERT_RETURN(readNextLineAsString(filename), true);

  115. 

  116.             try {

  117.                 ok = fEngine->loadFile(filename);

  118.             } CARLA_SAFE_EXCEPTION("loadFile");

  119. 

  120.             delete[] filename;

  121.         }

  122.         else if (std::strcmp(msg, "load_project") == 0)

  123.         {

  124.             const char* filename;

  125. 

  126.             CARLA_SAFE_ASSERT_RETURN(readNextLineAsString(filename), true);

  127. 

  128.             try {

  129.                 ok = fEngine->loadProject(filename);

  130.             } CARLA_SAFE_EXCEPTION("loadProject");

  131. 

  132.             delete[] filename;

  133.         }

  134.         else if (std::strcmp(msg, "save_project") == 0)

  135.         {

  136.             const char* filename;

  137. 

  138.             CARLA_SAFE_ASSERT_RETURN(readNextLineAsString(filename), true);

  139. 

  140.             try {

  141.                 ok = fEngine->saveProject(filename);

  142.             } CARLA_SAFE_EXCEPTION("saveProject");

  143. 

  144.             delete[] filename;

  145.         }

  146.         else if (std::strcmp(msg, "patchbay_connect") == 0)

  147.         {

  148.             uint32_t groupA, portA, groupB, portB;

  149. 

  150.             CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(groupA), true);

  151.             CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(portA), true);

  152.             CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(groupB), true);

  153.             CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(portB), true);

  154. 

  155.             try {

  156.                 ok = fEngine->patchbayConnect(groupA, portA, groupB, portB);

  157.             } CARLA_SAFE_EXCEPTION("patchbayConnect");

  158.         }

  159.         else if (std::strcmp(msg, "patchbay_disconnect") == 0)

  160.         {

  161.             uint32_t connectionId;

  162. 

  163.             CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(connectionId), true);

  164. 

  165.             try {

  166.                 ok = fEngine->patchbayDisconnect(connectionId);

  167.             } CARLA_SAFE_EXCEPTION("patchbayDisconnect");

  168.         }

  169.         else if (std::strcmp(msg, "patchbay_refresh") == 0)

  170.         {

  171.             try {

  172.                 ok = fEngine->patchbayRefresh(false);

  173.             } CARLA_SAFE_EXCEPTION("patchbayRefresh");

  174.         }

  175.         else if (std::strcmp(msg, "transport_play") == 0)

  176.         {

  177.             fEngine->transportPlay();

  178.         }

  179.         else if (std::strcmp(msg, "transport_pause") == 0)

  180.         {

  181.             fEngine->transportPause();

  182.         }

  183.         else if (std::strcmp(msg, "transport_relocate") == 0)

  184.         {

  185.             uint64_t frame;

  186. 

  187.             CARLA_SAFE_ASSERT_RETURN(readNextLineAsULong(frame), true);

  188. 

  189.             fEngine->transportRelocate(frame);

  190.         }

  191.         else if (std::strcmp(msg, "add_plugin") == 0)

  192.         {

  193.             uint32_t btype, ptype;

  194.             const char* filename = nullptr;

  195.             const char* name;

  196.             const char* label;

  197.             int64_t uniqueId;

  198. 

  199.             CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(btype), true);

  200.             CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(ptype), true);

  201.             readNextLineAsString(filename); // can be null

  202.             CARLA_SAFE_ASSERT_RETURN(readNextLineAsString(name), true);

  203.             CARLA_SAFE_ASSERT_RETURN(readNextLineAsString(label), true);

  204.             CARLA_SAFE_ASSERT_RETURN(readNextLineAsLong(uniqueId), true);

  205. 

  206.             if (filename != nullptr && std::strcmp(filename, "(null)") == 0)

  207.             {

  208.                 delete[] filename;

  209.                 filename = nullptr;

  210.             }

  211. 

  212.             if (std::strcmp(name, "(null)") == 0)

  213.             {

  214.                 delete[] name;

  215.                 name = nullptr;

  216.             }

  217. 

  218.             ok = fEngine->addPlugin(static_cast<BinaryType>(btype), static_cast<PluginType>(ptype), filename, name, label, uniqueId, nullptr);

  219. 

  220.             if (filename != nullptr)

  221.                 delete[] filename;

  222.             if (name != nullptr)

  223.                 delete[] name;

  224.             delete[] label;

  225.         }

  226.         else if (std::strcmp(msg, "remove_plugin") == 0)

  227.         {

  228.             uint32_t pluginId;

  229. 

  230.             CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(pluginId), true);

  231. 

  232.             ok = fEngine->removePlugin(pluginId);

  233.         }

  234.         else if (std::strcmp(msg, "remove_all_plugins") == 0)

  235.         {

  236.             ok = fEngine->removeAllPlugins();

  237.         }

  238.         else if (std::strcmp(msg, "rename_plugin") == 0)

  239.         {

  240.             uint32_t pluginId;

  241.             const char* newName;

  242. 

  243.             CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(pluginId), true);

  244.             CARLA_SAFE_ASSERT_RETURN(readNextLineAsString(newName), true);

  245. 

  246.             // TODO

  247.             /*const char* name =*/ fEngine->renamePlugin(pluginId, newName);

  248. 

  249.             delete[] newName;

  250.         }

  251.         else if (std::strcmp(msg, "clone_plugin") == 0)

  252.         {

  253.             uint32_t pluginId;

  254. 

  255.             CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(pluginId), true);

  256. 

  257.             ok = fEngine->clonePlugin(pluginId);

  258.         }

  259.         else if (std::strcmp(msg, "replace_plugin") == 0)

  260.         {

  261.             uint32_t pluginId;

  262. 

  263.             CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(pluginId), true);

  264. 

  265.             ok = fEngine->replacePlugin(pluginId);

  266.         }

  267.         else if (std::strcmp(msg, "switch_plugins") == 0)

  268.         {

  269.             uint32_t pluginIdA, pluginIdB;

  270. 

  271.             CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(pluginIdA), true);

  272.             CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(pluginIdB), true);

  273. 

  274.             ok = fEngine->switchPlugins(pluginIdA, pluginIdB);

  275.         }

  276.         else if (std::strcmp(msg, "load_plugin_state") == 0)

  277.         {

  278.             uint32_t pluginId;

  279.             const char* filename;

  280. 

  281.             CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(pluginId), true);

  282.             CARLA_SAFE_ASSERT_RETURN(readNextLineAsString(filename), true);

  283. 

  284.             if (CarlaPlugin* const plugin = fEngine->getPlugin(pluginId))

  285.                 plugin->loadStateFromFile(filename);

  286. 

  287.             delete[] filename;

  288.         }

  289.         else if (std::strcmp(msg, "save_plugin_state") == 0)

  290.         {

  291.             uint32_t pluginId;

  292.             const char* filename;

  293. 

  294.             CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(pluginId), true);

  295.             CARLA_SAFE_ASSERT_RETURN(readNextLineAsString(filename), true);

  296. 

  297.             if (CarlaPlugin* const plugin = fEngine->getPlugin(pluginId))

  298.                 plugin->saveStateToFile(filename);

  299. 

  300.             delete[] filename;

  301.         }

  302.         else if (std::strcmp(msg, "set_option") == 0)

  303.         {

  304.             uint32_t pluginId, option;

  305.             bool yesNo;

  306. 

  307.             CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(pluginId), true);

  308.             CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(option), true);

  309.             CARLA_SAFE_ASSERT_RETURN(readNextLineAsBool(yesNo), true);

  310. 

  311.             if (CarlaPlugin* const plugin = fEngine->getPlugin(pluginId))

  312.                 plugin->setOption(option, yesNo, false);

  313.         }

  314.         else if (std::strcmp(msg, "set_active") == 0)

  315.         {

  316.             uint32_t pluginId;

  317.             bool onOff;

  318. 

  319.             CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(pluginId), true);

  320.             CARLA_SAFE_ASSERT_RETURN(readNextLineAsBool(onOff), true);

  321. 

  322.             if (CarlaPlugin* const plugin = fEngine->getPlugin(pluginId))

  323.                 plugin->setActive(onOff, true, false);

  324.         }

  325.         else if (std::strcmp(msg, "set_drywet") == 0)

  326.         {

  327.             uint32_t pluginId;

  328.             float value;

  329. 

  330.             CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(pluginId), true);

  331.             CARLA_SAFE_ASSERT_RETURN(readNextLineAsFloat(value), true);

  332. 

  333.             if (CarlaPlugin* const plugin = fEngine->getPlugin(pluginId))

  334.                 plugin->setDryWet(value, true, false);

  335.         }

  336.         else if (std::strcmp(msg, "set_volume") == 0)

  337.         {

  338.             uint32_t pluginId;

  339.             float value;

  340. 

  341.             CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(pluginId), true);

  342.             CARLA_SAFE_ASSERT_RETURN(readNextLineAsFloat(value), true);

  343. 

  344.             if (CarlaPlugin* const plugin = fEngine->getPlugin(pluginId))

  345.                 plugin->setVolume(value, true, false);

  346.         }

  347.         else if (std::strcmp(msg, "set_balance_left") == 0)

  348.         {

  349.             uint32_t pluginId;

  350.             float value;

  351. 

  352.             CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(pluginId), true);

  353.             CARLA_SAFE_ASSERT_RETURN(readNextLineAsFloat(value), true);

  354. 

  355.             if (CarlaPlugin* const plugin = fEngine->getPlugin(pluginId))

  356.                 plugin->setBalanceLeft(value, true, false);

  357.         }

  358.         else if (std::strcmp(msg, "set_balance_right") == 0)

  359.         {

  360.             uint32_t pluginId;

  361.             float value;

  362. 

  363.             CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(pluginId), true);

  364.             CARLA_SAFE_ASSERT_RETURN(readNextLineAsFloat(value), true);

  365. 

  366.             if (CarlaPlugin* const plugin = fEngine->getPlugin(pluginId))

  367.                 plugin->setBalanceRight(value, true, false);

  368.         }

  369.         else if (std::strcmp(msg, "set_panning") == 0)

  370.         {

  371.             uint32_t pluginId;

  372.             float value;

  373. 

  374.             CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(pluginId), true);

  375.             CARLA_SAFE_ASSERT_RETURN(readNextLineAsFloat(value), true);

  376. 

  377.             if (CarlaPlugin* const plugin = fEngine->getPlugin(pluginId))

  378.                 plugin->setPanning(value, true, false);

  379.         }

  380.         else if (std::strcmp(msg, "set_ctrl_channel") == 0)

  381.         {

  382.             uint32_t pluginId;

  383.             int32_t channel;

  384. 

  385.             CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(pluginId), true);

  386.             CARLA_SAFE_ASSERT_RETURN(readNextLineAsInt(channel), true);

  387.             CARLA_SAFE_ASSERT_RETURN(channel >= -1 && channel < MAX_MIDI_CHANNELS, true);

  388. 

  389.             if (CarlaPlugin* const plugin = fEngine->getPlugin(pluginId))

  390.                 plugin->setCtrlChannel(int8_t(channel), true, false);

  391.         }

  392.         else if (std::strcmp(msg, "set_parameter_value") == 0)

  393.         {

  394.             uint32_t pluginId, parameterId;

  395.             float value;

  396. 

  397.             CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(pluginId), true);

  398.             CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(parameterId), true);

  399.             CARLA_SAFE_ASSERT_RETURN(readNextLineAsFloat(value), true);

  400. 

  401.             if (CarlaPlugin* const plugin = fEngine->getPlugin(pluginId))

  402.                 plugin->setParameterValue(parameterId, value, true, true, false);

  403.         }

  404.         else if (std::strcmp(msg, "set_parameter_midi_channel") == 0)

  405.         {

  406.             uint32_t pluginId, parameterId, channel;

  407. 

  408.             CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(pluginId), true);

  409.             CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(parameterId), true);

  410.             CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(channel), true);

  411.             CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS, true);

  412. 

  413.             if (CarlaPlugin* const plugin = fEngine->getPlugin(pluginId))

  414.                 plugin->setParameterMidiChannel(parameterId, static_cast<uint8_t>(channel), true, false);

  415.         }

  416.         else if (std::strcmp(msg, "set_parameter_midi_cc") == 0)

  417.         {

  418.             uint32_t pluginId, parameterId;

  419.             int32_t cc;

  420. 

  421.             CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(pluginId), true);

  422.             CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(parameterId), true);

  423.             CARLA_SAFE_ASSERT_RETURN(readNextLineAsInt(cc), true);

  424.             CARLA_SAFE_ASSERT_RETURN(cc >= -1 && cc < MAX_MIDI_CONTROL, true);

  425. 

  426.             if (CarlaPlugin* const plugin = fEngine->getPlugin(pluginId))

  427.                 plugin->setParameterMidiCC(parameterId, static_cast<int16_t>(cc), true, false);

  428.         }

  429.         else if (std::strcmp(msg, "set_program") == 0)

  430.         {

  431.             uint32_t pluginId;

  432.             int32_t index;

  433. 

  434.             CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(pluginId), true);

  435.             CARLA_SAFE_ASSERT_RETURN(readNextLineAsInt(index), true);

  436. 

  437.             if (CarlaPlugin* const plugin = fEngine->getPlugin(pluginId))

  438.                 plugin->setProgram(index, true, true, false);

  439.         }

  440.         else if (std::strcmp(msg, "set_midi_program") == 0)

  441.         {

  442.             uint32_t pluginId;

  443.             int32_t index;

  444. 

  445.             CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(pluginId), true);

  446.             CARLA_SAFE_ASSERT_RETURN(readNextLineAsInt(index), true);

  447. 

  448.             if (CarlaPlugin* const plugin = fEngine->getPlugin(pluginId))

  449.                 plugin->setMidiProgram(index, true, true, false);

  450.         }

  451.         else if (std::strcmp(msg, "set_custom_data") == 0)

  452.         {

  453.             uint32_t pluginId;

  454.             const char* type;

  455.             const char* key;

  456.             const char* value;

  457. 

  458.             CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(pluginId), true);

  459.             CARLA_SAFE_ASSERT_RETURN(readNextLineAsString(type), true);

  460.             CARLA_SAFE_ASSERT_RETURN(readNextLineAsString(key), true);

  461.             CARLA_SAFE_ASSERT_RETURN(readNextLineAsString(value), true);

  462. 

  463.             if (CarlaPlugin* const plugin = fEngine->getPlugin(pluginId))

  464.                 plugin->setCustomData(type, key, value, true);

  465. 

  466.             delete[] type;

  467.             delete[] key;

  468.             delete[] value;

  469.         }

  470.         else if (std::strcmp(msg, "set_chunk_data") == 0)

  471.         {

  472.             uint32_t pluginId;

  473.             const char* cdata;

  474. 

  475.             CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(pluginId), true);

  476.             CARLA_SAFE_ASSERT_RETURN(readNextLineAsString(cdata), true);

  477. 

  478.             if (CarlaPlugin* const plugin = fEngine->getPlugin(pluginId))

  479.             {

  480.                 std::vector<uint8_t> chunk(carla_getChunkFromBase64String(cdata));

  481.                 plugin->setChunkData(chunk.data(), chunk.size());

  482.             }

  483. 

  484.             delete[] cdata;

  485.         }

  486.         else if (std::strcmp(msg, "prepare_for_save") == 0)

  487.         {

  488.             uint32_t pluginId;

  489. 

  490.             CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(pluginId), true);

  491. 

  492.             if (CarlaPlugin* const plugin = fEngine->getPlugin(pluginId))

  493.                 plugin->prepareForSave();

  494.         }

  495.         else if (std::strcmp(msg, "reset_parameters") == 0)

  496.         {

  497.             uint32_t pluginId;

  498. 

  499.             CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(pluginId), true);

  500. 

  501.             if (CarlaPlugin* const plugin = fEngine->getPlugin(pluginId))

  502.                 plugin->resetParameters();

  503.         }

  504.         else if (std::strcmp(msg, "randomize_parameters") == 0)

  505.         {

  506.             uint32_t pluginId;

  507. 

  508.             CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(pluginId), true);

  509. 

  510.             if (CarlaPlugin* const plugin = fEngine->getPlugin(pluginId))

  511.                 plugin->randomizeParameters();

  512.         }

  513.         else if (std::strcmp(msg, "send_midi_note") == 0)

  514.         {

  515.             uint32_t pluginId, channel, note, velocity;

  516. 

  517.             CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(pluginId), true);

  518.             CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(channel), true);

  519.             CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(note), true);

  520.             CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(velocity), true);

  521.             CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS, true);

  522.             CARLA_SAFE_ASSERT_RETURN(note < MAX_MIDI_VALUE, true);

  523.             CARLA_SAFE_ASSERT_RETURN(velocity < MAX_MIDI_VALUE, true);

  524. 

  525.             if (CarlaPlugin* const plugin = fEngine->getPlugin(pluginId))

  526.                 plugin->sendMidiSingleNote(static_cast<uint8_t>(channel), static_cast<uint8_t>(note), static_cast<uint8_t>(velocity), true, true, false);

  527.         }

  528.         else if (std::strcmp(msg, "show_custom_ui") == 0)

  529.         {

  530.             uint32_t pluginId;

  531.             bool yesNo;

  532. 

  533.             CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(pluginId), true);

  534.             CARLA_SAFE_ASSERT_RETURN(readNextLineAsBool(yesNo), true);

  535. 

  536.             if (CarlaPlugin* const plugin = fEngine->getPlugin(pluginId))

  537.                 plugin->showCustomUI(yesNo);

  538.         }

  539.         else

  540.         {

  541.             carla_stderr("msgReceived : %s", msg);

  542.             return false;

  543.         }

  544. 

  545.         if (! ok)

  546.         {

  547.             const CarlaMutexLocker cml(getLock());

  548.             writeMsg("error\n", 6);

  549.             writeAndFixMsg(fEngine->getLastError());

  550.         }

  551. 

  552.         return true;

  553.     }

  554. 

  555. private:

  556.     CarlaEngine* const fEngine;

  557. 

  558.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaEngineNativeUI)

  559. };

  560. 

  561. // -----------------------------------------------------------------------

  562. 

  563. class CarlaEngineNative : public CarlaEngine

  564. {

  565. public:

  566.     CarlaEngineNative(const NativeHostDescriptor* const host, const bool isPatchbay, const uint32_t channels = 2)

  567.         : CarlaEngine(),

  568.           pHost(host),

  569.           kIsPatchbay(isPatchbay),

  570.           fIsActive(false),

  571.           fIsRunning(false),

  572.           fUiServer(this),

  573.           fOptionsForced(false),

  574.           leakDetector_CarlaEngineNative()

  575.     {

  576.         carla_debug("CarlaEngineNative::CarlaEngineNative()");

  577. 

  578.         CARLA_SAFE_ASSERT_INT(gJuceReferenceCounter >= 0, gJuceReferenceCounter);

  579. 

  580.         if (gNeedsJuceHandling && ++gJuceReferenceCounter == 1)

  581.             juce::initialiseJuce_GUI();

  582. 

  583.         carla_zeroChar(fTmpBuf, STR_MAX+1);

  584. 

  585.         pData->bufferSize = pHost->get_buffer_size(pHost->handle);

  586.         pData->sampleRate = pHost->get_sample_rate(pHost->handle);

  587. 

  588.         // set-up engine

  589.         if (kIsPatchbay)

  590.         {

  591.             pData->options.processMode         = ENGINE_PROCESS_MODE_PATCHBAY;

  592.             pData->options.transportMode       = ENGINE_TRANSPORT_MODE_PLUGIN;

  593.             pData->options.forceStereo         = false;

  594.             pData->options.preferPluginBridges = false;

  595.             pData->options.preferUiBridges     = false;

  596.             init("Carla-Patchbay");

  597.             pData->graph.create(false, pData->sampleRate, pData->bufferSize, channels, channels);

  598.         }

  599.         else

  600.         {

  601.             CARLA_SAFE_ASSERT(channels == 2);

  602.             pData->options.processMode         = ENGINE_PROCESS_MODE_CONTINUOUS_RACK;

  603.             pData->options.transportMode       = ENGINE_TRANSPORT_MODE_PLUGIN;

  604.             pData->options.forceStereo         = true;

  605.             pData->options.preferPluginBridges = false;

  606.             pData->options.preferUiBridges     = false;

  607.             init("Carla-Rack");

  608.             pData->graph.create(true, pData->sampleRate, pData->bufferSize, 0, 0);

  609.         }

  610. 

  611.         if (pData->options.resourceDir != nullptr)

  612.             delete[] pData->options.resourceDir;

  613.         if (pData->options.binaryDir != nullptr)

  614.             delete[] pData->options.binaryDir;

  615. 

  616.         pData->options.resourceDir = carla_strdup(pHost->resourceDir);

  617.         pData->options.binaryDir   = carla_strdup(carla_get_library_folder());

  618. 

  619.         setCallback(_ui_server_callback, this);

  620.     }

  621. 

  622.     ~CarlaEngineNative() override

  623.     {

  624.         CARLA_SAFE_ASSERT(! fIsActive);

  625.         carla_debug("CarlaEngineNative::~CarlaEngineNative() - START");

  626. 

  627.         pData->aboutToClose = true;

  628.         fIsRunning = false;

  629. 

  630.         removeAllPlugins();

  631.         //runPendingRtEvents();

  632.         close();

  633. 

  634.         pData->graph.destroy();

  635. 

  636.         if (gNeedsJuceHandling && --gJuceReferenceCounter == 0)

  637.             juce::shutdownJuce_GUI();

  638. 

  639.         carla_debug("CarlaEngineNative::~CarlaEngineNative() - END");

  640.     }

  641. 

  642. protected:

  643.     // -------------------------------------

  644.     // CarlaEngine virtual calls

  645. 

  646.     bool init(const char* const clientName) override

  647.     {

  648.         carla_debug("CarlaEngineNative::init(\"%s\")", clientName);

  649. 

  650.         fIsRunning = true;

  651. 

  652.         if (! pData->init(clientName))

  653.         {

  654.             close();

  655.             setLastError("Failed to init internal data");

  656.             return false;

  657.         }

  658. 

  659.         pData->bufferSize = pHost->get_buffer_size(pHost->handle);

  660.         pData->sampleRate = pHost->get_sample_rate(pHost->handle);

  661. 

  662.         return true;

  663.     }

  664. 

  665.     bool close() override

  666.     {

  667.         fIsRunning = false;

  668.         CarlaEngine::close();

  669.         return true;

  670.     }

  671. 

  672.     bool isRunning() const noexcept override

  673.     {

  674.         return fIsRunning;

  675.     }

  676. 

  677.     bool isOffline() const noexcept override

  678.     {

  679.         return pHost->is_offline(pHost->handle);

  680.     }

  681. 

  682.     EngineType getType() const noexcept override

  683.     {

  684.         return kEngineTypePlugin;

  685.     }

  686. 

  687.     const char* getCurrentDriverName() const noexcept override

  688.     {

  689.         return "Plugin";

  690.     }

  691. 

  692.     // -------------------------------------------------------------------

  693. 

  694.     const char* renamePlugin(const uint id, const char* const newName) override

  695.     {

  696.         if (const char* const retName = CarlaEngine::renamePlugin(id, newName))

  697.         {

  698.             uiServerCallback(ENGINE_CALLBACK_PLUGIN_RENAMED, id, 0, 0, 0.0f, retName);

  699.             return retName;

  700.         }

  701. 

  702.         return nullptr;

  703.     }

  704. 

  705.     // -------------------------------------------------------------------

  706. 

  707.     void bufferSizeChanged(const uint32_t newBufferSize)

  708.     {

  709.         if (pData->bufferSize == newBufferSize)

  710.             return;

  711. 

  712.         {

  713.             const CarlaMutexLocker cml(fUiServer.getLock());

  714. 

  715.             fUiServer.writeAndFixMsg("buffer-size");

  716.             std::sprintf(fTmpBuf, "%i\n", newBufferSize);

  717.             fUiServer.writeMsg(fTmpBuf);

  718.         }

  719. 

  720.         pData->bufferSize = newBufferSize;

  721.         CarlaEngine::bufferSizeChanged(newBufferSize);

  722.     }

  723. 

  724.     void sampleRateChanged(const double newSampleRate)

  725.     {

  726.         if (carla_compareFloats(pData->sampleRate, newSampleRate))

  727.             return;

  728. 

  729.         {

  730.             const CarlaMutexLocker cml(fUiServer.getLock());

  731.             const ScopedLocale csl;

  732. 

  733.             fUiServer.writeAndFixMsg("sample-rate");

  734.             std::sprintf(fTmpBuf, "%f\n", newSampleRate);

  735.             fUiServer.writeMsg(fTmpBuf);

  736.         }

  737. 

  738.         pData->sampleRate = newSampleRate;

  739.         CarlaEngine::sampleRateChanged(newSampleRate);

  740.     }

  741. 

  742.     // -------------------------------------------------------------------

  743. 

  744.     void uiServerSendPluginInfo(CarlaPlugin* const plugin)

  745.     {

  746.         const CarlaMutexLocker cml(fUiServer.getLock());

  747. 

  748.         const uint pluginId(plugin->getId());

  749. 

  750.         std::sprintf(fTmpBuf, "PLUGIN_INFO_%i\n", pluginId);

  751.         fUiServer.writeMsg(fTmpBuf);

  752. 

  753.         std::sprintf(fTmpBuf, "%i:%i:%i:" P_INT64 ":%i:%i\n", plugin->getType(), plugin->getCategory(), plugin->getHints(), plugin->getUniqueId(), plugin->getOptionsAvailable(), plugin->getOptionsEnabled());

  754.         fUiServer.writeMsg(fTmpBuf);

  755. 

  756.         if (const char* const filename = plugin->getFilename())

  757.         {

  758.             std::sprintf(fTmpBuf, "%s", filename);

  759.             fUiServer.writeAndFixMsg(fTmpBuf);

  760.         }

  761.         else

  762.             fUiServer.writeMsg("\n");

  763. 

  764.         if (const char* const name = plugin->getName())

  765.         {

  766.             std::sprintf(fTmpBuf, "%s", name);

  767.             fUiServer.writeAndFixMsg(fTmpBuf);

  768.         }

  769.         else

  770.             fUiServer.writeMsg("\n");

  771. 

  772.         if (const char* const iconName = plugin->getIconName())

  773.         {

  774.             std::sprintf(fTmpBuf, "%s", iconName);

  775.             fUiServer.writeAndFixMsg(fTmpBuf);

  776.         }

  777.         else

  778.             fUiServer.writeMsg("\n");

  779. 

  780.         plugin->getRealName(fTmpBuf);

  781.         fUiServer.writeAndFixMsg(fTmpBuf);

  782. 

  783.         plugin->getLabel(fTmpBuf);

  784.         fUiServer.writeAndFixMsg(fTmpBuf);

  785. 

  786.         plugin->getMaker(fTmpBuf);

  787.         fUiServer.writeAndFixMsg(fTmpBuf);

  788. 

  789.         plugin->getCopyright(fTmpBuf);

  790.         fUiServer.writeAndFixMsg(fTmpBuf);

  791. 

  792.         std::sprintf(fTmpBuf, "AUDIO_COUNT_%i:%i:%i\n", pluginId, plugin->getAudioInCount(), plugin->getAudioOutCount());

  793.         fUiServer.writeMsg(fTmpBuf);

  794. 

  795.         std::sprintf(fTmpBuf, "MIDI_COUNT_%i:%i:%i\n", pluginId, plugin->getMidiInCount(), plugin->getMidiOutCount());

  796.         fUiServer.writeMsg(fTmpBuf);

  797.     }

  798. 

  799.     void uiServerSendPluginParameters(CarlaPlugin* const plugin)

  800.     {

  801.         const CarlaMutexLocker cml(fUiServer.getLock());

  802.         const ScopedLocale csl;

  803. 

  804.         const uint pluginId(plugin->getId());

  805. 

  806.         for (int32_t i=PARAMETER_ACTIVE; i>PARAMETER_MAX; --i)

  807.         {

  808.             std::sprintf(fTmpBuf, "PARAMVAL_%i:%i\n", pluginId, i);

  809.             fUiServer.writeMsg(fTmpBuf);

  810.             std::sprintf(fTmpBuf, "%f\n", plugin->getInternalParameterValue(i));

  811.             fUiServer.writeMsg(fTmpBuf);

  812.         }

  813. 

  814.         uint32_t ins, outs, count;

  815.         plugin->getParameterCountInfo(ins, outs);

  816.         count = plugin->getParameterCount();

  817.         std::sprintf(fTmpBuf, "PARAMETER_COUNT_%i:%i:%i:%i\n", pluginId, ins, outs, count);

  818.         fUiServer.writeMsg(fTmpBuf);

  819. 

  820.         for (uint32_t i=0; i<count; ++i)

  821.         {

  822.             const ParameterData& paramData(plugin->getParameterData(i));

  823.             const ParameterRanges& paramRanges(plugin->getParameterRanges(i));

  824. 

  825.             std::sprintf(fTmpBuf, "PARAMETER_DATA_%i:%i\n", pluginId, i);

  826.             fUiServer.writeMsg(fTmpBuf);

  827.             std::sprintf(fTmpBuf, "%i:%i:%i:%i\n", paramData.type, paramData.hints, paramData.midiChannel, paramData.midiCC);

  828.             fUiServer.writeMsg(fTmpBuf);

  829.             plugin->getParameterName(i, fTmpBuf);

  830.             fUiServer.writeAndFixMsg(fTmpBuf);

  831.             plugin->getParameterUnit(i, fTmpBuf);

  832.             fUiServer.writeAndFixMsg(fTmpBuf);

  833. 

  834.             std::sprintf(fTmpBuf, "PARAMETER_RANGES_%i:%i\n", pluginId, i);

  835.             fUiServer.writeMsg(fTmpBuf);

  836.             std::sprintf(fTmpBuf, "%f:%f:%f:%f:%f:%f\n", paramRanges.def, paramRanges.min, paramRanges.max, paramRanges.step, paramRanges.stepSmall, paramRanges.stepLarge);

  837.             fUiServer.writeMsg(fTmpBuf);

  838. 

  839.             std::sprintf(fTmpBuf, "PARAMVAL_%i:%i\n", pluginId, i);

  840.             fUiServer.writeMsg(fTmpBuf);

  841.             std::sprintf(fTmpBuf, "%f\n", plugin->getParameterValue(i));

  842.             fUiServer.writeMsg(fTmpBuf);

  843.         }

  844.     }

  845. 

  846.     void uiServerSendPluginPrograms(CarlaPlugin* const plugin)

  847.     {

  848.         const CarlaMutexLocker cml(fUiServer.getLock());

  849. 

  850.         const uint pluginId(plugin->getId());

  851. 

  852.         uint32_t count = plugin->getProgramCount();

  853.         std::sprintf(fTmpBuf, "PROGRAM_COUNT_%i:%i:%i\n", pluginId, count, plugin->getCurrentProgram());

  854.         fUiServer.writeMsg(fTmpBuf);

  855. 

  856.         for (uint32_t i=0; i<count; ++i)

  857.         {

  858.             std::sprintf(fTmpBuf, "PROGRAM_NAME_%i:%i\n", pluginId, i);

  859.             fUiServer.writeMsg(fTmpBuf);

  860.             plugin->getProgramName(i, fTmpBuf);

  861.             fUiServer.writeAndFixMsg(fTmpBuf);

  862.         }

  863. 

  864.         count = plugin->getMidiProgramCount();

  865.         std::sprintf(fTmpBuf, "MIDI_PROGRAM_COUNT_%i:%i:%i\n", pluginId, count, plugin->getCurrentMidiProgram());

  866.         fUiServer.writeMsg(fTmpBuf);

  867. 

  868.         for (uint32_t i=0; i<count; ++i)

  869.         {

  870.             std::sprintf(fTmpBuf, "MIDI_PROGRAM_DATA_%i:%i\n", pluginId, i);

  871.             fUiServer.writeMsg(fTmpBuf);

  872. 

  873.             const MidiProgramData& mpData(plugin->getMidiProgramData(i));

  874.             std::sprintf(fTmpBuf, "%i:%i\n", mpData.bank, mpData.program);

  875.             fUiServer.writeMsg(fTmpBuf);

  876.             std::sprintf(fTmpBuf, "%s", mpData.name);

  877.             fUiServer.writeAndFixMsg(fTmpBuf);

  878.         }

  879.     }

  880. 

  881.     void uiServerCallback(const EngineCallbackOpcode action, const uint pluginId, const int value1, const int value2, const float value3, const char* const valueStr)

  882.     {

  883.         if (! fIsRunning)

  884.             return;

  885.         if (! fUiServer.isRunning())

  886.             return;

  887. 

  888.         CarlaPlugin* plugin;

  889. 

  890.         switch (action)

  891.         {

  892.         case ENGINE_CALLBACK_RELOAD_INFO:

  893.             plugin = getPlugin(pluginId);

  894. 

  895.             if (plugin != nullptr && plugin->isEnabled())

  896.             {

  897.                 CARLA_SAFE_ASSERT_BREAK(plugin->getId() == pluginId);

  898.                 uiServerSendPluginInfo(plugin);

  899.             }

  900.             break;

  901. 

  902.         case ENGINE_CALLBACK_RELOAD_PARAMETERS:

  903.             plugin = getPlugin(pluginId);

  904. 

  905.             if (plugin != nullptr && plugin->isEnabled())

  906.             {

  907.                 CARLA_SAFE_ASSERT_BREAK(plugin->getId() == pluginId);

  908.                 uiServerSendPluginParameters(plugin);

  909.             }

  910.             break;

  911. 

  912.         case ENGINE_CALLBACK_RELOAD_PROGRAMS:

  913.             plugin = getPlugin(pluginId);

  914. 

  915.             if (plugin != nullptr && plugin->isEnabled())

  916.             {

  917.                 CARLA_SAFE_ASSERT_BREAK(plugin->getId() == pluginId);

  918.                 uiServerSendPluginPrograms(plugin);

  919.             }

  920.             break;

  921. 

  922.         case ENGINE_CALLBACK_RELOAD_ALL:

  923.         case ENGINE_CALLBACK_PLUGIN_ADDED:

  924.             plugin = getPlugin(pluginId);

  925. 

  926.             if (plugin != nullptr && plugin->isEnabled())

  927.             {

  928.                 CARLA_SAFE_ASSERT_BREAK(plugin->getId() == pluginId);

  929.                 uiServerSendPluginInfo(plugin);

  930.                 uiServerSendPluginParameters(plugin);

  931.                 uiServerSendPluginPrograms(plugin);

  932.             }

  933.             break;

  934. 

  935.         default:

  936.             break;

  937.         }

  938. 

  939.         const CarlaMutexLocker cml(fUiServer.getLock());

  940.         const ScopedLocale csl;

  941. 

  942.         std::sprintf(fTmpBuf, "ENGINE_CALLBACK_%i\n", int(action));

  943.         fUiServer.writeMsg(fTmpBuf);

  944. 

  945.         std::sprintf(fTmpBuf, "%u\n", pluginId);

  946.         fUiServer.writeMsg(fTmpBuf);

  947. 

  948.         std::sprintf(fTmpBuf, "%i\n", value1);

  949.         fUiServer.writeMsg(fTmpBuf);

  950. 

  951.         std::sprintf(fTmpBuf, "%i\n", value2);

  952.         fUiServer.writeMsg(fTmpBuf);

  953. 

  954.         std::sprintf(fTmpBuf, "%f\n", value3);

  955.         fUiServer.writeMsg(fTmpBuf);

  956. 

  957.         fUiServer.writeAndFixMsg(valueStr);

  958.     }

  959. 

  960.     void uiServerInfo()

  961.     {

  962.         CARLA_SAFE_ASSERT_RETURN(fIsRunning,);

  963.         CARLA_SAFE_ASSERT_RETURN(fUiServer.isRunning(),);

  964. 

  965.         const CarlaMutexLocker cml(fUiServer.getLock());

  966. 

  967.         fUiServer.writeAndFixMsg("complete-license");

  968.         fUiServer.writeAndFixMsg(carla_get_complete_license_text());

  969. 

  970.         fUiServer.writeAndFixMsg("juce-version");

  971.         fUiServer.writeAndFixMsg(carla_get_juce_version());

  972. 

  973.         fUiServer.writeAndFixMsg("file-exts");

  974.         fUiServer.writeAndFixMsg(carla_get_supported_file_extensions());

  975. 

  976.         fUiServer.writeAndFixMsg("max-plugin-number");

  977.         std::sprintf(fTmpBuf, "%i\n", pData->maxPluginNumber);

  978.         fUiServer.writeMsg(fTmpBuf);

  979. 

  980.         fUiServer.writeAndFixMsg("buffer-size");

  981.         std::sprintf(fTmpBuf, "%i\n", pData->bufferSize);

  982.         fUiServer.writeMsg(fTmpBuf);

  983. 

  984.         const ScopedLocale csl;

  985. 

  986.         fUiServer.writeAndFixMsg("sample-rate");

  987.         std::sprintf(fTmpBuf, "%f\n", pData->sampleRate);

  988.         fUiServer.writeMsg(fTmpBuf);

  989.     }

  990. 

  991.     void uiServerOptions()

  992.     {

  993.         CARLA_SAFE_ASSERT_RETURN(fIsRunning,);

  994.         CARLA_SAFE_ASSERT_RETURN(fUiServer.isRunning(),);

  995. 

  996.         const EngineOptions& options(pData->options);

  997.         const CarlaMutexLocker cml(fUiServer.getLock());

  998. 

  999.         std::sprintf(fTmpBuf, "ENGINE_OPTION_%i\n", ENGINE_OPTION_PROCESS_MODE);

  1000.         fUiServer.writeMsg(fTmpBuf);

  1001.         std::sprintf(fTmpBuf, "%s\n", bool2str(fOptionsForced));

  1002.         fUiServer.writeMsg(fTmpBuf);

  1003.         std::sprintf(fTmpBuf, "%i\n", options.processMode);

  1004.         fUiServer.writeMsg(fTmpBuf);

  1005. 

  1006.         std::sprintf(fTmpBuf, "ENGINE_OPTION_%i\n", ENGINE_OPTION_TRANSPORT_MODE);

  1007.         fUiServer.writeMsg(fTmpBuf);

  1008.         std::sprintf(fTmpBuf, "%s\n", bool2str(fOptionsForced));

  1009.         fUiServer.writeMsg(fTmpBuf);

  1010.         std::sprintf(fTmpBuf, "%i\n", options.transportMode);

  1011.         fUiServer.writeMsg(fTmpBuf);

  1012. 

  1013.         std::sprintf(fTmpBuf, "ENGINE_OPTION_%i\n", ENGINE_OPTION_FORCE_STEREO);

  1014.         fUiServer.writeMsg(fTmpBuf);

  1015.         std::sprintf(fTmpBuf, "%s\n", bool2str(fOptionsForced));

  1016.         fUiServer.writeMsg(fTmpBuf);

  1017.         std::sprintf(fTmpBuf, "%s\n", bool2str(options.forceStereo));

  1018.         fUiServer.writeMsg(fTmpBuf);

  1019. 

  1020.         std::sprintf(fTmpBuf, "ENGINE_OPTION_%i\n", ENGINE_OPTION_PREFER_PLUGIN_BRIDGES);

  1021.         fUiServer.writeMsg(fTmpBuf);

  1022.         std::sprintf(fTmpBuf, "%s\n", bool2str(fOptionsForced));

  1023.         fUiServer.writeMsg(fTmpBuf);

  1024.         std::sprintf(fTmpBuf, "%s\n", bool2str(options.preferPluginBridges));

  1025.         fUiServer.writeMsg(fTmpBuf);

  1026. 

  1027.         std::sprintf(fTmpBuf, "ENGINE_OPTION_%i\n", ENGINE_OPTION_PREFER_UI_BRIDGES);

  1028.         fUiServer.writeMsg(fTmpBuf);

  1029.         std::sprintf(fTmpBuf, "%s\n", bool2str(fOptionsForced));

  1030.         fUiServer.writeMsg(fTmpBuf);

  1031.         std::sprintf(fTmpBuf, "%s\n", bool2str(options.preferUiBridges));

  1032.         fUiServer.writeMsg(fTmpBuf);

  1033. 

  1034.         std::sprintf(fTmpBuf, "ENGINE_OPTION_%i\n", ENGINE_OPTION_UIS_ALWAYS_ON_TOP);

  1035.         fUiServer.writeMsg(fTmpBuf);

  1036.         std::sprintf(fTmpBuf, "%s\n", bool2str(fOptionsForced));

  1037.         fUiServer.writeMsg(fTmpBuf);

  1038.         std::sprintf(fTmpBuf, "%s\n", bool2str(options.uisAlwaysOnTop));

  1039.         fUiServer.writeMsg(fTmpBuf);

  1040. 

  1041.         std::sprintf(fTmpBuf, "ENGINE_OPTION_%i\n", ENGINE_OPTION_MAX_PARAMETERS);

  1042.         fUiServer.writeMsg(fTmpBuf);

  1043.         std::sprintf(fTmpBuf, "%s\n", bool2str(fOptionsForced));

  1044.         fUiServer.writeMsg(fTmpBuf);

  1045.         std::sprintf(fTmpBuf, "%i\n", options.maxParameters);

  1046.         fUiServer.writeMsg(fTmpBuf);

  1047. 

  1048.         std::sprintf(fTmpBuf, "ENGINE_OPTION_%i\n", ENGINE_OPTION_UI_BRIDGES_TIMEOUT);

  1049.         fUiServer.writeMsg(fTmpBuf);

  1050.         std::sprintf(fTmpBuf, "%s\n", bool2str(fOptionsForced));

  1051.         fUiServer.writeMsg(fTmpBuf);

  1052.         std::sprintf(fTmpBuf, "%i\n", options.uiBridgesTimeout);

  1053.         fUiServer.writeMsg(fTmpBuf);

  1054. 

  1055.         std::sprintf(fTmpBuf, "ENGINE_OPTION_%i\n", ENGINE_OPTION_PATH_BINARIES);

  1056.         fUiServer.writeMsg(fTmpBuf);

  1057.         std::sprintf(fTmpBuf, "%s\n", "true");

  1058.         fUiServer.writeMsg(fTmpBuf);

  1059.         std::sprintf(fTmpBuf, "%s\n", options.binaryDir);

  1060.         fUiServer.writeMsg(fTmpBuf);

  1061. 

  1062.         std::sprintf(fTmpBuf, "ENGINE_OPTION_%i\n", ENGINE_OPTION_PATH_RESOURCES);

  1063.         fUiServer.writeMsg(fTmpBuf);

  1064.         std::sprintf(fTmpBuf, "%s\n", "true");

  1065.         fUiServer.writeMsg(fTmpBuf);

  1066.         std::sprintf(fTmpBuf, "%s\n", options.resourceDir);

  1067.         fUiServer.writeMsg(fTmpBuf);

  1068.     }

  1069. 

  1070.     // -------------------------------------------------------------------

  1071.     // Plugin parameter calls

  1072. 

  1073.     uint32_t getParameterCount() const

  1074.     {

  1075.         if (CarlaPlugin* const plugin = _getFirstPlugin())

  1076.             return plugin->getParameterCount();

  1077. 

  1078.         return 0;

  1079.     }

  1080. 

  1081.     const NativeParameter* getParameterInfo(const uint32_t index) const

  1082.     {

  1083.         if (CarlaPlugin* const plugin = _getFirstPlugin())

  1084.         {

  1085.             if (index < plugin->getParameterCount())

  1086.             {

  1087.                 static NativeParameter param;

  1088.                 static char strBufName[STR_MAX+1];

  1089.                 static char strBufUnit[STR_MAX+1];

  1090. 

  1091.                 const ParameterData& paramData(plugin->getParameterData(index));

  1092.                 const ParameterRanges& paramRanges(plugin->getParameterRanges(index));

  1093. 

  1094.                 plugin->getParameterName(index, strBufName);

  1095.                 plugin->getParameterUnit(index, strBufUnit);

  1096. 

  1097.                 uint hints = 0x0;

  1098. 

  1099.                 if (paramData.hints & PARAMETER_IS_BOOLEAN)

  1100.                     hints |= NATIVE_PARAMETER_IS_BOOLEAN;

  1101.                 if (paramData.hints & PARAMETER_IS_INTEGER)

  1102.                     hints |= NATIVE_PARAMETER_IS_INTEGER;

  1103.                 if (paramData.hints & PARAMETER_IS_LOGARITHMIC)

  1104.                     hints |= NATIVE_PARAMETER_IS_LOGARITHMIC;

  1105.                 if (paramData.hints & PARAMETER_IS_AUTOMABLE)

  1106.                     hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1107.                 if (paramData.hints & PARAMETER_USES_SAMPLERATE)

  1108.                     hints |= NATIVE_PARAMETER_USES_SAMPLE_RATE;

  1109.                 if (paramData.hints & PARAMETER_USES_SCALEPOINTS)

  1110.                     hints |= NATIVE_PARAMETER_USES_SCALEPOINTS;

  1111.                 if (paramData.hints & PARAMETER_USES_CUSTOM_TEXT)

  1112.                     hints |= NATIVE_PARAMETER_USES_CUSTOM_TEXT;

  1113. 

  1114.                 if (paramData.type == PARAMETER_INPUT || paramData.type == PARAMETER_OUTPUT)

  1115.                 {

  1116.                     if (paramData.hints & PARAMETER_IS_ENABLED)

  1117.                         hints |= NATIVE_PARAMETER_IS_ENABLED;

  1118.                     if (paramData.type == PARAMETER_OUTPUT)

  1119.                         hints |= NATIVE_PARAMETER_IS_OUTPUT;

  1120.                 }

  1121. 

  1122.                 param.hints = static_cast<NativeParameterHints>(hints);

  1123.                 param.name  = strBufName;

  1124.                 param.unit  = strBufUnit;

  1125.                 param.ranges.def = paramRanges.def;

  1126.                 param.ranges.min = paramRanges.min;

  1127.                 param.ranges.max = paramRanges.max;

  1128.                 param.ranges.step = paramRanges.step;

  1129.                 param.ranges.stepSmall = paramRanges.stepSmall;

  1130.                 param.ranges.stepLarge = paramRanges.stepLarge;

  1131.                 param.scalePointCount = 0; // TODO

  1132.                 param.scalePoints = nullptr;

  1133. 

  1134.                 return &param;

  1135.             }

  1136.         }

  1137. 

  1138.         return nullptr;

  1139.     }

  1140. 

  1141.     float getParameterValue(const uint32_t index) const

  1142.     {

  1143.         if (CarlaPlugin* const plugin = _getFirstPlugin())

  1144.         {

  1145.             if (index < plugin->getParameterCount())

  1146.                 return plugin->getParameterValue(index);

  1147.         }

  1148. 

  1149.         return 0.0f;

  1150.     }

  1151. 

  1152.     const char* getParameterText(const uint32_t index /*, const float value*/) const

  1153.     {

  1154.         if (CarlaPlugin* const plugin = _getFirstPlugin())

  1155.         {

  1156.             if (index < plugin->getParameterCount())

  1157.             {

  1158.                 static char strBuf[STR_MAX+1];

  1159.                 carla_zeroChar(strBuf, STR_MAX+1);

  1160. 

  1161.                 plugin->getParameterText(index, /*value,*/ strBuf);

  1162. 

  1163.                 return strBuf;

  1164.             }

  1165.         }

  1166. 

  1167.         return nullptr;

  1168.     }

  1169. 

  1170.     // -------------------------------------------------------------------

  1171.     // Plugin midi-program calls

  1172. 

  1173.     uint32_t getMidiProgramCount() const

  1174.     {

  1175.         if (CarlaPlugin* const plugin = _getFirstPlugin())

  1176.             return plugin->getMidiProgramCount();

  1177. 

  1178.         return 0;

  1179.     }

  1180. 

  1181.     const NativeMidiProgram* getMidiProgramInfo(const uint32_t index) const

  1182.     {

  1183.         if (CarlaPlugin* const plugin = _getFirstPlugin())

  1184.         {

  1185.             if (index < plugin->getMidiProgramCount())

  1186.             {

  1187.                 static NativeMidiProgram midiProg;

  1188. 

  1189.                 {

  1190.                     const MidiProgramData& midiProgData(plugin->getMidiProgramData(index));

  1191. 

  1192.                     midiProg.bank    = midiProgData.bank;

  1193.                     midiProg.program = midiProgData.program;

  1194.                     midiProg.name    = midiProgData.name;

  1195.                 }

  1196. 

  1197.                 return &midiProg;

  1198.             }

  1199.         }

  1200. 

  1201.         return nullptr;

  1202.     }

  1203. 

  1204.     // -------------------------------------------------------------------

  1205.     // Plugin state calls

  1206. 

  1207.     void setParameterValue(const uint32_t index, const float value)

  1208.     {

  1209.         if (CarlaPlugin* const plugin = _getFirstPlugin())

  1210.         {

  1211.             if (index < plugin->getParameterCount())

  1212.                 plugin->setParameterValue(index, value, false, false, false);

  1213.         }

  1214.     }

  1215. 

  1216.     void setMidiProgram(const uint8_t, const uint32_t bank, const uint32_t program)

  1217.     {

  1218.         if (CarlaPlugin* const plugin = _getFirstPlugin())

  1219.             plugin->setMidiProgramById(bank, program, false, false, false);

  1220.     }

  1221. 

  1222.     // -------------------------------------------------------------------

  1223.     // Plugin process calls

  1224. 

  1225.     void activate()

  1226.     {

  1227. #if 0

  1228.         for (uint32_t i=0; i < pData->curPluginCount; ++i)

  1229.         {

  1230.             CarlaPlugin* const plugin(pData->plugins[i].plugin);

  1231. 

  1232.             if (plugin == nullptr || ! plugin->isEnabled())

  1233.                 continue;

  1234. 

  1235.             plugin->setActive(true, true, false);

  1236.         }

  1237. #endif

  1238.         fIsActive = true;

  1239.     }

  1240. 

  1241.     void deactivate()

  1242.     {

  1243.         fIsActive = false;

  1244. #if 0

  1245.         for (uint32_t i=0; i < pData->curPluginCount; ++i)

  1246.         {

  1247.             CarlaPlugin* const plugin(pData->plugins[i].plugin);

  1248. 

  1249.             if (plugin == nullptr || ! plugin->isEnabled())

  1250.                 continue;

  1251. 

  1252.             plugin->setActive(false, true, false);

  1253.         }

  1254. #endif

  1255. 

  1256.         // just in case

  1257.         //runPendingRtEvents();

  1258.     }

  1259. 

  1260.     void process(float** const inBuffer, float** const outBuffer, const uint32_t frames, const NativeMidiEvent* const midiEvents, const uint32_t midiEventCount)

  1261.     {

  1262.         const PendingRtEventsRunner prt(this);

  1263. 

  1264.         // ---------------------------------------------------------------

  1265.         // Time Info

  1266. 

  1267.         const NativeTimeInfo* const timeInfo(pHost->get_time_info(pHost->handle));

  1268. 

  1269.         pData->timeInfo.playing = timeInfo->playing;

  1270.         pData->timeInfo.frame   = timeInfo->frame;

  1271.         pData->timeInfo.usecs   = timeInfo->usecs;

  1272.         pData->timeInfo.valid   = 0x0;

  1273. 

  1274.         if (timeInfo->bbt.valid)

  1275.         {

  1276.             pData->timeInfo.valid |= EngineTimeInfo::kValidBBT;

  1277. 

  1278.             pData->timeInfo.bbt.bar = timeInfo->bbt.bar;

  1279.             pData->timeInfo.bbt.beat = timeInfo->bbt.beat;

  1280.             pData->timeInfo.bbt.tick = timeInfo->bbt.tick;

  1281.             pData->timeInfo.bbt.barStartTick = timeInfo->bbt.barStartTick;

  1282. 

  1283.             pData->timeInfo.bbt.beatsPerBar = timeInfo->bbt.beatsPerBar;

  1284.             pData->timeInfo.bbt.beatType = timeInfo->bbt.beatType;

  1285. 

  1286.             pData->timeInfo.bbt.ticksPerBeat = timeInfo->bbt.ticksPerBeat;

  1287.             pData->timeInfo.bbt.beatsPerMinute = timeInfo->bbt.beatsPerMinute;

  1288.         }

  1289. 

  1290.         // ---------------------------------------------------------------

  1291.         // Do nothing if no plugins and rack mode

  1292. 

  1293.         if (pData->curPluginCount == 0 && ! kIsPatchbay)

  1294.         {

  1295.             FloatVectorOperations::copy(outBuffer[0], inBuffer[0], static_cast<int>(frames));

  1296.             FloatVectorOperations::copy(outBuffer[1], inBuffer[1], static_cast<int>(frames));

  1297.             return;

  1298.         }

  1299. 

  1300.         // ---------------------------------------------------------------

  1301.         // initialize events

  1302. 

  1303.         carla_zeroStruct<EngineEvent>(pData->events.in,  kMaxEngineEventInternalCount);

  1304.         carla_zeroStruct<EngineEvent>(pData->events.out, kMaxEngineEventInternalCount);

  1305. 

  1306.         // ---------------------------------------------------------------

  1307.         // events input (before processing)

  1308. 

  1309.         {

  1310.             uint32_t engineEventIndex = 0;

  1311. 

  1312.             for (uint32_t i=0; i < midiEventCount && engineEventIndex < kMaxEngineEventInternalCount; ++i)

  1313.             {

  1314.                 const NativeMidiEvent& midiEvent(midiEvents[i]);

  1315.                 EngineEvent&           engineEvent(pData->events.in[engineEventIndex++]);

  1316. 

  1317.                 engineEvent.time = midiEvent.time;

  1318.                 engineEvent.fillFromMidiData(midiEvent.size, midiEvent.data);

  1319. 

  1320.                 if (engineEventIndex >= kMaxEngineEventInternalCount)

  1321.                     break;

  1322.             }

  1323.         }

  1324. 

  1325.         if (kIsPatchbay)

  1326.         {

  1327.             // -----------------------------------------------------------

  1328.             // process

  1329. 

  1330.             pData->graph.process(pData, inBuffer, outBuffer, frames);

  1331.         }

  1332.         else

  1333.         {

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

  1335.             // create audio buffers

  1336. 

  1337.             const float* inBuf[2]  = {  inBuffer[0],  inBuffer[1] };

  1338.             /* */ float* outBuf[2] = { outBuffer[0], outBuffer[1] };

  1339. 

  1340.             // -----------------------------------------------------------

  1341.             // process

  1342. 

  1343.             pData->graph.processRack(pData, inBuf, outBuf, frames);

  1344.         }

  1345. 

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

  1347.         // events output (after processing)

  1348. 

  1349.         carla_zeroStruct<EngineEvent>(pData->events.in, kMaxEngineEventInternalCount);

  1350. 

  1351.         {

  1352.             NativeMidiEvent midiEvent;

  1353. 

  1354.             for (uint32_t i=0; i < kMaxEngineEventInternalCount; ++i)

  1355.             {

  1356.                 const EngineEvent& engineEvent(pData->events.out[i]);

  1357. 

  1358.                 if (engineEvent.type == kEngineEventTypeNull)

  1359.                     break;

  1360. 

  1361.                 midiEvent.time = engineEvent.time;

  1362. 

  1363.                 if (engineEvent.type == CarlaBackend::kEngineEventTypeControl)

  1364.                 {

  1365.                     midiEvent.port = 0;

  1366.                     engineEvent.ctrl.convertToMidiData(engineEvent.channel, midiEvent.size, midiEvent.data);

  1367.                 }

  1368.                 else if (engineEvent.type == kEngineEventTypeMidi)

  1369.                 {

  1370.                     if (engineEvent.midi.size > 4 || engineEvent.midi.dataExt != nullptr)

  1371.                         continue;

  1372. 

  1373.                     midiEvent.port = engineEvent.midi.port;

  1374.                     midiEvent.size = engineEvent.midi.size;

  1375. 

  1376.                     midiEvent.data[0] = static_cast<uint8_t>(engineEvent.midi.data[0] + engineEvent.channel);

  1377. 

  1378.                     for (uint8_t j=1; j < midiEvent.size; ++j)

  1379.                         midiEvent.data[j] = engineEvent.midi.data[j];

  1380.                 }

  1381.                 else

  1382.                 {

  1383.                     carla_stderr("Unknown event type...");

  1384.                     continue;

  1385.                 }

  1386. 

  1387.                 pHost->write_midi_event(pHost->handle, &midiEvent);

  1388.             }

  1389.         }

  1390.     }

  1391. 

  1392.     // -------------------------------------------------------------------

  1393.     // Plugin UI calls

  1394. 

  1395.     void uiShow(const bool show)

  1396.     {

  1397.         if (show)

  1398.         {

  1399.             if (fUiServer.isRunning())

  1400.                 return;

  1401. 

  1402.             CarlaString path(pHost->resourceDir);

  1403. 

  1404.             if (kIsPatchbay)

  1405.                 path += "/carla-plugin-patchbay";

  1406.             else

  1407.                 path += "/carla-plugin";

  1408. 

  1409.             carla_stdout("Trying to start carla-plugin using \"%s\"", path.buffer());

  1410. 

  1411.             fUiServer.setData(path, pData->sampleRate, pHost->uiName);

  1412.             fUiServer.start(false);

  1413. 

  1414.             uiServerInfo();

  1415.             uiServerOptions();

  1416.             uiServerCallback(ENGINE_CALLBACK_ENGINE_STARTED, 0, pData->options.processMode, pData->options.transportMode, 0.0f, "Plugin");

  1417. 

  1418.             fUiServer.show();

  1419. 

  1420.             for (uint i=0; i < pData->curPluginCount; ++i)

  1421.             {

  1422.                 CarlaPlugin* const plugin(pData->plugins[i].plugin);

  1423. 

  1424.                 if (plugin != nullptr && plugin->isEnabled())

  1425.                 {

  1426.                     uiServerCallback(ENGINE_CALLBACK_PLUGIN_ADDED, i, 0, 0, 0.0f, plugin->getName());

  1427.                 }

  1428.             }

  1429. 

  1430.             if (kIsPatchbay)

  1431.                 patchbayRefresh(false);

  1432.         }

  1433.         else

  1434.         {

  1435.             fUiServer.stop(5000);

  1436.         }

  1437.     }

  1438. 

  1439.     void uiIdle()

  1440.     {

  1441.         CarlaEngine::idle();

  1442.         fUiServer.idle();

  1443. 

  1444.         if (fUiServer.isRunning())

  1445.         {

  1446.             const EngineTimeInfo& timeInfo(pData->timeInfo);

  1447.             const CarlaMutexLocker cml(fUiServer.getLock());

  1448.             const ScopedLocale csl;

  1449. 

  1450.             // send transport

  1451.             fUiServer.writeAndFixMsg("transport");

  1452.             fUiServer.writeAndFixMsg(bool2str(timeInfo.playing));

  1453. 

  1454.             if (timeInfo.valid & EngineTimeInfo::kValidBBT)

  1455.             {

  1456.                 std::sprintf(fTmpBuf, P_UINT64 ":%i:%i:%i\n", timeInfo.frame, timeInfo.bbt.bar, timeInfo.bbt.beat, timeInfo.bbt.tick);

  1457.                 fUiServer.writeMsg(fTmpBuf);

  1458.                 std::sprintf(fTmpBuf, "%f\n", timeInfo.bbt.beatsPerMinute);

  1459.                 fUiServer.writeMsg(fTmpBuf);

  1460.             }

  1461.             else

  1462.             {

  1463.                 std::sprintf(fTmpBuf, P_UINT64 ":0:0:0\n", timeInfo.frame);

  1464.                 fUiServer.writeMsg(fTmpBuf);

  1465.                 fUiServer.writeMsg("0.0\n");

  1466.             }

  1467. 

  1468.             // send peaks and param outputs for all plugins

  1469.             for (uint i=0; i < pData->curPluginCount; ++i)

  1470.             {

  1471.                 const EnginePluginData& plugData(pData->plugins[i]);

  1472.                 const CarlaPlugin* const plugin(pData->plugins[i].plugin);

  1473. 

  1474.                 std::sprintf(fTmpBuf, "PEAKS_%i\n", i);

  1475.                 fUiServer.writeMsg(fTmpBuf);

  1476. 

  1477.                 std::sprintf(fTmpBuf, "%f:%f:%f:%f\n", plugData.insPeak[0], plugData.insPeak[1], plugData.outsPeak[0], plugData.outsPeak[1]);

  1478.                 fUiServer.writeMsg(fTmpBuf);

  1479. 

  1480.                 for (uint32_t j=0, count=plugin->getParameterCount(); j < count; ++j)

  1481.                 {

  1482.                     if (! plugin->isParameterOutput(j))

  1483.                         continue;

  1484. 

  1485.                     std::sprintf(fTmpBuf, "PARAMVAL_%i:%i\n", i, j);

  1486.                     fUiServer.writeMsg(fTmpBuf);

  1487.                     std::sprintf(fTmpBuf, "%f\n", plugin->getParameterValue(j));

  1488.                     fUiServer.writeMsg(fTmpBuf);

  1489.                 }

  1490.             }

  1491.         }

  1492. 

  1493.         switch (fUiServer.getAndResetUiState())

  1494.         {

  1495.         case CarlaExternalUI::UiNone:

  1496.         case CarlaExternalUI::UiShow:

  1497.             break;

  1498.         case CarlaExternalUI::UiCrashed:

  1499.             pHost->dispatcher(pHost->handle, NATIVE_HOST_OPCODE_UI_UNAVAILABLE, 0, 0, nullptr, 0.0f);

  1500.             break;

  1501.         case CarlaExternalUI::UiHide:

  1502.             pHost->ui_closed(pHost->handle);

  1503.             fUiServer.stop(2000);

  1504.             break;

  1505.         }

  1506.     }

  1507. 

  1508.     // -------------------------------------------------------------------

  1509.     // Plugin state calls

  1510. 

  1511.     char* getState() const

  1512.     {

  1513.         MemoryOutputStream out;

  1514.         saveProjectInternal(out);

  1515.         return strdup(out.toString().toRawUTF8());

  1516.     }

  1517. 

  1518.     void setState(const char* const data)

  1519.     {

  1520.         fOptionsForced = true;

  1521.         const String state(data);

  1522.         XmlDocument xml(state);

  1523.         loadProjectInternal(xml);

  1524.     }

  1525. 

  1526.     // -------------------------------------------------------------------

  1527. 

  1528. public:

  1529.     #define handlePtr ((CarlaEngineNative*)handle)

  1530. 

  1531.     static NativePluginHandle _instantiateRack(const NativeHostDescriptor* host)

  1532.     {

  1533.         return new CarlaEngineNative(host, false);

  1534.     }

  1535. 

  1536.     static NativePluginHandle _instantiatePatchbay(const NativeHostDescriptor* host)

  1537.     {

  1538.         return new CarlaEngineNative(host, true);

  1539.     }

  1540. 

  1541.     static NativePluginHandle _instantiatePatchbay16(const NativeHostDescriptor* host)

  1542.     {

  1543.         return new CarlaEngineNative(host, true, 16);

  1544.     }

  1545. 

  1546.     static NativePluginHandle _instantiatePatchbay32(const NativeHostDescriptor* host)

  1547.     {

  1548.         return new CarlaEngineNative(host, true, 32);

  1549.     }

  1550. 

  1551.     static void _cleanup(NativePluginHandle handle)

  1552.     {

  1553.         delete handlePtr;

  1554.     }

  1555. 

  1556.     static uint32_t _get_parameter_count(NativePluginHandle handle)

  1557.     {

  1558.         return handlePtr->getParameterCount();

  1559.     }

  1560. 

  1561.     static const NativeParameter* _get_parameter_info(NativePluginHandle handle, uint32_t index)

  1562.     {

  1563.         return handlePtr->getParameterInfo(index);

  1564.     }

  1565. 

  1566.     static float _get_parameter_value(NativePluginHandle handle, uint32_t index)

  1567.     {

  1568.         return handlePtr->getParameterValue(index);

  1569.     }

  1570. 

  1571.     static const char* _get_parameter_text(NativePluginHandle handle, uint32_t index /*, float value*/)

  1572.     {

  1573.         return handlePtr->getParameterText(index /*, value*/);

  1574.     }

  1575. 

  1576.     static uint32_t _get_midi_program_count(NativePluginHandle handle)

  1577.     {

  1578.         return handlePtr->getMidiProgramCount();

  1579.     }

  1580. 

  1581.     static const NativeMidiProgram* _get_midi_program_info(NativePluginHandle handle, uint32_t index)

  1582.     {

  1583.         return handlePtr->getMidiProgramInfo(index);

  1584.     }

  1585. 

  1586.     static void _set_parameter_value(NativePluginHandle handle, uint32_t index, float value)

  1587.     {

  1588.         handlePtr->setParameterValue(index, value);

  1589.     }

  1590. 

  1591.     static void _set_midi_program(NativePluginHandle handle, uint8_t channel, uint32_t bank, uint32_t program)

  1592.     {

  1593.         handlePtr->setMidiProgram(channel, bank, program);

  1594.     }

  1595. 

  1596.     static void _ui_show(NativePluginHandle handle, bool show)

  1597.     {

  1598.         handlePtr->uiShow(show);

  1599.     }

  1600. 

  1601.     static void _ui_idle(NativePluginHandle handle)

  1602.     {

  1603.         handlePtr->uiIdle();

  1604.     }

  1605. 

  1606.     static void _activate(NativePluginHandle handle)

  1607.     {

  1608.         handlePtr->activate();

  1609.     }

  1610. 

  1611.     static void _deactivate(NativePluginHandle handle)

  1612.     {

  1613.         handlePtr->deactivate();

  1614.     }

  1615. 

  1616.     static void _process(NativePluginHandle handle, float** inBuffer, float** outBuffer, const uint32_t frames, const NativeMidiEvent* midiEvents, uint32_t midiEventCount)

  1617.     {

  1618.         handlePtr->process(inBuffer, outBuffer, frames, midiEvents, midiEventCount);

  1619.     }

  1620. 

  1621.     static char* _get_state(NativePluginHandle handle)

  1622.     {

  1623.         return handlePtr->getState();

  1624.     }

  1625. 

  1626.     static void _set_state(NativePluginHandle handle, const char* data)

  1627.     {

  1628.         handlePtr->setState(data);

  1629.     }

  1630. 

  1631.     static intptr_t _dispatcher(NativePluginHandle handle, NativePluginDispatcherOpcode opcode, int32_t index, intptr_t value, void* ptr, float opt)

  1632.     {

  1633.         switch(opcode)

  1634.         {

  1635.         case NATIVE_PLUGIN_OPCODE_NULL:

  1636.             return 0;

  1637.         case NATIVE_PLUGIN_OPCODE_BUFFER_SIZE_CHANGED:

  1638.             CARLA_SAFE_ASSERT_RETURN(value > 0, 0);

  1639.             handlePtr->bufferSizeChanged(static_cast<uint32_t>(value));

  1640.             return 0;

  1641.         case NATIVE_PLUGIN_OPCODE_SAMPLE_RATE_CHANGED:

  1642.             CARLA_SAFE_ASSERT_RETURN(opt > 0.0, 0);

  1643.             handlePtr->sampleRateChanged(static_cast<double>(opt));

  1644.             return 0;

  1645.         case NATIVE_PLUGIN_OPCODE_OFFLINE_CHANGED:

  1646.             handlePtr->offlineModeChanged(value != 0);

  1647.             return 0;

  1648.         case NATIVE_PLUGIN_OPCODE_UI_NAME_CHANGED:

  1649.             //handlePtr->uiNameChanged(static_cast<const char*>(ptr));

  1650.             return 0;

  1651.         }

  1652. 

  1653.         return 0;

  1654. 

  1655.         // unused

  1656.         (void)index;

  1657.         (void)ptr;

  1658.     }

  1659. 

  1660.     // -------------------------------------------------------------------

  1661. 

  1662.     static void _ui_server_callback(void* handle, EngineCallbackOpcode action, uint pluginId, int value1, int value2, float value3, const char* valueStr)

  1663.     {

  1664.         handlePtr->uiServerCallback(action, pluginId, value1, value2, value3, valueStr);

  1665.     }

  1666. 

  1667.     // -------------------------------------------------------------------

  1668. 

  1669.     #undef handlePtr

  1670. 

  1671. private:

  1672.     const NativeHostDescriptor* const pHost;

  1673. 

  1674.     const bool kIsPatchbay; // rack if false

  1675.     bool fIsActive, fIsRunning;

  1676.     CarlaEngineNativeUI fUiServer;

  1677. 

  1678.     bool fOptionsForced;

  1679.     char fTmpBuf[STR_MAX+1];

  1680. 

  1681.     CarlaPlugin* _getFirstPlugin() const noexcept

  1682.     {

  1683.         if (pData->curPluginCount == 0 || pData->plugins == nullptr)

  1684.             return nullptr;

  1685. 

  1686.         CarlaPlugin* const plugin(pData->plugins[0].plugin);

  1687. 

  1688.         if (plugin == nullptr || ! plugin->isEnabled())

  1689.             return nullptr;

  1690. 

  1691.         return pData->plugins[0].plugin;

  1692.     }

  1693. 

  1694.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaEngineNative)

  1695. };

  1696. 

  1697. // -----------------------------------------------------------------------

  1698. 

  1699. static const NativePluginDescriptor carlaRackDesc = {

  1700.     /* category  */ NATIVE_PLUGIN_CATEGORY_OTHER,

  1701.     /* hints     */ static_cast<NativePluginHints>(NATIVE_PLUGIN_IS_SYNTH

  1702.                                                   |NATIVE_PLUGIN_HAS_UI

  1703.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS

  1704.                                                   |NATIVE_PLUGIN_NEEDS_SINGLE_THREAD

  1705.                                                   |NATIVE_PLUGIN_USES_STATE

  1706.                                                   |NATIVE_PLUGIN_USES_TIME),

  1707.     /* supports  */ static_cast<NativePluginSupports>(NATIVE_PLUGIN_SUPPORTS_EVERYTHING),

  1708.     /* audioIns  */ 2,

  1709.     /* audioOuts */ 2,

  1710.     /* midiIns   */ 1,

  1711.     /* midiOuts  */ 1,

  1712.     /* paramIns  */ 0,

  1713.     /* paramOuts */ 0,

  1714.     /* name      */ "Carla-Rack",

  1715.     /* label     */ "carlarack",

  1716.     /* maker     */ "falkTX",

  1717.     /* copyright */ "GNU GPL v2+",

  1718.     CarlaEngineNative::_instantiateRack,

  1719.     CarlaEngineNative::_cleanup,

  1720.     CarlaEngineNative::_get_parameter_count,

  1721.     CarlaEngineNative::_get_parameter_info,

  1722.     CarlaEngineNative::_get_parameter_value,

  1723.     CarlaEngineNative::_get_parameter_text,

  1724.     CarlaEngineNative::_get_midi_program_count,

  1725.     CarlaEngineNative::_get_midi_program_info,

  1726.     CarlaEngineNative::_set_parameter_value,

  1727.     CarlaEngineNative::_set_midi_program,

  1728.     /* _set_custom_data        */ nullptr,

  1729.     CarlaEngineNative::_ui_show,

  1730.     CarlaEngineNative::_ui_idle,

  1731.     /* _ui_set_parameter_value */ nullptr,

  1732.     /* _ui_set_midi_program    */ nullptr,

  1733.     /* _ui_set_custom_data     */ nullptr,

  1734.     CarlaEngineNative::_activate,

  1735.     CarlaEngineNative::_deactivate,

  1736.     CarlaEngineNative::_process,

  1737.     CarlaEngineNative::_get_state,

  1738.     CarlaEngineNative::_set_state,

  1739.     CarlaEngineNative::_dispatcher

  1740. };

  1741. 

  1742. static const NativePluginDescriptor carlaPatchbayDesc = {

  1743.     /* category  */ NATIVE_PLUGIN_CATEGORY_OTHER,

  1744.     /* hints     */ static_cast<NativePluginHints>(NATIVE_PLUGIN_IS_SYNTH

  1745.                                                   |NATIVE_PLUGIN_HAS_UI

  1746.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS

  1747.                                                   |NATIVE_PLUGIN_NEEDS_SINGLE_THREAD

  1748.                                                   |NATIVE_PLUGIN_USES_STATE

  1749.                                                   |NATIVE_PLUGIN_USES_TIME),

  1750.     /* supports  */ static_cast<NativePluginSupports>(NATIVE_PLUGIN_SUPPORTS_EVERYTHING),

  1751.     /* audioIns  */ 2,

  1752.     /* audioOuts */ 2,

  1753.     /* midiIns   */ 1,

  1754.     /* midiOuts  */ 1,

  1755.     /* paramIns  */ 0,

  1756.     /* paramOuts */ 0,

  1757.     /* name      */ "Carla-Patchbay",

  1758.     /* label     */ "carlapatchbay",

  1759.     /* maker     */ "falkTX",

  1760.     /* copyright */ "GNU GPL v2+",

  1761.     CarlaEngineNative::_instantiatePatchbay,

  1762.     CarlaEngineNative::_cleanup,

  1763.     CarlaEngineNative::_get_parameter_count,

  1764.     CarlaEngineNative::_get_parameter_info,

  1765.     CarlaEngineNative::_get_parameter_value,

  1766.     CarlaEngineNative::_get_parameter_text,

  1767.     CarlaEngineNative::_get_midi_program_count,

  1768.     CarlaEngineNative::_get_midi_program_info,

  1769.     CarlaEngineNative::_set_parameter_value,

  1770.     CarlaEngineNative::_set_midi_program,

  1771.     /* _set_custom_data        */ nullptr,

  1772.     CarlaEngineNative::_ui_show,

  1773.     CarlaEngineNative::_ui_idle,

  1774.     /* _ui_set_parameter_value */ nullptr,

  1775.     /* _ui_set_midi_program    */ nullptr,

  1776.     /* _ui_set_custom_data     */ nullptr,

  1777.     CarlaEngineNative::_activate,

  1778.     CarlaEngineNative::_deactivate,

  1779.     CarlaEngineNative::_process,

  1780.     CarlaEngineNative::_get_state,

  1781.     CarlaEngineNative::_set_state,

  1782.     CarlaEngineNative::_dispatcher

  1783. };

  1784. 

  1785. static const NativePluginDescriptor carlaPatchbay16Desc = {

  1786.     /* category  */ NATIVE_PLUGIN_CATEGORY_OTHER,

  1787.     /* hints     */ static_cast<NativePluginHints>(NATIVE_PLUGIN_IS_SYNTH

  1788.                                                   |NATIVE_PLUGIN_HAS_UI

  1789.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS

  1790.                                                   |NATIVE_PLUGIN_NEEDS_SINGLE_THREAD

  1791.                                                   |NATIVE_PLUGIN_USES_STATE

  1792.                                                   |NATIVE_PLUGIN_USES_TIME),

  1793.     /* supports  */ static_cast<NativePluginSupports>(NATIVE_PLUGIN_SUPPORTS_EVERYTHING),

  1794.     /* audioIns  */ 16,

  1795.     /* audioOuts */ 16,

  1796.     /* midiIns   */ 1,

  1797.     /* midiOuts  */ 1,

  1798.     /* paramIns  */ 0,

  1799.     /* paramOuts */ 0,

  1800.     /* name      */ "Carla-Patchbay (16chan)",

  1801.     /* label     */ "carlapatchbay16",

  1802.     /* maker     */ "falkTX",

  1803.     /* copyright */ "GNU GPL v2+",

  1804.     CarlaEngineNative::_instantiatePatchbay16,

  1805.     CarlaEngineNative::_cleanup,

  1806.     CarlaEngineNative::_get_parameter_count,

  1807.     CarlaEngineNative::_get_parameter_info,

  1808.     CarlaEngineNative::_get_parameter_value,

  1809.     CarlaEngineNative::_get_parameter_text,

  1810.     CarlaEngineNative::_get_midi_program_count,

  1811.     CarlaEngineNative::_get_midi_program_info,

  1812.     CarlaEngineNative::_set_parameter_value,

  1813.     CarlaEngineNative::_set_midi_program,

  1814.     /* _set_custom_data        */ nullptr,

  1815.     CarlaEngineNative::_ui_show,

  1816.     CarlaEngineNative::_ui_idle,

  1817.     /* _ui_set_parameter_value */ nullptr,

  1818.     /* _ui_set_midi_program    */ nullptr,

  1819.     /* _ui_set_custom_data     */ nullptr,

  1820.     CarlaEngineNative::_activate,

  1821.     CarlaEngineNative::_deactivate,

  1822.     CarlaEngineNative::_process,

  1823.     CarlaEngineNative::_get_state,

  1824.     CarlaEngineNative::_set_state,

  1825.     CarlaEngineNative::_dispatcher

  1826. };

  1827. 

  1828. static const NativePluginDescriptor carlaPatchbay32Desc = {

  1829.     /* category  */ NATIVE_PLUGIN_CATEGORY_OTHER,

  1830.     /* hints     */ static_cast<NativePluginHints>(NATIVE_PLUGIN_IS_SYNTH

  1831.                                                   |NATIVE_PLUGIN_HAS_UI

  1832.                                                   |NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS

  1833.                                                   |NATIVE_PLUGIN_NEEDS_SINGLE_THREAD

  1834.                                                   |NATIVE_PLUGIN_USES_STATE

  1835.                                                   |NATIVE_PLUGIN_USES_TIME),

  1836.     /* supports  */ static_cast<NativePluginSupports>(NATIVE_PLUGIN_SUPPORTS_EVERYTHING),

  1837.     /* audioIns  */ 32,

  1838.     /* audioOuts */ 32,

  1839.     /* midiIns   */ 1,

  1840.     /* midiOuts  */ 1,

  1841.     /* paramIns  */ 0,

  1842.     /* paramOuts */ 0,

  1843.     /* name      */ "Carla-Patchbay (32chan)",

  1844.     /* label     */ "carlapatchbay32",

  1845.     /* maker     */ "falkTX",

  1846.     /* copyright */ "GNU GPL v2+",

  1847.     CarlaEngineNative::_instantiatePatchbay32,

  1848.     CarlaEngineNative::_cleanup,

  1849.     CarlaEngineNative::_get_parameter_count,

  1850.     CarlaEngineNative::_get_parameter_info,

  1851.     CarlaEngineNative::_get_parameter_value,

  1852.     CarlaEngineNative::_get_parameter_text,

  1853.     CarlaEngineNative::_get_midi_program_count,

  1854.     CarlaEngineNative::_get_midi_program_info,

  1855.     CarlaEngineNative::_set_parameter_value,

  1856.     CarlaEngineNative::_set_midi_program,

  1857.     /* _set_custom_data        */ nullptr,

  1858.     CarlaEngineNative::_ui_show,

  1859.     CarlaEngineNative::_ui_idle,

  1860.     /* _ui_set_parameter_value */ nullptr,

  1861.     /* _ui_set_midi_program    */ nullptr,

  1862.     /* _ui_set_custom_data     */ nullptr,

  1863.     CarlaEngineNative::_activate,

  1864.     CarlaEngineNative::_deactivate,

  1865.     CarlaEngineNative::_process,

  1866.     CarlaEngineNative::_get_state,

  1867.     CarlaEngineNative::_set_state,

  1868.     CarlaEngineNative::_dispatcher

  1869. };

  1870. 

  1871. CARLA_BACKEND_END_NAMESPACE

  1872. 

  1873. // -----------------------------------------------------------------------

  1874. 

  1875. CARLA_EXPORT

  1876. void carla_register_native_plugin_carla();

  1877. 

  1878. void carla_register_native_plugin_carla()

  1879. {

  1880.     CARLA_BACKEND_USE_NAMESPACE;

  1881.     carla_register_native_plugin(&carlaRackDesc);

  1882.     carla_register_native_plugin(&carlaPatchbayDesc);

  1883.     carla_register_native_plugin(&carlaPatchbay16Desc);

  1884.     carla_register_native_plugin(&carlaPatchbay32Desc);

  1885. }

  1886. 

  1887. // -----------------------------------------------------------------------

  1888. 

  1889. CARLA_EXPORT

  1890. const NativePluginDescriptor* carla_get_native_rack_plugin();

  1891. const NativePluginDescriptor* carla_get_native_rack_plugin()

  1892. {

  1893.     // if this is called then we're running as special plugin

  1894.     gNeedsJuceHandling = true;

  1895. 

  1896.     CARLA_BACKEND_USE_NAMESPACE;

  1897.     return &carlaRackDesc;

  1898. }

  1899. 

  1900. CARLA_EXPORT

  1901. const NativePluginDescriptor* carla_get_native_patchbay_plugin();

  1902. const NativePluginDescriptor* carla_get_native_patchbay_plugin()

  1903. {

  1904.     // if this is called then we're running as special plugin

  1905.     gNeedsJuceHandling = true;

  1906. 

  1907.     CARLA_BACKEND_USE_NAMESPACE;

  1908.     return &carlaPatchbayDesc;

  1909. }

  1910. 

  1911. // -----------------------------------------------------------------------

  1912. // Extra stuff for linking purposes

  1913. 

  1914. #ifdef CARLA_PLUGIN_EXPORT

  1915. 

  1916. CARLA_BACKEND_START_NAMESPACE

  1917. 

  1918. CarlaEngine* CarlaEngine::newJack() { return nullptr; }

  1919. 

  1920. # if defined(CARLA_OS_MAC) || defined(CARLA_OS_WIN)

  1921. CarlaEngine*       CarlaEngine::newJuce(const AudioApi)           { return nullptr; }

  1922. uint               CarlaEngine::getJuceApiCount()                 { return 0;       }

  1923. const char*        CarlaEngine::getJuceApiName(const uint)        { return nullptr; }

  1924. const char* const* CarlaEngine::getJuceApiDeviceNames(const uint) { return nullptr; }

  1925. const EngineDriverDeviceInfo* CarlaEngine::getJuceDeviceInfo(const uint, const char* const) { return nullptr; }

  1926. # else

  1927. CarlaEngine*       CarlaEngine::newRtAudio(const AudioApi)           { return nullptr; }

  1928. uint               CarlaEngine::getRtAudioApiCount()                 { return 0;       }

  1929. const char*        CarlaEngine::getRtAudioApiName(const uint)        { return nullptr; }

  1930. const char* const* CarlaEngine::getRtAudioApiDeviceNames(const uint) { return nullptr; }

  1931. const EngineDriverDeviceInfo* CarlaEngine::getRtAudioDeviceInfo(const uint, const char* const) { return nullptr; }

  1932. # endif

  1933. 

  1934. CARLA_BACKEND_END_NAMESPACE

  1935. 

  1936. #include "CarlaHostCommon.cpp"

  1937. #include "CarlaPluginUI.cpp"

  1938. #include "CarlaDssiUtils.cpp"

  1939. #include "CarlaPipeUtils.cpp"

  1940. #include "CarlaStateUtils.cpp"

  1941. #include "CarlaJuceEvents.cpp"

  1942. 

  1943. #endif

  1944. 

  1945. // -----------------------------------------------------------------------