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

1618 lines
53KB
Raw Blame History 

  1. /*

  2.  * Carla Plugin Host

  3.  * Copyright (C) 2011-2014 Filipe Coelho <falktx@falktx.com>

  4.  *

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

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

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

  8.  * the License, or any later version.

  9.  *

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

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

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

  13.  * GNU General Public License for more details.

  14.  *

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

  16.  */

  17. 

  18. #include "CarlaDefines.h"

  19. 

  20. #ifdef BUILD_BRIDGE

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

  22. #endif

  23. #ifdef CARLA_OS_WIN

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

  25. #endif

  26. 

  27. #include "CarlaEngineInternal.hpp"

  28. #include "CarlaPlugin.hpp"

  29. 

  30. #include "CarlaBackendUtils.hpp"

  31. #include "CarlaBase64Utils.hpp"

  32. #include "CarlaBinaryUtils.hpp"

  33. #include "CarlaMathUtils.hpp"

  34. #include "CarlaStateUtils.hpp"

  35. 

  36. #include "CarlaExternalUI.hpp"

  37. #include "CarlaNative.hpp"

  38. 

  39. #include "juce_audio_basics.h"

  40. 

  41. using juce::File;

  42. using juce::FloatVectorOperations;

  43. using juce::MemoryOutputStream;

  44. using juce::ScopedPointer;

  45. using juce::String;

  46. using juce::XmlDocument;

  47. using juce::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.           leakDetector_CarlaEngineNativeUI()

  59.     {

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

  61.     }

  62. 

  63.     ~CarlaEngineNativeUI() override

  64.     {

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

  66.     }

  67. 

  68.     CarlaMutex& getWriteLock() noexcept

  69.     {

  70.         return fWriteLock;

  71.     }

  72. 

  73. protected:

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

  75.     {

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

  77.             return true;

  78. 

  79.         bool ok = true;

  80. 

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

  82.         {

  83.             uint32_t option;

  84.             int32_t value;

  85.             const char* valueStr = nullptr;

  86. 

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

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

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

  90. 

  91.             try {

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

  93.             } CARLA_SAFE_EXCEPTION("setOption");

  94. 

  95.             delete[] valueStr;

  96.         }

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

  98.         {

  99.             const char* filename;

  100. 

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

  102. 

  103.             try {

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

  105.             } CARLA_SAFE_EXCEPTION("loadFile");

  106. 

  107.             delete[] filename;

  108.         }

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

  110.         {

  111.             const char* filename;

  112. 

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

  114. 

  115.             try {

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

  117.             } CARLA_SAFE_EXCEPTION("loadProject");

  118. 

  119.             delete[] filename;

  120.         }

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

  122.         {

  123.             const char* filename;

  124. 

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

  126. 

  127.             try {

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

  129.             } CARLA_SAFE_EXCEPTION("saveProject");

  130. 

  131.             delete[] filename;

  132.         }

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

  134.         {

  135.             uint32_t groupA, portA, groupB, portB;

  136. 

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

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

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

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

  141. 

  142.             try {

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

  144.             } CARLA_SAFE_EXCEPTION("patchbayConnect");

  145.         }

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

  147.         {

  148.             uint32_t connectionId;

  149. 

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

  151. 

  152.             try {

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

  154.             } CARLA_SAFE_EXCEPTION("patchbayDisconnect");

  155.         }

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

  157.         {

  158.             try {

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

  160.             } CARLA_SAFE_EXCEPTION("patchbayRefresh");

  161.         }

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

  163.         {

  164.             fEngine->transportPlay();

  165.         }

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

  167.         {

  168.             fEngine->transportPause();

  169.         }

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

  171.         {

  172.             uint64_t frame;

  173. 

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

  175. 

  176.             fEngine->transportRelocate(frame);

  177.         }

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

  179.         {

  180.             uint32_t btype, ptype;

  181.             const char* filename = nullptr;

  182.             const char* name;

  183.             const char* label;

  184.             int64_t uniqueId;

  185. 

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

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

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

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

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

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

  192. 

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

  194.             {

  195.                 delete[] filename;

  196.                 filename = nullptr;

  197.             }

  198. 

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

  200.             {

  201.                 delete[] name;

  202.                 name = nullptr;

  203.             }

  204. 

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

  206. 

  207.             if (filename != nullptr)

  208.                 delete[] filename;

  209.             if (name != nullptr)

  210.                 delete[] name;

  211.             delete[] label;

  212.         }

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

  214.         {

  215.             uint32_t pluginId;

  216. 

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

  218. 

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

  220.         }

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

  222.         {

  223.             ok = fEngine->removeAllPlugins();

  224.         }

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

  226.         {

  227.             uint32_t pluginId;

  228.             const char* newName;

  229. 

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

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

  232. 

  233.             // TODO

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

  235. 

  236.             delete[] newName;

  237.         }

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

  239.         {

  240.             uint32_t pluginId;

  241. 

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

  243. 

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

  245.         }

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

  247.         {

  248.             uint32_t pluginId;

  249. 

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

  251. 

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

  253.         }

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

  255.         {

  256.             uint32_t pluginIdA, pluginIdB;

  257. 

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

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

  260. 

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

  262.         }

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

  264.         {

  265.             uint32_t pluginId;

  266.             const char* filename;

  267. 

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

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

  270. 

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

  272.                 plugin->loadStateFromFile(filename);

  273. 

  274.             delete[] filename;

  275.         }

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

  277.         {

  278.             uint32_t pluginId;

  279.             const char* filename;

  280. 

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

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

  283. 

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

  285.                 plugin->saveStateToFile(filename);

  286. 

  287.             delete[] filename;

  288.         }

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

  290.         {

  291.             uint32_t pluginId, option;

  292.             bool yesNo;

  293. 

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

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

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

  297. 

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

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

  300.         }

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

  302.         {

  303.             uint32_t pluginId;

  304.             bool onOff;

  305. 

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

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

  308. 

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

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

  311.         }

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

  313.         {

  314.             uint32_t pluginId;

  315.             float value;

  316. 

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

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

  319. 

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

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

  322.         }

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

  324.         {

  325.             uint32_t pluginId;

  326.             float value;

  327. 

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

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

  330. 

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

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

  333.         }

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

  335.         {

  336.             uint32_t pluginId;

  337.             float value;

  338. 

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

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

  341. 

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

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

  344.         }

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

  346.         {

  347.             uint32_t pluginId;

  348.             float value;

  349. 

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

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

  352. 

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

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

  355.         }

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

  357.         {

  358.             uint32_t pluginId;

  359.             float value;

  360. 

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

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

  363. 

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

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

  366.         }

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

  368.         {

  369.             uint32_t pluginId;

  370.             int32_t channel;

  371. 

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

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

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

  375. 

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

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

  378.         }

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

  380.         {

  381.             uint32_t pluginId, parameterId;

  382.             float value;

  383. 

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

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

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

  387. 

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

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

  390.         }

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

  392.         {

  393.             uint32_t pluginId, parameterId, channel;

  394. 

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

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

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

  398.             CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS, true);

  399. 

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

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

  402.         }

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

  404.         {

  405.             uint32_t pluginId, parameterId;

  406.             int32_t cc;

  407. 

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

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

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

  411.             CARLA_SAFE_ASSERT_RETURN(cc >= -1 && cc < 0x5F, true);

  412. 

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

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

  415.         }

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

  417.         {

  418.             uint32_t pluginId;

  419.             int32_t index;

  420. 

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

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

  423. 

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

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

  426.         }

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

  428.         {

  429.             uint32_t pluginId;

  430.             int32_t index;

  431. 

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

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

  434. 

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

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

  437.         }

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

  439.         {

  440.             uint32_t pluginId;

  441.             const char* type;

  442.             const char* key;

  443.             const char* value;

  444. 

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

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

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

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

  449. 

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

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

  452. 

  453.             delete[] type;

  454.             delete[] key;

  455.             delete[] value;

  456.         }

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

  458.         {

  459.             uint32_t pluginId;

  460.             const char* cdata;

  461. 

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

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

  464. 

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

  466.             {

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

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

  469.             }

  470. 

  471.             delete[] cdata;

  472.         }

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

  474.         {

  475.             uint32_t pluginId;

  476. 

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

  478. 

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

  480.                 plugin->prepareForSave();

  481.         }

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

  483.         {

  484.             uint32_t pluginId;

  485. 

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

  487. 

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

  489.                 plugin->resetParameters();

  490.         }

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

  492.         {

  493.             uint32_t pluginId;

  494. 

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

  496. 

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

  498.                 plugin->randomizeParameters();

  499.         }

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

  501.         {

  502.             uint32_t pluginId, channel, note, velocity;

  503. 

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

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

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

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

  508.             CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS, true);

  509.             CARLA_SAFE_ASSERT_RETURN(note < MAX_MIDI_VALUE, true);

  510.             CARLA_SAFE_ASSERT_RETURN(velocity < MAX_MIDI_VALUE, true);

  511. 

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

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

  514.         }

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

  516.         {

  517.             uint32_t pluginId;

  518.             bool yesNo;

  519. 

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

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

  522. 

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

  524.                 plugin->showCustomUI(yesNo);

  525.         }

  526.         else

  527.         {

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

  529.             return false;

  530.         }

  531. 

  532.         if (! ok)

  533.         {

  534.             const CarlaMutexLocker cml(fWriteLock);

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

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

  537.         }

  538. 

  539.         return true;

  540.     }

  541. 

  542. private:

  543.     CarlaEngine* const fEngine;

  544. 

  545.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaEngineNativeUI)

  546. };

  547. 

  548. // -----------------------------------------------------------------------

  549. 

  550. class CarlaEngineNative : public CarlaEngine

  551. {

  552. public:

  553.     CarlaEngineNative(const NativeHostDescriptor* const host, const bool isPatchbay)

  554.         : CarlaEngine(),

  555.           pHost(host),

  556.           fIsPatchbay(isPatchbay),

  557.           fIsActive(false),

  558.           fIsRunning(false),

  559.           fUiServer(this),

  560.           leakDetector_CarlaEngineNative()

  561.     {

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

  563. 

  564.         carla_zeroChar(fTmpBuf, STR_MAX+1);

  565. 

  566.         // set-up engine

  567.         if (fIsPatchbay)

  568.         {

  569.             pData->options.processMode         = ENGINE_PROCESS_MODE_PATCHBAY;

  570.             pData->options.transportMode       = ENGINE_TRANSPORT_MODE_PLUGIN;

  571.             pData->options.forceStereo         = false;

  572.             pData->options.preferPluginBridges = false;

  573.             pData->options.preferUiBridges     = false;

  574.             init("Carla-Patchbay");

  575.             pData->graph.create(false, pData->sampleRate, pData->bufferSize, 2, 2);

  576.         }

  577.         else

  578.         {

  579.             pData->options.processMode         = ENGINE_PROCESS_MODE_CONTINUOUS_RACK;

  580.             pData->options.transportMode       = ENGINE_TRANSPORT_MODE_PLUGIN;

  581.             pData->options.forceStereo         = true;

  582.             pData->options.preferPluginBridges = false;

  583.             pData->options.preferUiBridges     = false;

  584.             init("Carla-Rack");

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

  586.         }

  587. 

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

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

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

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

  592. 

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

  594.         pData->options.binaryDir   = carla_strdup(File(pHost->resourceDir).getParentDirectory().getFullPathName().toRawUTF8());

  595. 

  596.         setCallback(_ui_server_callback, this);

  597.     }

  598. 

  599.     ~CarlaEngineNative() override

  600.     {

  601.         CARLA_SAFE_ASSERT(! fIsActive);

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

  603. 

  604.         pData->aboutToClose = true;

  605.         fIsRunning = false;

  606. 

  607.         removeAllPlugins();

  608.         //runPendingRtEvents();

  609.         close();

  610. 

  611.         pData->graph.destroy();

  612. 

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

  614.     }

  615. 

  616. protected:

  617.     // -------------------------------------

  618.     // CarlaEngine virtual calls

  619. 

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

  621.     {

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

  623. 

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

  625.         {

  626.             close();

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

  628.             return false;

  629.         }

  630. 

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

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

  633. 

  634.         fIsRunning = true;

  635.         return true;

  636.     }

  637. 

  638.     bool isRunning() const noexcept override

  639.     {

  640.         return fIsRunning;

  641.     }

  642. 

  643.     bool isOffline() const noexcept override

  644.     {

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

  646.     }

  647. 

  648.     EngineType getType() const noexcept override

  649.     {

  650.         return kEngineTypePlugin;

  651.     }

  652. 

  653.     const char* getCurrentDriverName() const noexcept override

  654.     {

  655.         return "Plugin";

  656.     }

  657. 

  658.     // -------------------------------------------------------------------

  659. 

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

  661.     {

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

  663.         {

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

  665.             return retName;

  666.         }

  667. 

  668.         return nullptr;

  669.     }

  670. 

  671.     // -------------------------------------------------------------------

  672. 

  673.     void bufferSizeChanged(const uint32_t newBufferSize)

  674.     {

  675.         pData->bufferSize = newBufferSize;

  676.         CarlaEngine::bufferSizeChanged(newBufferSize);

  677.     }

  678. 

  679.     void sampleRateChanged(const double newSampleRate)

  680.     {

  681.         pData->sampleRate = newSampleRate;

  682.         CarlaEngine::sampleRateChanged(newSampleRate);

  683.     }

  684. 

  685.     // -------------------------------------------------------------------

  686. 

  687.     void uiServerSendPluginInfo(CarlaPlugin* const plugin)

  688.     {

  689.         const CarlaMutexLocker cml(fUiServer.getWriteLock());

  690. 

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

  692. 

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

  694.         fUiServer.writeMsg(fTmpBuf);

  695. 

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

  697.         fUiServer.writeMsg(fTmpBuf);

  698. 

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

  700.         {

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

  702.             fUiServer.writeAndFixMsg(fTmpBuf);

  703.         }

  704.         else

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

  706. 

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

  708.         {

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

  710.             fUiServer.writeAndFixMsg(fTmpBuf);

  711.         }

  712.         else

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

  714. 

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

  716.         {

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

  718.             fUiServer.writeAndFixMsg(fTmpBuf);

  719.         }

  720.         else

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

  722. 

  723.         plugin->getRealName(fTmpBuf);

  724.         fUiServer.writeAndFixMsg(fTmpBuf);

  725. 

  726.         plugin->getLabel(fTmpBuf);

  727.         fUiServer.writeAndFixMsg(fTmpBuf);

  728. 

  729.         plugin->getMaker(fTmpBuf);

  730.         fUiServer.writeAndFixMsg(fTmpBuf);

  731. 

  732.         plugin->getCopyright(fTmpBuf);

  733.         fUiServer.writeAndFixMsg(fTmpBuf);

  734. 

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

  736.         fUiServer.writeMsg(fTmpBuf);

  737. 

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

  739.         fUiServer.writeMsg(fTmpBuf);

  740.     }

  741. 

  742.     void uiServerSendPluginParameters(CarlaPlugin* const plugin)

  743.     {

  744.         const CarlaMutexLocker cml(fUiServer.getWriteLock());

  745. 

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

  747. 

  748.         uint32_t ins, outs, count;

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

  750.         count = plugin->getParameterCount();

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

  752.         fUiServer.writeMsg(fTmpBuf);

  753. 

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

  755.         {

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

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

  758. 

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

  760.             fUiServer.writeMsg(fTmpBuf);

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

  762.             fUiServer.writeMsg(fTmpBuf);

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

  764.             fUiServer.writeAndFixMsg(fTmpBuf);

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

  766.             fUiServer.writeAndFixMsg(fTmpBuf);

  767. 

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

  769.             fUiServer.writeMsg(fTmpBuf);

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

  771.             fUiServer.writeMsg(fTmpBuf);

  772. 

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

  774.             fUiServer.writeMsg(fTmpBuf);

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

  776.             fUiServer.writeMsg(fTmpBuf);

  777.         }

  778.     }

  779. 

  780.     void uiServerSendPluginPrograms(CarlaPlugin* const plugin)

  781.     {

  782.         const CarlaMutexLocker cml(fUiServer.getWriteLock());

  783. 

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

  785. 

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

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

  788.         fUiServer.writeMsg(fTmpBuf);

  789. 

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

  791.         {

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

  793.             fUiServer.writeMsg(fTmpBuf);

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

  795.             fUiServer.writeAndFixMsg(fTmpBuf);

  796.         }

  797. 

  798.         count = plugin->getMidiProgramCount();

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

  800.         fUiServer.writeMsg(fTmpBuf);

  801. 

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

  803.         {

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

  805.             fUiServer.writeMsg(fTmpBuf);

  806. 

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

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

  809.             fUiServer.writeMsg(fTmpBuf);

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

  811.             fUiServer.writeAndFixMsg(fTmpBuf);

  812.         }

  813.     }

  814. 

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

  816.     {

  817.         if (! fIsRunning)

  818.             return;

  819.         if (! fUiServer.isOk())

  820.             return;

  821. 

  822.         CarlaPlugin* plugin;

  823. 

  824.         switch (action)

  825.         {

  826.         case ENGINE_CALLBACK_RELOAD_INFO:

  827.             plugin = getPlugin(pluginId);

  828. 

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

  830.             {

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

  832.                 uiServerSendPluginInfo(plugin);

  833.             }

  834.             break;

  835. 

  836.         case ENGINE_CALLBACK_RELOAD_PARAMETERS:

  837.             plugin = getPlugin(pluginId);

  838. 

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

  840.             {

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

  842.                 uiServerSendPluginParameters(plugin);

  843.             }

  844.             break;

  845. 

  846.         case ENGINE_CALLBACK_RELOAD_PROGRAMS:

  847.             plugin = getPlugin(pluginId);

  848. 

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

  850.             {

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

  852.                 uiServerSendPluginPrograms(plugin);

  853.             }

  854.             break;

  855. 

  856.         case ENGINE_CALLBACK_RELOAD_ALL:

  857.         case ENGINE_CALLBACK_PLUGIN_ADDED:

  858.             plugin = getPlugin(pluginId);

  859. 

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

  861.             {

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

  863.                 uiServerSendPluginInfo(plugin);

  864.                 uiServerSendPluginParameters(plugin);

  865.                 uiServerSendPluginPrograms(plugin);

  866.             }

  867.             break;

  868. 

  869.         default:

  870.             break;

  871.         }

  872. 

  873.         const CarlaMutexLocker cml(fUiServer.getWriteLock());

  874. 

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

  876.         fUiServer.writeMsg(fTmpBuf);

  877. 

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

  879.         fUiServer.writeMsg(fTmpBuf);

  880. 

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

  882.         fUiServer.writeMsg(fTmpBuf);

  883. 

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

  885.         fUiServer.writeMsg(fTmpBuf);

  886. 

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

  888.         fUiServer.writeMsg(fTmpBuf);

  889. 

  890.         fUiServer.writeAndFixMsg(valueStr);

  891.     }

  892. 

  893.     // -------------------------------------------------------------------

  894.     // Plugin parameter calls

  895. 

  896.     uint32_t getParameterCount() const

  897.     {

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

  899.             return plugin->getParameterCount();

  900. 

  901.         return 0;

  902.     }

  903. 

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

  905.     {

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

  907.         {

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

  909.             {

  910.                 static NativeParameter param;

  911.                 static char strBufName[STR_MAX+1];

  912.                 static char strBufUnit[STR_MAX+1];

  913. 

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

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

  916. 

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

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

  919. 

  920.                 uint hints = 0x0;

  921. 

  922.                 if (paramData.hints & PARAMETER_IS_BOOLEAN)

  923.                     hints |= ::PARAMETER_IS_BOOLEAN;

  924.                 if (paramData.hints & PARAMETER_IS_INTEGER)

  925.                     hints |= ::PARAMETER_IS_INTEGER;

  926.                 if (paramData.hints & PARAMETER_IS_LOGARITHMIC)

  927.                     hints |= ::PARAMETER_IS_LOGARITHMIC;

  928.                 if (paramData.hints & PARAMETER_IS_AUTOMABLE)

  929.                     hints |= ::PARAMETER_IS_AUTOMABLE;

  930.                 if (paramData.hints & PARAMETER_USES_SAMPLERATE)

  931.                     hints |= ::PARAMETER_USES_SAMPLE_RATE;

  932.                 if (paramData.hints & PARAMETER_USES_SCALEPOINTS)

  933.                     hints |= ::PARAMETER_USES_SCALEPOINTS;

  934.                 if (paramData.hints & PARAMETER_USES_CUSTOM_TEXT)

  935.                     hints |= ::PARAMETER_USES_CUSTOM_TEXT;

  936. 

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

  938.                 {

  939.                     if (paramData.hints & PARAMETER_IS_ENABLED)

  940.                         hints |= ::PARAMETER_IS_ENABLED;

  941.                     if (paramData.type == PARAMETER_OUTPUT)

  942.                         hints |= ::PARAMETER_IS_OUTPUT;

  943.                 }

  944. 

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

  946.                 param.name  = strBufName;

  947.                 param.unit  = strBufUnit;

  948.                 param.ranges.def = paramRanges.def;

  949.                 param.ranges.min = paramRanges.min;

  950.                 param.ranges.max = paramRanges.max;

  951.                 param.ranges.step = paramRanges.step;

  952.                 param.ranges.stepSmall = paramRanges.stepSmall;

  953.                 param.ranges.stepLarge = paramRanges.stepLarge;

  954.                 param.scalePointCount = 0; // TODO

  955.                 param.scalePoints = nullptr;

  956. 

  957.                 return &param;

  958.             }

  959.         }

  960. 

  961.         return nullptr;

  962.     }

  963. 

  964.     float getParameterValue(const uint32_t index) const

  965.     {

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

  967.         {

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

  969.                 return plugin->getParameterValue(index);

  970.         }

  971. 

  972.         return 0.0f;

  973.     }

  974. 

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

  976.     {

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

  978.         {

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

  980.             {

  981.                 static char strBuf[STR_MAX+1];

  982.                 carla_zeroChar(strBuf, STR_MAX+1);

  983. 

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

  985. 

  986.                 return strBuf;

  987.             }

  988.         }

  989. 

  990.         return nullptr;

  991.     }

  992. 

  993.     // -------------------------------------------------------------------

  994.     // Plugin midi-program calls

  995. 

  996.     uint32_t getMidiProgramCount() const

  997.     {

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

  999.             return plugin->getMidiProgramCount();

  1000. 

  1001.         return 0;

  1002.     }

  1003. 

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

  1005.     {

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

  1007.         {

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

  1009.             {

  1010.                 static NativeMidiProgram midiProg;

  1011. 

  1012.                 {

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

  1014. 

  1015.                     midiProg.bank    = midiProgData.bank;

  1016.                     midiProg.program = midiProgData.program;

  1017.                     midiProg.name    = midiProgData.name;

  1018.                 }

  1019. 

  1020.                 return &midiProg;

  1021.             }

  1022.         }

  1023. 

  1024.         return nullptr;

  1025.     }

  1026. 

  1027.     // -------------------------------------------------------------------

  1028.     // Plugin state calls

  1029. 

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

  1031.     {

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

  1033.         {

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

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

  1036.         }

  1037.     }

  1038. 

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

  1040.     {

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

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

  1043.     }

  1044. 

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

  1046.     // Plugin process calls

  1047. 

  1048.     void activate()

  1049.     {

  1050. #if 0

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

  1052.         {

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

  1054. 

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

  1056.                 continue;

  1057. 

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

  1059.         }

  1060. #endif

  1061.         fIsActive = true;

  1062.     }

  1063. 

  1064.     void deactivate()

  1065.     {

  1066.         fIsActive = false;

  1067. #if 0

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

  1069.         {

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

  1071. 

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

  1073.                 continue;

  1074. 

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

  1076.         }

  1077. #endif

  1078. 

  1079.         // just in case

  1080.         //runPendingRtEvents();

  1081.     }

  1082. 

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

  1084.     {

  1085.         const PendingRtEventsRunner prt(this);

  1086. 

  1087.         if (pData->curPluginCount == 0 && ! fIsPatchbay)

  1088.         {

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

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

  1091.             return;

  1092.         }

  1093. 

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

  1095.         // Time Info

  1096. 

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

  1098. 

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

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

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

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

  1103. 

  1104.         if (timeInfo->bbt.valid)

  1105.         {

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

  1107. 

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

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

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

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

  1112. 

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

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

  1115. 

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

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

  1118.         }

  1119. 

  1120.         // ---------------------------------------------------------------

  1121.         // initialize events

  1122. 

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

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

  1125. 

  1126.         // ---------------------------------------------------------------

  1127.         // events input (before processing)

  1128. 

  1129.         {

  1130.             uint32_t engineEventIndex = 0;

  1131. 

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

  1133.             {

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

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

  1136. 

  1137.                 engineEvent.time = midiEvent.time;

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

  1139. 

  1140.                 if (engineEventIndex >= kMaxEngineEventInternalCount)

  1141.                     break;

  1142.             }

  1143.         }

  1144. 

  1145.         if (fIsPatchbay)

  1146.         {

  1147.             // -----------------------------------------------------------

  1148.             // process

  1149. 

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

  1151.         }

  1152.         else

  1153.         {

  1154.             // -----------------------------------------------------------

  1155.             // create audio buffers

  1156. 

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

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

  1159. 

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

  1161.             // process

  1162. 

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

  1164.         }

  1165. 

  1166.         // ---------------------------------------------------------------

  1167.         // events output (after processing)

  1168. 

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

  1170. 

  1171.         {

  1172.             NativeMidiEvent midiEvent;

  1173. 

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

  1175.             {

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

  1177. 

  1178.                 if (engineEvent.type == kEngineEventTypeNull)

  1179.                     break;

  1180. 

  1181.                 midiEvent.time = engineEvent.time;

  1182. 

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

  1184.                 {

  1185.                     midiEvent.port = 0;

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

  1187.                 }

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

  1189.                 {

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

  1191.                         continue;

  1192. 

  1193.                     midiEvent.port = engineEvent.midi.port;

  1194.                     midiEvent.size = engineEvent.midi.size;

  1195. 

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

  1197. 

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

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

  1200.                 }

  1201.                 else

  1202.                 {

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

  1204.                     continue;

  1205.                 }

  1206. 

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

  1208.             }

  1209.         }

  1210.     }

  1211. 

  1212.     // -------------------------------------------------------------------

  1213.     // Plugin UI calls

  1214. 

  1215.     void uiShow(const bool show)

  1216.     {

  1217.         if (show)

  1218.         {

  1219.             if (fUiServer.isOk())

  1220.                 return;

  1221. 

  1222.             CarlaString path(pHost->resourceDir);

  1223. 

  1224.             if (fIsPatchbay)

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

  1226.             else

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

  1228. 

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

  1230. 

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

  1232.             fUiServer.start();

  1233. 

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

  1235.             {

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

  1237. 

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

  1239.                 {

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

  1241.                 }

  1242.             }

  1243. 

  1244.             if (fIsPatchbay)

  1245.                 patchbayRefresh(false);

  1246.         }

  1247.         else

  1248.         {

  1249.             fUiServer.stop();

  1250.         }

  1251.     }

  1252. 

  1253.     void uiIdle()

  1254.     {

  1255.         CarlaEngine::idle();

  1256.         fUiServer.idle();

  1257. 

  1258.         if (! fUiServer.isOk())

  1259.             return;

  1260. 

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

  1262.         {

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

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

  1265. 

  1266.             {

  1267.                 const CarlaMutexLocker cml(fUiServer.getWriteLock());

  1268. 

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

  1270.                 fUiServer.writeMsg(fTmpBuf);

  1271. 

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

  1273.                 fUiServer.writeMsg(fTmpBuf);

  1274.             }

  1275. 

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

  1277.             {

  1278.                 if (plugin->isParameterOutput(j))

  1279.                     continue;

  1280. 

  1281.                 const CarlaMutexLocker cml(fUiServer.getWriteLock());

  1282. 

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

  1284.                 fUiServer.writeMsg(fTmpBuf);

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

  1286.                 fUiServer.writeMsg(fTmpBuf);

  1287.             }

  1288.         }

  1289. 

  1290.         switch (fUiServer.getAndResetUiState())

  1291.         {

  1292.         case CarlaExternalUI::UiNone:

  1293.         case CarlaExternalUI::UiShow:

  1294.             break;

  1295.         case CarlaExternalUI::UiCrashed:

  1296.             pHost->dispatcher(pHost->handle, HOST_OPCODE_UI_UNAVAILABLE, 0, 0, nullptr, 0.0f);

  1297.             break;

  1298.         case CarlaExternalUI::UiHide:

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

  1300.             fUiServer.stop();

  1301.             break;

  1302.         }

  1303.     }

  1304. 

  1305.     // -------------------------------------------------------------------

  1306.     // Plugin state calls

  1307. 

  1308.     char* getState() const

  1309.     {

  1310.         MemoryOutputStream out;

  1311.         saveProjectInternal(out);

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

  1313.     }

  1314. 

  1315.     void setState(const char* const data)

  1316.     {

  1317.         const String state(data);

  1318.         XmlDocument xml(state);

  1319.         loadProjectInternal(xml);

  1320.     }

  1321. 

  1322.     // -------------------------------------------------------------------

  1323. 

  1324. public:

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

  1326. 

  1327.     static NativePluginHandle _instantiateRack(const NativeHostDescriptor* host)

  1328.     {

  1329.         return new CarlaEngineNative(host, false);

  1330.     }

  1331. 

  1332.     static NativePluginHandle _instantiatePatchbay(const NativeHostDescriptor* host)

  1333.     {

  1334.         return new CarlaEngineNative(host, true);

  1335.     }

  1336. 

  1337.     static void _cleanup(NativePluginHandle handle)

  1338.     {

  1339.         delete handlePtr;

  1340.     }

  1341. 

  1342.     static uint32_t _get_parameter_count(NativePluginHandle handle)

  1343.     {

  1344.         return handlePtr->getParameterCount();

  1345.     }

  1346. 

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

  1348.     {

  1349.         return handlePtr->getParameterInfo(index);

  1350.     }

  1351. 

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

  1353.     {

  1354.         return handlePtr->getParameterValue(index);

  1355.     }

  1356. 

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

  1358.     {

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

  1360.     }

  1361. 

  1362.     static uint32_t _get_midi_program_count(NativePluginHandle handle)

  1363.     {

  1364.         return handlePtr->getMidiProgramCount();

  1365.     }

  1366. 

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

  1368.     {

  1369.         return handlePtr->getMidiProgramInfo(index);

  1370.     }

  1371. 

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

  1373.     {

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

  1375.     }

  1376. 

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

  1378.     {

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

  1380.     }

  1381. 

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

  1383.     {

  1384.         handlePtr->uiShow(show);

  1385.     }

  1386. 

  1387.     static void _ui_idle(NativePluginHandle handle)

  1388.     {

  1389.         handlePtr->uiIdle();

  1390.     }

  1391. 

  1392.     static void _activate(NativePluginHandle handle)

  1393.     {

  1394.         handlePtr->activate();

  1395.     }

  1396. 

  1397.     static void _deactivate(NativePluginHandle handle)

  1398.     {

  1399.         handlePtr->deactivate();

  1400.     }

  1401. 

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

  1403.     {

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

  1405.     }

  1406. 

  1407.     static char* _get_state(NativePluginHandle handle)

  1408.     {

  1409.         return handlePtr->getState();

  1410.     }

  1411. 

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

  1413.     {

  1414.         handlePtr->setState(data);

  1415.     }

  1416. 

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

  1418.     {

  1419.         switch(opcode)

  1420.         {

  1421.         case PLUGIN_OPCODE_NULL:

  1422.             return 0;

  1423.         case PLUGIN_OPCODE_BUFFER_SIZE_CHANGED:

  1424.             CARLA_SAFE_ASSERT_RETURN(value > 0, 0);

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

  1426.             return 0;

  1427.         case PLUGIN_OPCODE_SAMPLE_RATE_CHANGED:

  1428.             CARLA_SAFE_ASSERT_RETURN(opt > 0.0, 0);

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

  1430.             return 0;

  1431.         case PLUGIN_OPCODE_OFFLINE_CHANGED:

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

  1433.             return 0;

  1434.         case PLUGIN_OPCODE_UI_NAME_CHANGED:

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

  1436.             return 0;

  1437.         }

  1438. 

  1439.         return 0;

  1440. 

  1441.         // unused

  1442.         (void)index;

  1443.         (void)ptr;

  1444.     }

  1445. 

  1446.     // -------------------------------------------------------------------

  1447. 

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

  1449.     {

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

  1451.     }

  1452. 

  1453.     // -------------------------------------------------------------------

  1454. 

  1455.     #undef handlePtr

  1456. 

  1457. private:

  1458.     const NativeHostDescriptor* const pHost;

  1459. 

  1460.     const bool fIsPatchbay; // rack if false

  1461.     bool fIsActive, fIsRunning;

  1462.     CarlaEngineNativeUI fUiServer;

  1463. 

  1464.     char fTmpBuf[STR_MAX+1];

  1465. 

  1466.     CarlaPlugin* _getFirstPlugin() const noexcept

  1467.     {

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

  1469.             return nullptr;

  1470. 

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

  1472. 

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

  1474.             return nullptr;

  1475. 

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

  1477.     }

  1478. 

  1479.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaEngineNative)

  1480. };

  1481. 

  1482. // -----------------------------------------------------------------------

  1483. 

  1484. static const NativePluginDescriptor carlaRackDesc = {

  1485.     /* category  */ ::PLUGIN_CATEGORY_OTHER,

  1486.     /* hints     */ static_cast<NativePluginHints>(::PLUGIN_IS_SYNTH|::PLUGIN_HAS_UI|::PLUGIN_NEEDS_FIXED_BUFFERS|::PLUGIN_NEEDS_SINGLE_THREAD|::PLUGIN_USES_STATE|::PLUGIN_USES_TIME),

  1487.     /* supports  */ static_cast<NativePluginSupports>(::PLUGIN_SUPPORTS_EVERYTHING),

  1488.     /* audioIns  */ 2,

  1489.     /* audioOuts */ 2,

  1490.     /* midiIns   */ 1,

  1491.     /* midiOuts  */ 1,

  1492.     /* paramIns  */ 0,

  1493.     /* paramOuts */ 0,

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

  1495.     /* label     */ "carlarack",

  1496.     /* maker     */ "falkTX",

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

  1498.     CarlaEngineNative::_instantiateRack,

  1499.     CarlaEngineNative::_cleanup,

  1500.     CarlaEngineNative::_get_parameter_count,

  1501.     CarlaEngineNative::_get_parameter_info,

  1502.     CarlaEngineNative::_get_parameter_value,

  1503.     CarlaEngineNative::_get_parameter_text,

  1504.     CarlaEngineNative::_get_midi_program_count,

  1505.     CarlaEngineNative::_get_midi_program_info,

  1506.     CarlaEngineNative::_set_parameter_value,

  1507.     CarlaEngineNative::_set_midi_program,

  1508.     /* _set_custom_data        */ nullptr,

  1509.     CarlaEngineNative::_ui_show,

  1510.     CarlaEngineNative::_ui_idle,

  1511.     /* _ui_set_parameter_value */ nullptr,

  1512.     /* _ui_set_midi_program    */ nullptr,

  1513.     /* _ui_set_custom_data     */ nullptr,

  1514.     CarlaEngineNative::_activate,

  1515.     CarlaEngineNative::_deactivate,

  1516.     CarlaEngineNative::_process,

  1517.     CarlaEngineNative::_get_state,

  1518.     CarlaEngineNative::_set_state,

  1519.     CarlaEngineNative::_dispatcher

  1520. };

  1521. 

  1522. static const NativePluginDescriptor carlaPatchbayDesc = {

  1523.     /* category  */ ::PLUGIN_CATEGORY_OTHER,

  1524.     /* hints     */ static_cast<NativePluginHints>(::PLUGIN_IS_SYNTH|::PLUGIN_HAS_UI|::PLUGIN_NEEDS_FIXED_BUFFERS|::PLUGIN_NEEDS_SINGLE_THREAD|::PLUGIN_USES_STATE|::PLUGIN_USES_TIME),

  1525.     /* supports  */ static_cast<NativePluginSupports>(::PLUGIN_SUPPORTS_EVERYTHING),

  1526.     /* audioIns  */ 2,

  1527.     /* audioOuts */ 2,

  1528.     /* midiIns   */ 1,

  1529.     /* midiOuts  */ 1,

  1530.     /* paramIns  */ 0,

  1531.     /* paramOuts */ 0,

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

  1533.     /* label     */ "carlapatchbay",

  1534.     /* maker     */ "falkTX",

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

  1536.     CarlaEngineNative::_instantiatePatchbay,

  1537.     CarlaEngineNative::_cleanup,

  1538.     CarlaEngineNative::_get_parameter_count,

  1539.     CarlaEngineNative::_get_parameter_info,

  1540.     CarlaEngineNative::_get_parameter_value,

  1541.     CarlaEngineNative::_get_parameter_text,

  1542.     CarlaEngineNative::_get_midi_program_count,

  1543.     CarlaEngineNative::_get_midi_program_info,

  1544.     CarlaEngineNative::_set_parameter_value,

  1545.     CarlaEngineNative::_set_midi_program,

  1546.     /* _set_custom_data        */ nullptr,

  1547.     CarlaEngineNative::_ui_show,

  1548.     CarlaEngineNative::_ui_idle,

  1549.     /* _ui_set_parameter_value */ nullptr,

  1550.     /* _ui_set_midi_program    */ nullptr,

  1551.     /* _ui_set_custom_data     */ nullptr,

  1552.     CarlaEngineNative::_activate,

  1553.     CarlaEngineNative::_deactivate,

  1554.     CarlaEngineNative::_process,

  1555.     CarlaEngineNative::_get_state,

  1556.     CarlaEngineNative::_set_state,

  1557.     CarlaEngineNative::_dispatcher

  1558. };

  1559. 

  1560. CARLA_BACKEND_END_NAMESPACE

  1561. 

  1562. // -----------------------------------------------------------------------

  1563. 

  1564. CARLA_EXPORT

  1565. void carla_register_native_plugin_carla();

  1566. 

  1567. void carla_register_native_plugin_carla()

  1568. {

  1569.     CARLA_BACKEND_USE_NAMESPACE;

  1570.     carla_register_native_plugin(&carlaRackDesc);

  1571.     carla_register_native_plugin(&carlaPatchbayDesc);

  1572. }

  1573. 

  1574. // -----------------------------------------------------------------------

  1575. 

  1576. CARLA_EXPORT

  1577. const NativePluginDescriptor* get_carla_native_plugin();

  1578. 

  1579. const NativePluginDescriptor* get_carla_native_plugin()

  1580. {

  1581.     CARLA_BACKEND_USE_NAMESPACE;

  1582.     return &carlaRackDesc;

  1583. }

  1584. 

  1585. // -----------------------------------------------------------------------

  1586. // Extra stuff for linking purposes

  1587. 

  1588. #ifdef CARLA_PLUGIN_EXPORT

  1589. 

  1590. CARLA_BACKEND_START_NAMESPACE

  1591. 

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

  1593. 

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

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

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

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

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

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

  1600. # else

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

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

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

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

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

  1606. # endif

  1607. 

  1608. CARLA_BACKEND_END_NAMESPACE

  1609. 

  1610. #include "CarlaPluginUI.cpp"

  1611. #include "CarlaDssiUtils.cpp"

  1612. #include "CarlaStateUtils.cpp"

  1613. #include "CarlaJuceEvents.cpp"

  1614. 

  1615. #endif

  1616. 

  1617. // -----------------------------------------------------------------------