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

2338 lines
78KB
Raw Blame History 

  1. /*

  2.  * Carla Plugin Host

  3.  * Copyright (C) 2011-2018 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_ALTERNATIVE_ARCH

  21. # error This file should not be compiled if building alternative-arch bridges

  22. #endif

  23. 

  24. #include "CarlaEngineInternal.hpp"

  25. #include "CarlaPlugin.hpp"

  26. 

  27. #include "CarlaBackendUtils.hpp"

  28. #include "CarlaBase64Utils.hpp"

  29. #include "CarlaBinaryUtils.hpp"

  30. #include "CarlaMathUtils.hpp"

  31. #include "CarlaStateUtils.hpp"

  32. 

  33. #include "CarlaExternalUI.hpp"

  34. #include "CarlaHost.h"

  35. #include "CarlaNative.hpp"

  36. #include "CarlaNativePlugin.h"

  37. 

  38. #include "water/files/File.h"

  39. #include "water/streams/MemoryOutputStream.h"

  40. #include "water/xml/XmlDocument.h"

  41. #include "water/xml/XmlElement.h"

  42. 

  43. using water::File;

  44. using water::MemoryOutputStream;

  45. using water::String;

  46. using water::XmlDocument;

  47. using water::XmlElement;

  48. 

  49. CARLA_BACKEND_START_NAMESPACE

  50. 

  51. // -----------------------------------------------------------------------

  52. 

  53. class CarlaEngineNativeUI : public CarlaExternalUI

  54. {

  55. public:

  56.     CarlaEngineNativeUI(CarlaEngine* const engine)

  57.         : fEngine(engine)

  58.     {

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

  60.     }

  61. 

  62.     ~CarlaEngineNativeUI() noexcept override

  63.     {

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

  65.     }

  66. 

  67. protected:

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

  69.     {

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

  71.             return true;

  72. 

  73.         bool ok = true;

  74. 

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

  76.         {

  77.             uint32_t option;

  78.             int32_t value;

  79.             const char* valueStr = nullptr;

  80. 

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

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

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

  84. 

  85.             try {

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

  87.             } CARLA_SAFE_EXCEPTION("setOption");

  88. 

  89.             if (valueStr != nullptr)

  90.                 delete[] valueStr;

  91.         }

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

  93.         {

  94.             const char* filename;

  95. 

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

  97. 

  98.             try {

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

  100.             } CARLA_SAFE_EXCEPTION("loadFile");

  101. 

  102.             delete[] filename;

  103.         }

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

  105.         {

  106.             const char* filename;

  107. 

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

  109. 

  110.             try {

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

  112.             } CARLA_SAFE_EXCEPTION("loadProject");

  113. 

  114.             delete[] filename;

  115.         }

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

  117.         {

  118.             const char* filename;

  119. 

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

  121. 

  122.             try {

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

  124.             } CARLA_SAFE_EXCEPTION("saveProject");

  125. 

  126.             delete[] filename;

  127.         }

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

  129.         {

  130.             uint32_t groupA, portA, groupB, portB;

  131. 

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

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

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

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

  136. 

  137.             try {

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

  139.             } CARLA_SAFE_EXCEPTION("patchbayConnect");

  140.         }

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

  142.         {

  143.             uint32_t connectionId;

  144. 

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

  146. 

  147.             try {

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

  149.             } CARLA_SAFE_EXCEPTION("patchbayDisconnect");

  150.         }

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

  152.         {

  153.             try {

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

  155.             } CARLA_SAFE_EXCEPTION("patchbayRefresh");

  156.         }

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

  158.         {

  159.             fEngine->transportPlay();

  160.         }

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

  162.         {

  163.             fEngine->transportPause();

  164.         }

  165.         else if (std::strcmp(msg, "transport_bpm") == 0)

  166.         {

  167.             double bpm;

  168. 

  169.             CARLA_SAFE_ASSERT_RETURN(readNextLineAsDouble(bpm), true);

  170. 

  171.             fEngine->transportBPM(bpm);

  172.         }

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

  174.         {

  175.             uint64_t frame;

  176. 

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

  178. 

  179.             fEngine->transportRelocate(frame);

  180.         }

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

  182.         {

  183.             uint32_t btype, ptype;

  184.             const char* filename = nullptr;

  185.             const char* name;

  186.             const char* label;

  187.             int64_t uniqueId;

  188.             uint options;

  189. 

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

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

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

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

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

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

  196.             CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(options), true);

  197. 

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

  199.             {

  200.                 delete[] filename;

  201.                 filename = nullptr;

  202.             }

  203. 

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

  205.             {

  206.                 delete[] name;

  207.                 name = nullptr;

  208.             }

  209. 

  210.             ok = fEngine->addPlugin(static_cast<BinaryType>(btype), static_cast<PluginType>(ptype),

  211.                                     filename, name, label, uniqueId, nullptr, options);

  212. 

  213.             if (filename != nullptr)

  214.                 delete[] filename;

  215.             if (name != nullptr)

  216.                 delete[] name;

  217.             delete[] label;

  218.         }

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

  220.         {

  221.             uint32_t pluginId;

  222. 

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

  224. 

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

  226.         }

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

  228.         {

  229.             ok = fEngine->removeAllPlugins();

  230.         }

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

  232.         {

  233.             uint32_t pluginId;

  234.             const char* newName;

  235. 

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

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

  238. 

  239.             // TODO

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

  241. 

  242.             delete[] newName;

  243.         }

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

  245.         {

  246.             uint32_t pluginId;

  247. 

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

  249. 

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

  251.         }

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

  253.         {

  254.             uint32_t pluginId;

  255. 

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

  257. 

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

  259.         }

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

  261.         {

  262.             uint32_t pluginIdA, pluginIdB;

  263. 

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

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

  266. 

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

  268.         }

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

  270.         {

  271.             uint32_t pluginId;

  272.             const char* filename;

  273. 

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

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

  276. 

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

  278.                 plugin->loadStateFromFile(filename);

  279. 

  280.             delete[] filename;

  281.         }

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

  283.         {

  284.             uint32_t pluginId;

  285.             const char* filename;

  286. 

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

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

  289. 

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

  291.                 plugin->saveStateToFile(filename);

  292. 

  293.             delete[] filename;

  294.         }

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

  296.         {

  297.             uint32_t pluginId, option;

  298.             bool yesNo;

  299. 

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

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

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

  303. 

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

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

  306.         }

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

  308.         {

  309.             uint32_t pluginId;

  310.             bool onOff;

  311. 

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

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

  314. 

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

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

  317.         }

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

  319.         {

  320.             uint32_t pluginId;

  321.             float value;

  322. 

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

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

  325. 

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

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

  328.         }

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

  330.         {

  331.             uint32_t pluginId;

  332.             float value;

  333. 

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

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

  336. 

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

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

  339.         }

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

  341.         {

  342.             uint32_t pluginId;

  343.             float value;

  344. 

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

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

  347. 

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

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

  350.         }

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

  352.         {

  353.             uint32_t pluginId;

  354.             float value;

  355. 

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

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

  358. 

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

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

  361.         }

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

  363.         {

  364.             uint32_t pluginId;

  365.             float value;

  366. 

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

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

  369. 

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

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

  372.         }

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

  374.         {

  375.             uint32_t pluginId;

  376.             int32_t channel;

  377. 

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

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

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

  381. 

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

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

  384.         }

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

  386.         {

  387.             uint32_t pluginId, parameterId;

  388.             float value;

  389. 

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

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

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

  393. 

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

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

  396.         }

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

  398.         {

  399.             uint32_t pluginId, parameterId, channel;

  400. 

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

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

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

  404.             CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS, true);

  405. 

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

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

  408.         }

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

  410.         {

  411.             uint32_t pluginId, parameterId;

  412.             int32_t cc;

  413. 

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

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

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

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

  418. 

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

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

  421.         }

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

  423.         {

  424.             uint32_t pluginId;

  425.             int32_t index;

  426. 

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

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

  429. 

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

  431.             {

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

  433.                 _updateParamValues(plugin, pluginId);

  434.             }

  435.         }

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

  437.         {

  438.             uint32_t pluginId;

  439.             int32_t index;

  440. 

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

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

  443. 

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

  445.             {

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

  447.                 _updateParamValues(plugin, pluginId);

  448.             }

  449.         }

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

  451.         {

  452.             uint32_t pluginId;

  453.             const char* type;

  454.             const char* key;

  455.             const char* value;

  456. 

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

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

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

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

  461. 

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

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

  464. 

  465.             delete[] type;

  466.             delete[] key;

  467.             delete[] value;

  468.         }

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

  470.         {

  471.             uint32_t pluginId;

  472.             const char* cdata;

  473. 

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

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

  476. 

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

  478.             {

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

  480. #ifdef CARLA_PROPER_CPP11_SUPPORT

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

  482. #else

  483.                 plugin->setChunkData(&chunk.front(), chunk.size());

  484. #endif

  485.             }

  486. 

  487.             delete[] cdata;

  488.         }

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

  490.         {

  491.             uint32_t pluginId;

  492. 

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

  494. 

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

  496.                 plugin->prepareForSave();

  497.         }

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

  499.         {

  500.             uint32_t pluginId;

  501. 

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

  503. 

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

  505.                 plugin->resetParameters();

  506.         }

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

  508.         {

  509.             uint32_t pluginId;

  510. 

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

  512. 

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

  514.                 plugin->randomizeParameters();

  515.         }

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

  517.         {

  518.             uint32_t pluginId, channel, note, velocity;

  519. 

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

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

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

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

  524.             CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS, true);

  525.             CARLA_SAFE_ASSERT_RETURN(note < MAX_MIDI_VALUE, true);

  526.             CARLA_SAFE_ASSERT_RETURN(velocity < MAX_MIDI_VALUE, true);

  527. 

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

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

  530.         }

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

  532.         {

  533.             uint32_t pluginId;

  534.             bool yesNo;

  535. 

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

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

  538. 

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

  540.                 plugin->showCustomUI(yesNo);

  541.         }

  542.         else

  543.         {

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

  545.             return false;

  546.         }

  547. 

  548.         if (! ok)

  549.         {

  550.             const CarlaMutexLocker cml(getPipeLock());

  551. 

  552.             if (writeMessage("error\n", 6) && writeAndFixMessage(fEngine->getLastError()))

  553.                 flushMessages();

  554.         }

  555. 

  556.         return true;

  557.     }

  558. 

  559. private:

  560.     CarlaEngine* const fEngine;

  561. 

  562.     void _updateParamValues(CarlaPlugin* const plugin, const uint32_t pluginId) const noexcept

  563.     {

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

  565.             fEngine->callback(ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED,

  566.                               pluginId, static_cast<int>(i), 0, plugin->getParameterValue(i), nullptr);

  567.     }

  568. 

  569.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaEngineNativeUI)

  570. };

  571. 

  572. // -----------------------------------------------------------------------

  573. 

  574. class CarlaEngineNative : public CarlaEngine

  575. {

  576. public:

  577.     CarlaEngineNative(const NativeHostDescriptor* const host, const bool isPatchbay, const bool withMidiOut,

  578.                       const uint32_t inChan = 2, uint32_t outChan = 2)

  579.         : CarlaEngine(),

  580.           pHost(host),

  581.           kIsPatchbay(isPatchbay),

  582.           kHasMidiOut(withMidiOut),

  583.           fIsActive(false),

  584.           fIsRunning(false),

  585.           fUiServer(this),

  586.           fOptionsForced(false)

  587.     {

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

  589. 

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

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

  592.         pData->initTime(nullptr);

  593. 

  594.         if (outChan == 0)

  595.             outChan = inChan;

  596. 

  597.         // set-up engine

  598.         if (kIsPatchbay)

  599.         {

  600.             pData->options.processMode         = ENGINE_PROCESS_MODE_PATCHBAY;

  601.             pData->options.transportMode       = ENGINE_TRANSPORT_MODE_PLUGIN;

  602.             pData->options.forceStereo         = false;

  603.             pData->options.preferPluginBridges = false;

  604.             pData->options.preferUiBridges     = false;

  605.             init("Carla-Patchbay");

  606.             pData->graph.create(inChan, outChan);

  607.         }

  608.         else

  609.         {

  610.             CARLA_SAFE_ASSERT(inChan == 2);

  611.             CARLA_SAFE_ASSERT(outChan == 2);

  612.             pData->options.processMode         = ENGINE_PROCESS_MODE_CONTINUOUS_RACK;

  613.             pData->options.transportMode       = ENGINE_TRANSPORT_MODE_PLUGIN;

  614.             pData->options.forceStereo         = true;

  615.             pData->options.preferPluginBridges = false;

  616.             pData->options.preferUiBridges     = false;

  617.             init("Carla-Rack");

  618.             pData->graph.create(0, 0); // FIXME?

  619.         }

  620. 

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

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

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

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

  625. 

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

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

  628. 

  629.         setCallback(_ui_server_callback, this);

  630.         setFileCallback(_ui_file_callback, this);

  631.     }

  632. 

  633.     ~CarlaEngineNative() override

  634.     {

  635.         CARLA_SAFE_ASSERT(! fIsActive);

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

  637. 

  638.         pData->aboutToClose = true;

  639.         fIsRunning = false;

  640. 

  641.         removeAllPlugins();

  642.         //runPendingRtEvents();

  643.         close();

  644. 

  645.         pData->graph.destroy();

  646. 

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

  648.     }

  649. 

  650. protected:

  651.     // -------------------------------------

  652.     // CarlaEngine virtual calls

  653. 

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

  655.     {

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

  657. 

  658.         fIsRunning = true;

  659. 

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

  661.         {

  662.             close();

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

  664.             return false;

  665.         }

  666. 

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

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

  669. 

  670.         return true;

  671.     }

  672. 

  673.     bool close() override

  674.     {

  675.         fIsRunning = false;

  676.         CarlaEngine::close();

  677.         return true;

  678.     }

  679. 

  680.     bool isRunning() const noexcept override

  681.     {

  682.         return fIsRunning;

  683.     }

  684. 

  685.     bool isOffline() const noexcept override

  686.     {

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

  688.     }

  689. 

  690.     bool usesConstantBufferSize() const noexcept override

  691.     {

  692.         // TODO LV2 hosts can report this, till then we allow this

  693.         return true;

  694.     }

  695. 

  696.     EngineType getType() const noexcept override

  697.     {

  698.         return kEngineTypePlugin;

  699.     }

  700. 

  701.     const char* getCurrentDriverName() const noexcept override

  702.     {

  703.         return "Plugin";

  704.     }

  705. 

  706.     void callback(const EngineCallbackOpcode action, const uint pluginId, const int value1, const int value2, const float value3, const char* const valueStr) noexcept override

  707.     {

  708.         CarlaEngine::callback(action, pluginId, value1, value2, value3, valueStr);

  709. 

  710.         if (action == ENGINE_CALLBACK_IDLE && ! pData->aboutToClose)

  711.             pHost->dispatcher(pHost->handle, NATIVE_HOST_OPCODE_HOST_IDLE, 0, 0, nullptr, 0.0f);

  712.     }

  713. 

  714.     // -------------------------------------------------------------------

  715. 

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

  717.     {

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

  719.         {

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

  721.             return retName;

  722.         }

  723. 

  724.         return nullptr;

  725.     }

  726. 

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

  728. 

  729.     void bufferSizeChanged(const uint32_t newBufferSize)

  730.     {

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

  732.             return;

  733. 

  734.         {

  735.             const CarlaMutexLocker cml(fUiServer.getPipeLock());

  736. 

  737.             if (fUiServer.writeAndFixMessage("buffer-size"))

  738.             {

  739.                 char tmpBuf[STR_MAX];

  740.                 carla_zeroChars(tmpBuf, STR_MAX);

  741. 

  742.                 std::sprintf(tmpBuf, "%i\n", newBufferSize);

  743. 

  744.                 if (fUiServer.writeMessage(tmpBuf))

  745.                     fUiServer.flushMessages();

  746.             }

  747.         }

  748. 

  749.         pData->bufferSize = newBufferSize;

  750.         CarlaEngine::bufferSizeChanged(newBufferSize);

  751.     }

  752. 

  753.     void sampleRateChanged(const double newSampleRate)

  754.     {

  755.         if (carla_isEqual(pData->sampleRate, newSampleRate))

  756.             return;

  757. 

  758.         {

  759.             const CarlaMutexLocker cml(fUiServer.getPipeLock());

  760. 

  761.             if (fUiServer.writeAndFixMessage("sample-rate"))

  762.             {

  763.                 char tmpBuf[STR_MAX];

  764.                 carla_zeroChars(tmpBuf, STR_MAX);

  765. 

  766.                 {

  767.                     const ScopedLocale csl;

  768.                     std::sprintf(tmpBuf, "%f\n", newSampleRate);

  769.                 }

  770. 

  771.                 if (fUiServer.writeMessage(tmpBuf))

  772.                     fUiServer.flushMessages();

  773.             }

  774.         }

  775. 

  776.         pData->sampleRate = newSampleRate;

  777.         CarlaEngine::sampleRateChanged(newSampleRate);

  778.     }

  779. 

  780.     // -------------------------------------------------------------------

  781. 

  782.     void uiServerSendPluginInfo(CarlaPlugin* const plugin)

  783.     {

  784.         char tmpBuf[STR_MAX];

  785.         carla_zeroChars(tmpBuf, STR_MAX);

  786. 

  787.         const CarlaMutexLocker cml(fUiServer.getPipeLock());

  788. 

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

  790. 

  791.         std::sprintf(tmpBuf, "PLUGIN_INFO_%i\n", pluginId);

  792.         if (! fUiServer.writeMessage(tmpBuf))

  793.             return;

  794. 

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

  796.         if (! fUiServer.writeMessage(tmpBuf))

  797.             return;

  798. 

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

  800.         {

  801.             std::sprintf(tmpBuf, "%s", filename);

  802.             if (! fUiServer.writeAndFixMessage(tmpBuf))

  803.                 return;

  804.         }

  805.         else

  806.         {

  807.             if (! fUiServer.writeMessage("\n"))

  808.                 return;

  809.         }

  810. 

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

  812.         {

  813.             std::sprintf(tmpBuf, "%s", name);

  814.             if (! fUiServer.writeAndFixMessage(tmpBuf))

  815.                 return;

  816.         }

  817.         else

  818.         {

  819.             if (! fUiServer.writeMessage("\n"))

  820.                 return;

  821.         }

  822. 

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

  824.         {

  825.             std::sprintf(tmpBuf, "%s", iconName);

  826.             if (! fUiServer.writeAndFixMessage(tmpBuf))

  827.                 return;

  828.         }

  829.         else

  830.         {

  831.             if (! fUiServer.writeMessage("\n"))

  832.                 return;

  833.         }

  834. 

  835.         plugin->getRealName(tmpBuf);

  836.         if (! fUiServer.writeAndFixMessage(tmpBuf))

  837.             return;

  838. 

  839.         plugin->getLabel(tmpBuf);

  840.         if (! fUiServer.writeAndFixMessage(tmpBuf))

  841.             return;

  842. 

  843.         plugin->getMaker(tmpBuf);

  844.         if (! fUiServer.writeAndFixMessage(tmpBuf))

  845.             return;

  846. 

  847.         plugin->getCopyright(tmpBuf);

  848.         if (! fUiServer.writeAndFixMessage(tmpBuf))

  849.             return;

  850. 

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

  852.         if (! fUiServer.writeMessage(tmpBuf))

  853.             return;

  854. 

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

  856.         if (! fUiServer.writeMessage(tmpBuf))

  857.             return;

  858. 

  859.         fUiServer.flushMessages();

  860.     }

  861. 

  862.     void uiServerSendPluginParameters(CarlaPlugin* const plugin)

  863.     {

  864.         char tmpBuf[STR_MAX];

  865.         carla_zeroChars(tmpBuf, STR_MAX);

  866. 

  867.         const CarlaMutexLocker cml(fUiServer.getPipeLock());

  868.         const ScopedLocale csl;

  869. 

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

  871. 

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

  873.         {

  874.             std::sprintf(tmpBuf, "PARAMVAL_%i:%i\n", pluginId, i);

  875.             if (! fUiServer.writeMessage(tmpBuf))

  876.                 return;

  877. 

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

  879.             if (! fUiServer.writeMessage(tmpBuf))

  880.                 return;

  881. 

  882.             fUiServer.flushMessages();

  883.         }

  884. 

  885.         uint32_t ins, outs, count;

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

  887.         count = plugin->getParameterCount();

  888. 

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

  890.         if (! fUiServer.writeMessage(tmpBuf))

  891.             return;

  892. 

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

  894.         {

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

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

  897. 

  898.             std::sprintf(tmpBuf, "PARAMETER_DATA_%i:%i\n", pluginId, i);

  899.             if (! fUiServer.writeMessage(tmpBuf))

  900.                 return;

  901. 

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

  903.             if (! fUiServer.writeMessage(tmpBuf))

  904.                 return;

  905. 

  906.             plugin->getParameterName(i, tmpBuf);

  907.             if (! fUiServer.writeAndFixMessage(tmpBuf))

  908.                 return;

  909. 

  910.             plugin->getParameterUnit(i, tmpBuf);

  911.             if (! fUiServer.writeAndFixMessage(tmpBuf))

  912.                 return;

  913. 

  914.             std::sprintf(tmpBuf, "PARAMETER_RANGES_%i:%i\n", pluginId, i);

  915.             if (! fUiServer.writeMessage(tmpBuf))

  916.                 return;

  917. 

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

  919.             if (! fUiServer.writeMessage(tmpBuf))

  920.                 return;

  921. 

  922.             std::sprintf(tmpBuf, "PARAMVAL_%i:%i\n", pluginId, i);

  923.             if (! fUiServer.writeMessage(tmpBuf))

  924.                 return;

  925. 

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

  927.             if (! fUiServer.writeMessage(tmpBuf))

  928.                 return;

  929.         }

  930. 

  931.         fUiServer.flushMessages();

  932.     }

  933. 

  934.     void uiServerSendPluginPrograms(CarlaPlugin* const plugin)

  935.     {

  936.         char tmpBuf[STR_MAX];

  937.         carla_zeroChars(tmpBuf, STR_MAX);

  938. 

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

  940. 

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

  942. 

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

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

  945.         if (! fUiServer.writeMessage(tmpBuf))

  946.             return;

  947. 

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

  949.         {

  950.             std::sprintf(tmpBuf, "PROGRAM_NAME_%i:%i\n", pluginId, i);

  951.             if (! fUiServer.writeMessage(tmpBuf))

  952.                 return;

  953. 

  954.             plugin->getProgramName(i, tmpBuf);

  955.             if (! fUiServer.writeAndFixMessage(tmpBuf))

  956.                 return;

  957.         }

  958. 

  959.         fUiServer.flushMessages();

  960. 

  961.         count = plugin->getMidiProgramCount();

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

  963.         if (! fUiServer.writeMessage(tmpBuf))

  964.             return;

  965. 

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

  967.         {

  968.             std::sprintf(tmpBuf, "MIDI_PROGRAM_DATA_%i:%i\n", pluginId, i);

  969.             if (! fUiServer.writeMessage(tmpBuf))

  970.                 return;

  971. 

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

  973. 

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

  975.             if (! fUiServer.writeMessage(tmpBuf))

  976.                 return;

  977. 

  978.             std::sprintf(tmpBuf, "%s", mpData.name);

  979.             if (! fUiServer.writeAndFixMessage(tmpBuf))

  980.                 return;

  981.         }

  982. 

  983.         fUiServer.flushMessages();

  984.     }

  985. 

  986.     void uiServerSendPluginProperties(CarlaPlugin* const plugin)

  987.     {

  988.         char tmpBuf[STR_MAX];

  989.         carla_zeroChars(tmpBuf, STR_MAX);

  990. 

  991.         const CarlaMutexLocker cml(fUiServer.getPipeLock());

  992. 

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

  994. 

  995.         uint32_t count = plugin->getCustomDataCount();

  996.         std::sprintf(tmpBuf, "CUSTOM_DATA_COUNT_%i:%i\n", pluginId, count);

  997.         if (! fUiServer.writeMessage(tmpBuf))

  998.             return;

  999. 

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

  1001.         {

  1002.             const CustomData& customData(plugin->getCustomData(i));

  1003.             CARLA_SAFE_ASSERT_CONTINUE(customData.isValid());

  1004. 

  1005.             if (std::strcmp(customData.type, CUSTOM_DATA_TYPE_PROPERTY) != 0)

  1006.                 continue;

  1007. 

  1008.             std::sprintf(tmpBuf, "CUSTOM_DATA_%i:%i\n", pluginId, i);

  1009.             if (! fUiServer.writeMessage(tmpBuf))

  1010.                 return;

  1011. 

  1012.             if (! fUiServer.writeAndFixMessage(customData.type))

  1013.                 return;

  1014.             if (! fUiServer.writeAndFixMessage(customData.key))

  1015.                 return;

  1016.             if (! fUiServer.writeAndFixMessage(customData.value))

  1017.                 return;

  1018.         }

  1019. 

  1020.         fUiServer.flushMessages();

  1021.     }

  1022. 

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

  1024.     {

  1025.         if (! fIsRunning)

  1026.             return;

  1027.         if (! fUiServer.isPipeRunning())

  1028.             return;

  1029. 

  1030.         CarlaPlugin* plugin;

  1031. 

  1032.         switch (action)

  1033.         {

  1034.         case ENGINE_CALLBACK_UPDATE:

  1035.             plugin = getPlugin(pluginId);

  1036. 

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

  1038.             {

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

  1040.                 uiServerSendPluginProperties(plugin);

  1041.             }

  1042.             break;

  1043. 

  1044.         case ENGINE_CALLBACK_RELOAD_INFO:

  1045.             plugin = getPlugin(pluginId);

  1046. 

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

  1048.             {

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

  1050.                 uiServerSendPluginInfo(plugin);

  1051.             }

  1052.             break;

  1053. 

  1054.         case ENGINE_CALLBACK_RELOAD_PARAMETERS:

  1055.             plugin = getPlugin(pluginId);

  1056. 

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

  1058.             {

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

  1060.                 uiServerSendPluginParameters(plugin);

  1061.             }

  1062.             break;

  1063. 

  1064.         case ENGINE_CALLBACK_RELOAD_PROGRAMS:

  1065.             plugin = getPlugin(pluginId);

  1066. 

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

  1068.             {

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

  1070.                 uiServerSendPluginPrograms(plugin);

  1071.             }

  1072.             break;

  1073. 

  1074.         case ENGINE_CALLBACK_RELOAD_ALL:

  1075.         case ENGINE_CALLBACK_PLUGIN_ADDED:

  1076.             plugin = getPlugin(pluginId);

  1077. 

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

  1079.             {

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

  1081.                 uiServerSendPluginInfo(plugin);

  1082.                 uiServerSendPluginParameters(plugin);

  1083.                 uiServerSendPluginPrograms(plugin);

  1084.                 uiServerSendPluginProperties(plugin);

  1085.             }

  1086.             break;

  1087. 

  1088.         default:

  1089.             break;

  1090.         }

  1091. 

  1092.         char tmpBuf[STR_MAX];

  1093.         carla_zeroChars(tmpBuf, STR_MAX);

  1094. 

  1095.         const CarlaMutexLocker cml(fUiServer.getPipeLock());

  1096. 

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

  1098.         if (! fUiServer.writeMessage(tmpBuf))

  1099.             return;

  1100.         std::sprintf(tmpBuf, "%u\n", pluginId);

  1101.         if (! fUiServer.writeMessage(tmpBuf))

  1102.             return;

  1103.         std::sprintf(tmpBuf, "%i\n", value1);

  1104.         if (! fUiServer.writeMessage(tmpBuf))

  1105.             return;

  1106.         std::sprintf(tmpBuf, "%i\n", value2);

  1107.         if (! fUiServer.writeMessage(tmpBuf))

  1108.             return;

  1109.         {

  1110.             const ScopedLocale csl;

  1111.             std::sprintf(tmpBuf, "%f\n", value3);

  1112.         }

  1113.         if (! fUiServer.writeMessage(tmpBuf))

  1114.             return;

  1115.         if (! fUiServer.writeAndFixMessage(valueStr != nullptr ? valueStr : ""))

  1116.             return;

  1117. 

  1118.         fUiServer.flushMessages();

  1119.     }

  1120. 

  1121.     const char* uiFileCallback(FileCallbackOpcode action, bool isDir, const char* title, const char* filter)

  1122.     {

  1123.         switch (action)

  1124.         {

  1125.         case FILE_CALLBACK_DEBUG:

  1126.             return nullptr;

  1127. 

  1128.         case FILE_CALLBACK_OPEN:

  1129.             return pHost->ui_open_file(pHost->handle, isDir, title, filter);

  1130. 

  1131.         case FILE_CALLBACK_SAVE:

  1132.             return pHost->ui_save_file(pHost->handle, isDir, title, filter);

  1133.         }

  1134. 

  1135.         return nullptr;

  1136.     }

  1137. 

  1138.     void uiServerInfo()

  1139.     {

  1140.         CARLA_SAFE_ASSERT_RETURN(fIsRunning,);

  1141.         CARLA_SAFE_ASSERT_RETURN(fUiServer.isPipeRunning(),);

  1142. 

  1143.         char tmpBuf[STR_MAX];

  1144.         carla_zeroChars(tmpBuf, STR_MAX);

  1145. 

  1146.         const CarlaMutexLocker cml(fUiServer.getPipeLock());

  1147. 

  1148. #if defined(HAVE_LIBLO) && !defined(BUILD_BRIDGE)

  1149.         if (! fUiServer.writeAndFixMessage("osc-urls"))

  1150.             return;

  1151.         if (! fUiServer.writeAndFixMessage(pData->osc.getServerPathTCP()))

  1152.             return;

  1153.         if (! fUiServer.writeAndFixMessage(pData->osc.getServerPathUDP()))

  1154.             return;

  1155. #endif

  1156. 

  1157.         if (! fUiServer.writeAndFixMessage("max-plugin-number"))

  1158.             return;

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

  1160.         if (! fUiServer.writeMessage(tmpBuf))

  1161.             return;

  1162. 

  1163.         if (! fUiServer.writeAndFixMessage("buffer-size"))

  1164.             return;

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

  1166.         if (! fUiServer.writeMessage(tmpBuf))

  1167.             return;

  1168. 

  1169.         if (! fUiServer.writeAndFixMessage("sample-rate"))

  1170.             return;

  1171.         {

  1172.             const ScopedLocale csl;

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

  1174.         }

  1175.         if (! fUiServer.writeMessage(tmpBuf))

  1176.             return;

  1177. 

  1178.         fUiServer.flushMessages();

  1179.     }

  1180. 

  1181.     void uiServerOptions()

  1182.     {

  1183.         CARLA_SAFE_ASSERT_RETURN(fIsRunning,);

  1184.         CARLA_SAFE_ASSERT_RETURN(fUiServer.isPipeRunning(),);

  1185. 

  1186.         char tmpBuf[STR_MAX];

  1187.         carla_zeroChars(tmpBuf, STR_MAX);

  1188. 

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

  1190.         const CarlaMutexLocker cml(fUiServer.getPipeLock());

  1191. 

  1192.         const char* const optionsForcedStr(fOptionsForced ? "true\n" : "false\n");

  1193.         const std::size_t optionsForcedStrSize(fOptionsForced ? 5 : 6);

  1194. 

  1195.         std::sprintf(tmpBuf, "ENGINE_OPTION_%i\n", ENGINE_OPTION_PROCESS_MODE);

  1196.         if (! fUiServer.writeMessage(tmpBuf))

  1197.             return;

  1198.         if (! fUiServer.writeMessage(optionsForcedStr, optionsForcedStrSize))

  1199.             return;

  1200.         std::sprintf(tmpBuf, "%i\n", options.processMode);

  1201.         if (! fUiServer.writeMessage(tmpBuf))

  1202.             return;

  1203.         fUiServer.flushMessages();

  1204. 

  1205.         std::sprintf(tmpBuf, "ENGINE_OPTION_%i\n", ENGINE_OPTION_TRANSPORT_MODE);

  1206.         if (! fUiServer.writeMessage(tmpBuf))

  1207.             return;

  1208.         if (! fUiServer.writeMessage(optionsForcedStr, optionsForcedStrSize))

  1209.             return;

  1210.         std::sprintf(tmpBuf, "%i\n", options.transportMode);

  1211.         if (! fUiServer.writeMessage(tmpBuf))

  1212.             return;

  1213.         fUiServer.flushMessages();

  1214. 

  1215.         std::sprintf(tmpBuf, "ENGINE_OPTION_%i\n", ENGINE_OPTION_FORCE_STEREO);

  1216.         if (! fUiServer.writeMessage(tmpBuf))

  1217.             return;

  1218.         if (! fUiServer.writeMessage(optionsForcedStr, optionsForcedStrSize))

  1219.             return;

  1220.         if (! fUiServer.writeMessage(options.forceStereo ? "true\n" : "false\n"))

  1221.             return;

  1222.         fUiServer.flushMessages();

  1223. 

  1224.         std::sprintf(tmpBuf, "ENGINE_OPTION_%i\n", ENGINE_OPTION_PREFER_PLUGIN_BRIDGES);

  1225.         if (! fUiServer.writeMessage(tmpBuf))

  1226.             return;

  1227.         if (! fUiServer.writeMessage(optionsForcedStr, optionsForcedStrSize))

  1228.             return;

  1229.         if (! fUiServer.writeMessage(options.preferPluginBridges ? "true\n" : "false\n"))

  1230.             return;

  1231.         fUiServer.flushMessages();

  1232. 

  1233.         std::sprintf(tmpBuf, "ENGINE_OPTION_%i\n", ENGINE_OPTION_PREFER_UI_BRIDGES);

  1234.         if (! fUiServer.writeMessage(tmpBuf))

  1235.             return;

  1236.         if (! fUiServer.writeMessage(optionsForcedStr, optionsForcedStrSize))

  1237.             return;

  1238.         if (! fUiServer.writeMessage(options.preferUiBridges ? "true\n" : "false\n"))

  1239.             return;

  1240.         fUiServer.flushMessages();

  1241. 

  1242.         std::sprintf(tmpBuf, "ENGINE_OPTION_%i\n", ENGINE_OPTION_UIS_ALWAYS_ON_TOP);

  1243.         if (! fUiServer.writeMessage(tmpBuf))

  1244.             return;

  1245.         if (! fUiServer.writeMessage(optionsForcedStr, optionsForcedStrSize))

  1246.             return;

  1247.         if (! fUiServer.writeMessage(options.uisAlwaysOnTop ? "true\n" : "false\n"))

  1248.             return;

  1249.         fUiServer.flushMessages();

  1250. 

  1251.         std::sprintf(tmpBuf, "ENGINE_OPTION_%i\n", ENGINE_OPTION_MAX_PARAMETERS);

  1252.         if (! fUiServer.writeMessage(tmpBuf))

  1253.             return;

  1254.         if (! fUiServer.writeMessage(optionsForcedStr, optionsForcedStrSize))

  1255.             return;

  1256.         std::sprintf(tmpBuf, "%i\n", options.maxParameters);

  1257.         if (! fUiServer.writeMessage(tmpBuf))

  1258.             return;

  1259.         fUiServer.flushMessages();

  1260. 

  1261.         std::sprintf(tmpBuf, "ENGINE_OPTION_%i\n", ENGINE_OPTION_UI_BRIDGES_TIMEOUT);

  1262.         if (! fUiServer.writeMessage(tmpBuf))

  1263.             return;

  1264.         if (! fUiServer.writeMessage(optionsForcedStr, optionsForcedStrSize))

  1265.             return;

  1266.         std::sprintf(tmpBuf, "%i\n", options.uiBridgesTimeout);

  1267.         if (! fUiServer.writeMessage(tmpBuf))

  1268.             return;

  1269.         fUiServer.flushMessages();

  1270. 

  1271.         std::sprintf(tmpBuf, "ENGINE_OPTION_%i\n", ENGINE_OPTION_PATH_BINARIES);

  1272.         if (! fUiServer.writeMessage(tmpBuf))

  1273.             return;

  1274.         if (! fUiServer.writeMessage("true\n", 5))

  1275.             return;

  1276.         std::sprintf(tmpBuf, "%s\n", options.binaryDir);

  1277.         if (! fUiServer.writeMessage(tmpBuf))

  1278.             return;

  1279.         fUiServer.flushMessages();

  1280. 

  1281.         std::sprintf(tmpBuf, "ENGINE_OPTION_%i\n", ENGINE_OPTION_PATH_RESOURCES);

  1282.         if (! fUiServer.writeMessage(tmpBuf))

  1283.             return;

  1284.         if (! fUiServer.writeMessage("true\n", 5))

  1285.             return;

  1286.         std::sprintf(tmpBuf, "%s\n", options.resourceDir);

  1287.         if (! fUiServer.writeMessage(tmpBuf))

  1288.             return;

  1289.         fUiServer.flushMessages();

  1290.     }

  1291. 

  1292.     // -------------------------------------------------------------------

  1293.     // Plugin parameter calls

  1294. 

  1295.     uint32_t getParameterCount() const

  1296.     {

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

  1298.             return plugin->getParameterCount();

  1299. 

  1300.         return 0;

  1301.     }

  1302. 

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

  1304.     {

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

  1306.         {

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

  1308.             {

  1309.                 static NativeParameter param;

  1310.                 static char strBufName[STR_MAX+1];

  1311.                 static char strBufUnit[STR_MAX+1];

  1312. 

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

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

  1315. 

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

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

  1318. 

  1319.                 uint hints = 0x0;

  1320. 

  1321.                 if (paramData.hints & PARAMETER_IS_BOOLEAN)

  1322.                     hints |= NATIVE_PARAMETER_IS_BOOLEAN;

  1323.                 if (paramData.hints & PARAMETER_IS_INTEGER)

  1324.                     hints |= NATIVE_PARAMETER_IS_INTEGER;

  1325.                 if (paramData.hints & PARAMETER_IS_LOGARITHMIC)

  1326.                     hints |= NATIVE_PARAMETER_IS_LOGARITHMIC;

  1327.                 if (paramData.hints & PARAMETER_IS_AUTOMABLE)

  1328.                     hints |= NATIVE_PARAMETER_IS_AUTOMABLE;

  1329.                 if (paramData.hints & PARAMETER_USES_SAMPLERATE)

  1330.                     hints |= NATIVE_PARAMETER_USES_SAMPLE_RATE;

  1331.                 if (paramData.hints & PARAMETER_USES_SCALEPOINTS)

  1332.                     hints |= NATIVE_PARAMETER_USES_SCALEPOINTS;

  1333. 

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

  1335.                 {

  1336.                     if (paramData.hints & PARAMETER_IS_ENABLED)

  1337.                         hints |= NATIVE_PARAMETER_IS_ENABLED;

  1338.                     if (paramData.type == PARAMETER_OUTPUT)

  1339.                         hints |= NATIVE_PARAMETER_IS_OUTPUT;

  1340.                 }

  1341. 

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

  1343.                 param.name  = strBufName;

  1344.                 param.unit  = strBufUnit;

  1345.                 param.ranges.def = paramRanges.def;

  1346.                 param.ranges.min = paramRanges.min;

  1347.                 param.ranges.max = paramRanges.max;

  1348.                 param.ranges.step = paramRanges.step;

  1349.                 param.ranges.stepSmall = paramRanges.stepSmall;

  1350.                 param.ranges.stepLarge = paramRanges.stepLarge;

  1351.                 param.scalePointCount = 0; // TODO

  1352.                 param.scalePoints = nullptr;

  1353. 

  1354.                 return &param;

  1355.             }

  1356.         }

  1357. 

  1358.         return nullptr;

  1359.     }

  1360. 

  1361.     float getParameterValue(const uint32_t index) const

  1362.     {

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

  1364.         {

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

  1366.                 return plugin->getParameterValue(index);

  1367.         }

  1368. 

  1369.         return 0.0f;

  1370.     }

  1371. 

  1372.     // -------------------------------------------------------------------

  1373.     // Plugin midi-program calls

  1374. 

  1375.     uint32_t getMidiProgramCount() const

  1376.     {

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

  1378.             return plugin->getMidiProgramCount();

  1379. 

  1380.         return 0;

  1381.     }

  1382. 

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

  1384.     {

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

  1386.         {

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

  1388.             {

  1389.                 static NativeMidiProgram midiProg;

  1390. 

  1391.                 {

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

  1393. 

  1394.                     midiProg.bank    = midiProgData.bank;

  1395.                     midiProg.program = midiProgData.program;

  1396.                     midiProg.name    = midiProgData.name;

  1397.                 }

  1398. 

  1399.                 return &midiProg;

  1400.             }

  1401.         }

  1402. 

  1403.         return nullptr;

  1404.     }

  1405. 

  1406.     // -------------------------------------------------------------------

  1407.     // Plugin state calls

  1408. 

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

  1410.     {

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

  1412.         {

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

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

  1415.         }

  1416.     }

  1417. 

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

  1419.     {

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

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

  1422.     }

  1423. 

  1424.     // -------------------------------------------------------------------

  1425.     // Plugin process calls

  1426. 

  1427.     void activate()

  1428.     {

  1429. #if 0

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

  1431.         {

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

  1433. 

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

  1435.                 continue;

  1436. 

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

  1438.         }

  1439. #endif

  1440.         fIsActive = true;

  1441.     }

  1442. 

  1443.     void deactivate()

  1444.     {

  1445.         fIsActive = false;

  1446. #if 0

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

  1448.         {

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

  1450. 

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

  1452.                 continue;

  1453. 

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

  1455.         }

  1456. #endif

  1457. 

  1458.         // just in case

  1459.         //runPendingRtEvents();

  1460.     }

  1461. 

  1462.     void process(float** const inBuffer, float** const outBuffer, const uint32_t frames,

  1463.                  const NativeMidiEvent* const midiEvents, const uint32_t midiEventCount)

  1464.     {

  1465.         const PendingRtEventsRunner prt(this, frames);

  1466. 

  1467.         // ---------------------------------------------------------------

  1468.         // Time Info

  1469. 

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

  1471. 

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

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

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

  1475.         pData->timeInfo.bbt.valid = timeInfo->bbt.valid;

  1476. 

  1477.         if (timeInfo->bbt.valid)

  1478.         {

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

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

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

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

  1483. 

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

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

  1486. 

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

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

  1489.         }

  1490. 

  1491.         // ---------------------------------------------------------------

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

  1493. 

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

  1495.         {

  1496.             if (outBuffer[0] != inBuffer[0])

  1497.                 carla_copyFloats(outBuffer[0], inBuffer[0], frames);

  1498. 

  1499.             if (outBuffer[1] != inBuffer[1])

  1500.                 carla_copyFloats(outBuffer[1], inBuffer[1], frames);

  1501. 

  1502.             for (uint32_t i=0; i < midiEventCount; ++i)

  1503.             {

  1504.                 if (! pHost->write_midi_event(pHost->handle, &midiEvents[i]))

  1505.                     break;

  1506.             }

  1507.             return;

  1508.         }

  1509. 

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

  1511.         // initialize events

  1512. 

  1513.         carla_zeroStructs(pData->events.in,  kMaxEngineEventInternalCount);

  1514.         carla_zeroStructs(pData->events.out, kMaxEngineEventInternalCount);

  1515. 

  1516.         // ---------------------------------------------------------------

  1517.         // events input (before processing)

  1518. 

  1519.         {

  1520.             uint32_t engineEventIndex = 0;

  1521. 

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

  1523.             {

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

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

  1526. 

  1527.                 engineEvent.time = midiEvent.time;

  1528.                 engineEvent.fillFromMidiData(midiEvent.size, midiEvent.data, 0);

  1529. 

  1530.                 if (engineEventIndex >= kMaxEngineEventInternalCount)

  1531.                     break;

  1532.             }

  1533.         }

  1534. 

  1535.         if (kIsPatchbay)

  1536.         {

  1537.             // -----------------------------------------------------------

  1538.             // process

  1539. 

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

  1541.         }

  1542.         else

  1543.         {

  1544.             // -----------------------------------------------------------

  1545.             // create audio buffers

  1546. 

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

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

  1549. 

  1550.             // -----------------------------------------------------------

  1551.             // process

  1552. 

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

  1554.         }

  1555. 

  1556.         // ---------------------------------------------------------------

  1557.         // events output (after processing)

  1558. 

  1559.         carla_zeroStructs(pData->events.in, kMaxEngineEventInternalCount);

  1560. 

  1561.         if (kHasMidiOut)

  1562.         {

  1563.             NativeMidiEvent midiEvent;

  1564. 

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

  1566.             {

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

  1568. 

  1569.                 if (engineEvent.type == kEngineEventTypeNull)

  1570.                     break;

  1571. 

  1572.                 carla_zeroStruct(midiEvent);

  1573.                 midiEvent.time = engineEvent.time;

  1574. 

  1575.                 /**/ if (engineEvent.type == kEngineEventTypeControl)

  1576.                 {

  1577.                     midiEvent.port = 0;

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

  1579.                 }

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

  1581.                 {

  1582.                     if (engineEvent.midi.size > 4)

  1583.                         continue;

  1584. 

  1585.                     midiEvent.port = engineEvent.midi.port;

  1586.                     midiEvent.size = engineEvent.midi.size;

  1587. 

  1588.                     midiEvent.data[0] = static_cast<uint8_t>(engineEvent.midi.data[0] | (engineEvent.channel & MIDI_CHANNEL_BIT));

  1589. 

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

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

  1592.                 }

  1593.                 else

  1594.                 {

  1595.                     continue;

  1596.                 }

  1597. 

  1598.                 if (midiEvent.size > 0)

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

  1600.             }

  1601.         }

  1602.     }

  1603. 

  1604.     // -------------------------------------------------------------------

  1605.     // Plugin UI calls

  1606. 

  1607.     void uiShow(const bool show)

  1608.     {

  1609.         if (show)

  1610.         {

  1611.             if (fUiServer.isPipeRunning())

  1612.             {

  1613.                 fUiServer.writeFocusMessage();

  1614.                 return;

  1615.             }

  1616. 

  1617.             CarlaString path(pHost->resourceDir);

  1618. 

  1619.             if (kIsPatchbay)

  1620.                 path += CARLA_OS_SEP_STR "carla-plugin-patchbay";

  1621.             else

  1622.                 path += CARLA_OS_SEP_STR "carla-plugin";

  1623. #ifdef CARLA_OS_WIN

  1624.             path += ".exe";

  1625. #endif

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

  1627. 

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

  1629. 

  1630.             if (! fUiServer.startPipeServer(false))

  1631.             {

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

  1633.                 return;

  1634.             }

  1635. 

  1636.             uiServerInfo();

  1637.             uiServerOptions();

  1638.             uiServerCallback(ENGINE_CALLBACK_ENGINE_STARTED, 0,

  1639.                              pData->options.processMode, pData->options.transportMode,

  1640.                              static_cast<float>(pData->sampleRate), "Plugin");

  1641. 

  1642.             fUiServer.writeShowMessage();

  1643. 

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

  1645.             {

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

  1647. 

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

  1649.                 {

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

  1651.                 }

  1652.             }

  1653. 

  1654.             if (kIsPatchbay)

  1655.                 patchbayRefresh(false);

  1656.         }

  1657.         else

  1658.         {

  1659.             fUiServer.stopPipeServer(2000);

  1660. 

  1661.             // hide all custom uis

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

  1663.             {

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

  1665. 

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

  1667.                 {

  1668.                     if (plugin->getHints() & PLUGIN_HAS_CUSTOM_UI)

  1669.                     {

  1670.                         try {

  1671.                             plugin->showCustomUI(false);

  1672.                         } CARLA_SAFE_EXCEPTION_CONTINUE("Plugin showCustomUI (hide)");

  1673.                     }

  1674.                 }

  1675.             }

  1676.         }

  1677.     }

  1678. 

  1679.     void uiIdle()

  1680.     {

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

  1682.         {

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

  1684. 

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

  1686.             {

  1687.                 const uint hints(plugin->getHints());

  1688. 

  1689.                 if ((hints & PLUGIN_HAS_CUSTOM_UI) != 0 && (hints & PLUGIN_NEEDS_UI_MAIN_THREAD) != 0)

  1690.                 {

  1691.                     try {

  1692.                         plugin->uiIdle();

  1693.                     } CARLA_SAFE_EXCEPTION_CONTINUE("Plugin uiIdle");

  1694.                 }

  1695.             }

  1696.         }

  1697. 

  1698.         idlePipe();

  1699. 

  1700.         switch (fUiServer.getAndResetUiState())

  1701.         {

  1702.         case CarlaExternalUI::UiNone:

  1703.         case CarlaExternalUI::UiShow:

  1704.             break;

  1705.         case CarlaExternalUI::UiCrashed:

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

  1707.             break;

  1708.         case CarlaExternalUI::UiHide:

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

  1710.             fUiServer.stopPipeServer(1000);

  1711.             break;

  1712.         }

  1713.     }

  1714. 

  1715.     void idlePipe()

  1716.     {

  1717.         if (! fUiServer.isPipeRunning())

  1718.             return;

  1719. 

  1720.         fUiServer.idlePipe();

  1721. 

  1722.         char tmpBuf[STR_MAX];

  1723.         carla_zeroChars(tmpBuf, STR_MAX);

  1724. 

  1725.         const CarlaMutexLocker cml(fUiServer.getPipeLock());

  1726.         const ScopedLocale csl;

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

  1728. 

  1729.         // send transport

  1730.         if (! fUiServer.writeAndFixMessage("transport"))

  1731.             return;

  1732.         if (! fUiServer.writeMessage(timeInfo.playing ? "true\n" : "false\n"))

  1733.             return;

  1734. 

  1735.         if (timeInfo.bbt.valid)

  1736.         {

  1737.             std::sprintf(tmpBuf, P_UINT64 ":%i:%i:%i\n",

  1738.                          timeInfo.frame, timeInfo.bbt.bar, timeInfo.bbt.beat, static_cast<int>(timeInfo.bbt.tick + 0.5));

  1739.             if (! fUiServer.writeMessage(tmpBuf))

  1740.                 return;

  1741. 

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

  1743.             if (! fUiServer.writeMessage(tmpBuf))

  1744.                 return;

  1745.         }

  1746.         else

  1747.         {

  1748.             std::sprintf(tmpBuf, P_UINT64 ":0:0:0\n", timeInfo.frame);

  1749.             if (! fUiServer.writeMessage(tmpBuf))

  1750.                 return;

  1751. 

  1752.             if (! fUiServer.writeMessage("0.0\n"))

  1753.                 return;

  1754.         }

  1755. 

  1756.         fUiServer.flushMessages();

  1757. 

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

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

  1760.         {

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

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

  1763. 

  1764.             std::sprintf(tmpBuf, "PEAKS_%i\n", i);

  1765.             if (! fUiServer.writeMessage(tmpBuf))

  1766.                 return;

  1767. 

  1768.             std::sprintf(tmpBuf, "%f:%f:%f:%f\n",

  1769.                          plugData.peaks[0], plugData.peaks[1], plugData.peaks[2], plugData.peaks[3]);

  1770.             if (! fUiServer.writeMessage(tmpBuf))

  1771.                 return;

  1772. 

  1773.             fUiServer.flushMessages();

  1774. 

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

  1776.             {

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

  1778.                     continue;

  1779. 

  1780.                 std::sprintf(tmpBuf, "PARAMVAL_%i:%i\n", i, j);

  1781.                 if (! fUiServer.writeMessage(tmpBuf))

  1782.                     return;

  1783. 

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

  1785.                 if (! fUiServer.writeMessage(tmpBuf))

  1786.                     return;

  1787. 

  1788.                 fUiServer.flushMessages();

  1789.             }

  1790.         }

  1791.     }

  1792. 

  1793.     // -------------------------------------------------------------------

  1794.     // Plugin state calls

  1795. 

  1796.     char* getState() const

  1797.     {

  1798.         MemoryOutputStream out;

  1799.         saveProjectInternal(out);

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

  1801.     }

  1802. 

  1803.     void setState(const char* const data)

  1804.     {

  1805.         // remove all plugins from UI side

  1806.         for (uint i=0, count=pData->curPluginCount; i < count; ++i)

  1807.             CarlaEngine::callback(ENGINE_CALLBACK_PLUGIN_REMOVED, count-i-1, 0, 0, 0.0f, nullptr);

  1808. 

  1809.         // remove all plugins from backend, no lock

  1810.         fIsRunning = false;

  1811.         removeAllPlugins();

  1812.         fIsRunning = true;

  1813. 

  1814.         // stopped during removeAllPlugins()

  1815.         if (! pData->thread.isThreadRunning())

  1816.             pData->thread.startThread();

  1817. 

  1818.         fOptionsForced = true;

  1819.         const String state(data);

  1820.         XmlDocument xml(state);

  1821.         loadProjectInternal(xml);

  1822.     }

  1823. 

  1824.     // -------------------------------------------------------------------

  1825. 

  1826. public:

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

  1828. 

  1829.     static NativePluginHandle _instantiateRack(const NativeHostDescriptor* host)

  1830.     {

  1831.         return new CarlaEngineNative(host, false, true);

  1832.     }

  1833. 

  1834.     static NativePluginHandle _instantiateRackNoMidiOut(const NativeHostDescriptor* host)

  1835.     {

  1836.         return new CarlaEngineNative(host, false, false);

  1837.     }

  1838. 

  1839.     static NativePluginHandle _instantiatePatchbay(const NativeHostDescriptor* host)

  1840.     {

  1841.         return new CarlaEngineNative(host, true, true);

  1842.     }

  1843. 

  1844.     static NativePluginHandle _instantiatePatchbay3s(const NativeHostDescriptor* host)

  1845.     {

  1846.         return new CarlaEngineNative(host, true, true, 3, 2);

  1847.     }

  1848. 

  1849.     static NativePluginHandle _instantiatePatchbay16(const NativeHostDescriptor* host)

  1850.     {

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

  1852.     }

  1853. 

  1854.     static NativePluginHandle _instantiatePatchbay32(const NativeHostDescriptor* host)

  1855.     {

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

  1857.     }

  1858. 

  1859.     static void _cleanup(NativePluginHandle handle)

  1860.     {

  1861.         delete handlePtr;

  1862.     }

  1863. 

  1864.     static uint32_t _get_parameter_count(NativePluginHandle handle)

  1865.     {

  1866.         return handlePtr->getParameterCount();

  1867.     }

  1868. 

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

  1870.     {

  1871.         return handlePtr->getParameterInfo(index);

  1872.     }

  1873. 

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

  1875.     {

  1876.         return handlePtr->getParameterValue(index);

  1877.     }

  1878. 

  1879.     static uint32_t _get_midi_program_count(NativePluginHandle handle)

  1880.     {

  1881.         return handlePtr->getMidiProgramCount();

  1882.     }

  1883. 

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

  1885.     {

  1886.         return handlePtr->getMidiProgramInfo(index);

  1887.     }

  1888. 

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

  1890.     {

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

  1892.     }

  1893. 

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

  1895.     {

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

  1897.     }

  1898. 

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

  1900.     {

  1901.         handlePtr->uiShow(show);

  1902.     }

  1903. 

  1904.     static void _ui_idle(NativePluginHandle handle)

  1905.     {

  1906.         handlePtr->uiIdle();

  1907.     }

  1908. 

  1909.     static void _activate(NativePluginHandle handle)

  1910.     {

  1911.         handlePtr->activate();

  1912.     }

  1913. 

  1914.     static void _deactivate(NativePluginHandle handle)

  1915.     {

  1916.         handlePtr->deactivate();

  1917.     }

  1918. 

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

  1920.     {

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

  1922.     }

  1923. 

  1924.     static char* _get_state(NativePluginHandle handle)

  1925.     {

  1926.         return handlePtr->getState();

  1927.     }

  1928. 

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

  1930.     {

  1931.         handlePtr->setState(data);

  1932.     }

  1933. 

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

  1935.     {

  1936.         switch(opcode)

  1937.         {

  1938.         case NATIVE_PLUGIN_OPCODE_NULL:

  1939.             return 0;

  1940.         case NATIVE_PLUGIN_OPCODE_BUFFER_SIZE_CHANGED:

  1941.             CARLA_SAFE_ASSERT_RETURN(value > 0, 0);

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

  1943.             return 0;

  1944.         case NATIVE_PLUGIN_OPCODE_SAMPLE_RATE_CHANGED:

  1945.             CARLA_SAFE_ASSERT_RETURN(opt > 0.0, 0);

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

  1947.             return 0;

  1948.         case NATIVE_PLUGIN_OPCODE_OFFLINE_CHANGED:

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

  1950.             return 0;

  1951.         case NATIVE_PLUGIN_OPCODE_UI_NAME_CHANGED:

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

  1953.             return 0;

  1954.         case NATIVE_PLUGIN_OPCODE_GET_INTERNAL_HANDLE: {

  1955.             CarlaEngineNative* const engine = handlePtr;

  1956.             return (intptr_t)(CarlaEngine*)engine;

  1957.         }

  1958.         }

  1959. 

  1960.         return 0;

  1961. 

  1962.         // unused

  1963.         (void)index;

  1964.         (void)ptr;

  1965.     }

  1966. 

  1967.     // -------------------------------------------------------------------

  1968. 

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

  1970.     {

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

  1972.     }

  1973. 

  1974.     static const char* _ui_file_callback(void* handle, FileCallbackOpcode action, bool isDir, const char* title, const char* filter)

  1975.     {

  1976.         return handlePtr->uiFileCallback(action, isDir, title, filter);

  1977.     }

  1978. 

  1979.     // -------------------------------------------------------------------

  1980. 

  1981.     #undef handlePtr

  1982. 

  1983. private:

  1984.     const NativeHostDescriptor* const pHost;

  1985. 

  1986.     const bool kIsPatchbay; // rack if false

  1987.     const bool kHasMidiOut;

  1988.     bool fIsActive, fIsRunning;

  1989.     CarlaEngineNativeUI fUiServer;

  1990. 

  1991.     bool fOptionsForced;

  1992. 

  1993.     CarlaPlugin* _getFirstPlugin() const noexcept

  1994.     {

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

  1996.             return nullptr;

  1997. 

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

  1999. 

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

  2001.             return nullptr;

  2002. 

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

  2004.     }

  2005. 

  2006.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaEngineNative)

  2007. };

  2008. 

  2009. // -----------------------------------------------------------------------

  2010. 

  2011. static const NativePluginDescriptor carlaRackDesc = {

  2012.     /* category  */ NATIVE_PLUGIN_CATEGORY_OTHER,

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

  2014.                                                   |NATIVE_PLUGIN_HAS_UI

  2015.                                                   |NATIVE_PLUGIN_NEEDS_UI_MAIN_THREAD

  2016.                                                   |NATIVE_PLUGIN_USES_STATE

  2017.                                                   |NATIVE_PLUGIN_USES_TIME),

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

  2019.     /* audioIns  */ 2,

  2020.     /* audioOuts */ 2,

  2021.     /* midiIns   */ 1,

  2022.     /* midiOuts  */ 1,

  2023.     /* paramIns  */ 0,

  2024.     /* paramOuts */ 0,

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

  2026.     /* label     */ "carlarack",

  2027.     /* maker     */ "falkTX",

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

  2029.     CarlaEngineNative::_instantiateRack,

  2030.     CarlaEngineNative::_cleanup,

  2031.     CarlaEngineNative::_get_parameter_count,

  2032.     CarlaEngineNative::_get_parameter_info,

  2033.     CarlaEngineNative::_get_parameter_value,

  2034.     CarlaEngineNative::_get_midi_program_count,

  2035.     CarlaEngineNative::_get_midi_program_info,

  2036.     CarlaEngineNative::_set_parameter_value,

  2037.     CarlaEngineNative::_set_midi_program,

  2038.     /* _set_custom_data        */ nullptr,

  2039.     CarlaEngineNative::_ui_show,

  2040.     CarlaEngineNative::_ui_idle,

  2041.     /* _ui_set_parameter_value */ nullptr,

  2042.     /* _ui_set_midi_program    */ nullptr,

  2043.     /* _ui_set_custom_data     */ nullptr,

  2044.     CarlaEngineNative::_activate,

  2045.     CarlaEngineNative::_deactivate,

  2046.     CarlaEngineNative::_process,

  2047.     CarlaEngineNative::_get_state,

  2048.     CarlaEngineNative::_set_state,

  2049.     CarlaEngineNative::_dispatcher

  2050. };

  2051. 

  2052. static const NativePluginDescriptor carlaRackNoMidiOutDesc = {

  2053.     /* category  */ NATIVE_PLUGIN_CATEGORY_OTHER,

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

  2055.                                                   |NATIVE_PLUGIN_HAS_UI

  2056.                                                   |NATIVE_PLUGIN_NEEDS_UI_MAIN_THREAD

  2057.                                                   |NATIVE_PLUGIN_USES_STATE

  2058.                                                   |NATIVE_PLUGIN_USES_TIME),

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

  2060.     /* audioIns  */ 2,

  2061.     /* audioOuts */ 2,

  2062.     /* midiIns   */ 1,

  2063.     /* midiOuts  */ 0,

  2064.     /* paramIns  */ 0,

  2065.     /* paramOuts */ 0,

  2066.     /* name      */ "Carla-Rack (no midi out)",

  2067.     /* label     */ "carlarack-nomidiout",

  2068.     /* maker     */ "falkTX",

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

  2070.     CarlaEngineNative::_instantiateRackNoMidiOut,

  2071.     CarlaEngineNative::_cleanup,

  2072.     CarlaEngineNative::_get_parameter_count,

  2073.     CarlaEngineNative::_get_parameter_info,

  2074.     CarlaEngineNative::_get_parameter_value,

  2075.     CarlaEngineNative::_get_midi_program_count,

  2076.     CarlaEngineNative::_get_midi_program_info,

  2077.     CarlaEngineNative::_set_parameter_value,

  2078.     CarlaEngineNative::_set_midi_program,

  2079.     /* _set_custom_data        */ nullptr,

  2080.     CarlaEngineNative::_ui_show,

  2081.     CarlaEngineNative::_ui_idle,

  2082.     /* _ui_set_parameter_value */ nullptr,

  2083.     /* _ui_set_midi_program    */ nullptr,

  2084.     /* _ui_set_custom_data     */ nullptr,

  2085.     CarlaEngineNative::_activate,

  2086.     CarlaEngineNative::_deactivate,

  2087.     CarlaEngineNative::_process,

  2088.     CarlaEngineNative::_get_state,

  2089.     CarlaEngineNative::_set_state,

  2090.     CarlaEngineNative::_dispatcher

  2091. };

  2092. 

  2093. static const NativePluginDescriptor carlaPatchbayDesc = {

  2094.     /* category  */ NATIVE_PLUGIN_CATEGORY_OTHER,

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

  2096.                                                   |NATIVE_PLUGIN_HAS_UI

  2097.                                                   |NATIVE_PLUGIN_NEEDS_UI_MAIN_THREAD

  2098.                                                   |NATIVE_PLUGIN_USES_STATE

  2099.                                                   |NATIVE_PLUGIN_USES_TIME),

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

  2101.     /* audioIns  */ 2,

  2102.     /* audioOuts */ 2,

  2103.     /* midiIns   */ 1,

  2104.     /* midiOuts  */ 1,

  2105.     /* paramIns  */ 0,

  2106.     /* paramOuts */ 0,

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

  2108.     /* label     */ "carlapatchbay",

  2109.     /* maker     */ "falkTX",

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

  2111.     CarlaEngineNative::_instantiatePatchbay,

  2112.     CarlaEngineNative::_cleanup,

  2113.     CarlaEngineNative::_get_parameter_count,

  2114.     CarlaEngineNative::_get_parameter_info,

  2115.     CarlaEngineNative::_get_parameter_value,

  2116.     CarlaEngineNative::_get_midi_program_count,

  2117.     CarlaEngineNative::_get_midi_program_info,

  2118.     CarlaEngineNative::_set_parameter_value,

  2119.     CarlaEngineNative::_set_midi_program,

  2120.     /* _set_custom_data        */ nullptr,

  2121.     CarlaEngineNative::_ui_show,

  2122.     CarlaEngineNative::_ui_idle,

  2123.     /* _ui_set_parameter_value */ nullptr,

  2124.     /* _ui_set_midi_program    */ nullptr,

  2125.     /* _ui_set_custom_data     */ nullptr,

  2126.     CarlaEngineNative::_activate,

  2127.     CarlaEngineNative::_deactivate,

  2128.     CarlaEngineNative::_process,

  2129.     CarlaEngineNative::_get_state,

  2130.     CarlaEngineNative::_set_state,

  2131.     CarlaEngineNative::_dispatcher

  2132. };

  2133. 

  2134. static const NativePluginDescriptor carlaPatchbay3sDesc = {

  2135.     /* category  */ NATIVE_PLUGIN_CATEGORY_OTHER,

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

  2137.                                                   |NATIVE_PLUGIN_HAS_UI

  2138.                                                   |NATIVE_PLUGIN_NEEDS_UI_MAIN_THREAD

  2139.                                                   |NATIVE_PLUGIN_USES_STATE

  2140.                                                   |NATIVE_PLUGIN_USES_TIME),

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

  2142.     /* audioIns  */ 3,

  2143.     /* audioOuts */ 2,

  2144.     /* midiIns   */ 1,

  2145.     /* midiOuts  */ 1,

  2146.     /* paramIns  */ 0,

  2147.     /* paramOuts */ 0,

  2148.     /* name      */ "Carla-Patchbay (sidechain)",

  2149.     /* label     */ "carlapatchbay3s",

  2150.     /* maker     */ "falkTX",

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

  2152.     CarlaEngineNative::_instantiatePatchbay3s,

  2153.     CarlaEngineNative::_cleanup,

  2154.     CarlaEngineNative::_get_parameter_count,

  2155.     CarlaEngineNative::_get_parameter_info,

  2156.     CarlaEngineNative::_get_parameter_value,

  2157.     CarlaEngineNative::_get_midi_program_count,

  2158.     CarlaEngineNative::_get_midi_program_info,

  2159.     CarlaEngineNative::_set_parameter_value,

  2160.     CarlaEngineNative::_set_midi_program,

  2161.     /* _set_custom_data        */ nullptr,

  2162.     CarlaEngineNative::_ui_show,

  2163.     CarlaEngineNative::_ui_idle,

  2164.     /* _ui_set_parameter_value */ nullptr,

  2165.     /* _ui_set_midi_program    */ nullptr,

  2166.     /* _ui_set_custom_data     */ nullptr,

  2167.     CarlaEngineNative::_activate,

  2168.     CarlaEngineNative::_deactivate,

  2169.     CarlaEngineNative::_process,

  2170.     CarlaEngineNative::_get_state,

  2171.     CarlaEngineNative::_set_state,

  2172.     CarlaEngineNative::_dispatcher

  2173. };

  2174. 

  2175. static const NativePluginDescriptor carlaPatchbay16Desc = {

  2176.     /* category  */ NATIVE_PLUGIN_CATEGORY_OTHER,

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

  2178.                                                   |NATIVE_PLUGIN_HAS_UI

  2179.                                                   |NATIVE_PLUGIN_NEEDS_UI_MAIN_THREAD

  2180.                                                   |NATIVE_PLUGIN_USES_STATE

  2181.                                                   |NATIVE_PLUGIN_USES_TIME),

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

  2183.     /* audioIns  */ 16,

  2184.     /* audioOuts */ 16,

  2185.     /* midiIns   */ 1,

  2186.     /* midiOuts  */ 1,

  2187.     /* paramIns  */ 0,

  2188.     /* paramOuts */ 0,

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

  2190.     /* label     */ "carlapatchbay16",

  2191.     /* maker     */ "falkTX",

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

  2193.     CarlaEngineNative::_instantiatePatchbay16,

  2194.     CarlaEngineNative::_cleanup,

  2195.     CarlaEngineNative::_get_parameter_count,

  2196.     CarlaEngineNative::_get_parameter_info,

  2197.     CarlaEngineNative::_get_parameter_value,

  2198.     CarlaEngineNative::_get_midi_program_count,

  2199.     CarlaEngineNative::_get_midi_program_info,

  2200.     CarlaEngineNative::_set_parameter_value,

  2201.     CarlaEngineNative::_set_midi_program,

  2202.     /* _set_custom_data        */ nullptr,

  2203.     CarlaEngineNative::_ui_show,

  2204.     CarlaEngineNative::_ui_idle,

  2205.     /* _ui_set_parameter_value */ nullptr,

  2206.     /* _ui_set_midi_program    */ nullptr,

  2207.     /* _ui_set_custom_data     */ nullptr,

  2208.     CarlaEngineNative::_activate,

  2209.     CarlaEngineNative::_deactivate,

  2210.     CarlaEngineNative::_process,

  2211.     CarlaEngineNative::_get_state,

  2212.     CarlaEngineNative::_set_state,

  2213.     CarlaEngineNative::_dispatcher

  2214. };

  2215. 

  2216. static const NativePluginDescriptor carlaPatchbay32Desc = {

  2217.     /* category  */ NATIVE_PLUGIN_CATEGORY_OTHER,

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

  2219.                                                   |NATIVE_PLUGIN_HAS_UI

  2220.                                                   |NATIVE_PLUGIN_NEEDS_UI_MAIN_THREAD

  2221.                                                   |NATIVE_PLUGIN_USES_STATE

  2222.                                                   |NATIVE_PLUGIN_USES_TIME),

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

  2224.     /* audioIns  */ 32,

  2225.     /* audioOuts */ 32,

  2226.     /* midiIns   */ 1,

  2227.     /* midiOuts  */ 1,

  2228.     /* paramIns  */ 0,

  2229.     /* paramOuts */ 0,

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

  2231.     /* label     */ "carlapatchbay32",

  2232.     /* maker     */ "falkTX",

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

  2234.     CarlaEngineNative::_instantiatePatchbay32,

  2235.     CarlaEngineNative::_cleanup,

  2236.     CarlaEngineNative::_get_parameter_count,

  2237.     CarlaEngineNative::_get_parameter_info,

  2238.     CarlaEngineNative::_get_parameter_value,

  2239.     CarlaEngineNative::_get_midi_program_count,

  2240.     CarlaEngineNative::_get_midi_program_info,

  2241.     CarlaEngineNative::_set_parameter_value,

  2242.     CarlaEngineNative::_set_midi_program,

  2243.     /* _set_custom_data        */ nullptr,

  2244.     CarlaEngineNative::_ui_show,

  2245.     CarlaEngineNative::_ui_idle,

  2246.     /* _ui_set_parameter_value */ nullptr,

  2247.     /* _ui_set_midi_program    */ nullptr,

  2248.     /* _ui_set_custom_data     */ nullptr,

  2249.     CarlaEngineNative::_activate,

  2250.     CarlaEngineNative::_deactivate,

  2251.     CarlaEngineNative::_process,

  2252.     CarlaEngineNative::_get_state,

  2253.     CarlaEngineNative::_set_state,

  2254.     CarlaEngineNative::_dispatcher

  2255. };

  2256. 

  2257. CARLA_BACKEND_END_NAMESPACE

  2258. 

  2259. // -----------------------------------------------------------------------

  2260. 

  2261. CARLA_EXPORT

  2262. void carla_register_native_plugin_carla();

  2263. 

  2264. void carla_register_native_plugin_carla()

  2265. {

  2266.     CARLA_BACKEND_USE_NAMESPACE;

  2267.     carla_register_native_plugin(&carlaRackDesc);

  2268.     carla_register_native_plugin(&carlaRackNoMidiOutDesc);

  2269.     carla_register_native_plugin(&carlaPatchbayDesc);

  2270.     carla_register_native_plugin(&carlaPatchbay3sDesc);

  2271.     carla_register_native_plugin(&carlaPatchbay16Desc);

  2272.     carla_register_native_plugin(&carlaPatchbay32Desc);

  2273. }

  2274. 

  2275. // -----------------------------------------------------------------------

  2276. 

  2277. const NativePluginDescriptor* carla_get_native_rack_plugin()

  2278. {

  2279.     CARLA_BACKEND_USE_NAMESPACE;

  2280.     return &carlaRackDesc;

  2281. }

  2282. 

  2283. const NativePluginDescriptor* carla_get_native_patchbay_plugin()

  2284. {

  2285.     CARLA_BACKEND_USE_NAMESPACE;

  2286.     return &carlaPatchbayDesc;

  2287. }

  2288. 

  2289. const NativePluginDescriptor* carla_get_native_patchbay16_plugin()

  2290. {

  2291.     CARLA_BACKEND_USE_NAMESPACE;

  2292.     return &carlaPatchbay16Desc;

  2293. }

  2294. 

  2295. const NativePluginDescriptor* carla_get_native_patchbay32_plugin()

  2296. {

  2297.     CARLA_BACKEND_USE_NAMESPACE;

  2298.     return &carlaPatchbay32Desc;

  2299. }

  2300. 

  2301. // -----------------------------------------------------------------------

  2302. // Extra stuff for linking purposes

  2303. 

  2304. #ifdef CARLA_PLUGIN_EXPORT

  2305. 

  2306. CARLA_BACKEND_START_NAMESPACE

  2307. 

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

  2309. 

  2310. # ifdef USING_JUCE

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

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

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

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

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

  2316. # else

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

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

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

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

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

  2322. # endif

  2323. 

  2324. CARLA_BACKEND_END_NAMESPACE

  2325. 

  2326. #define CARLA_PLUGIN_UI_CLASS_PREFIX EngineNative

  2327. #include "CarlaHostCommon.cpp"

  2328. #include "CarlaPluginUI.cpp"

  2329. #include "CarlaDssiUtils.cpp"

  2330. #include "CarlaMacUtils.cpp"

  2331. #include "CarlaPatchbayUtils.cpp"

  2332. #include "CarlaPipeUtils.cpp"

  2333. #include "CarlaStateUtils.cpp"

  2334. 

  2335. #endif

  2336. 

  2337. // -----------------------------------------------------------------------