falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 43 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.
2707 Commits
17 Branches
116MB
Tree: c64986e622
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'c64986e622'
${ noResults }
Carla/source/backend/CarlaStandalone.cpp

2541 lines
90KB
Raw Blame History 

  1. /*

  2.  * Carla Standalone

  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. // TODO:

  19. // Check carla_stderr2("Engine is not running"); <= prepend func name and args

  20. 

  21. #include "CarlaHost.h"

  22. #include "CarlaMIDI.h"

  23. 

  24. #include "CarlaEngine.hpp"

  25. #include "CarlaPlugin.hpp"

  26. 

  27. #include "CarlaBackendUtils.hpp"

  28. #include "CarlaBase64Utils.hpp"

  29. 

  30. #ifdef HAVE_LIBLO

  31. # include "CarlaOscUtils.hpp"

  32. #endif

  33. 

  34. #include "juce_audio_formats.h"

  35. 

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

  37. # include "juce_gui_basics.h"

  38. #else

  39. namespace juce {

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

  41. } // namespace juce

  42. #endif

  43. 

  44. namespace CB = CarlaBackend;

  45. using CB::EngineOptions;

  46. 

  47. // -------------------------------------------------------------------------------------------------------------------

  48. // Single, standalone engine

  49. 

  50. struct CarlaBackendStandalone {

  51.     CarlaEngine*       engine;

  52.     EngineCallbackFunc engineCallback;

  53.     void*              engineCallbackPtr;

  54. #ifndef BUILD_BRIDGE

  55.     EngineOptions      engineOptions;

  56. #endif

  57. 

  58.     FileCallbackFunc fileCallback;

  59.     void*            fileCallbackPtr;

  60. 

  61.     CarlaString lastError;

  62. 

  63.     CarlaBackendStandalone() noexcept

  64.         : engine(nullptr),

  65.           engineCallback(nullptr),

  66.           engineCallbackPtr(nullptr),

  67. #ifndef BUILD_BRIDGE

  68.           engineOptions(),

  69. #endif

  70.           fileCallback(nullptr),

  71.           fileCallbackPtr(nullptr),

  72.           lastError() {}

  73. 

  74.     ~CarlaBackendStandalone() noexcept

  75.     {

  76.         CARLA_SAFE_ASSERT(engine == nullptr);

  77.     }

  78. 

  79.     CARLA_PREVENT_HEAP_ALLOCATION

  80.     CARLA_DECLARE_NON_COPY_STRUCT(CarlaBackendStandalone)

  81. };

  82. 

  83. static CarlaBackendStandalone gStandalone;

  84. 

  85. #ifdef HAVE_LIBLO

  86. // -------------------------------------------------------------------------------------------------------------------

  87. // NSM support

  88. 

  89. #define NSM_API_VERSION_MAJOR 1

  90. #define NSM_API_VERSION_MINOR 2

  91. 

  92. #define NSM_CLIENT_FEATURES ":switch:"

  93. //#define NSM_CLIENT_FEATURES ":switch:optional-gui:"

  94. 

  95. class CarlaNSM

  96. {

  97. public:

  98.     CarlaNSM() noexcept

  99.         : fOscAddress(nullptr),

  100.           fOscServer(nullptr),

  101.           fOscServerThread(nullptr),

  102.           fClientNameId(),

  103.           fProjectPath(),

  104.           fHasBroadcast(false),

  105.           fHasOptionalGui(false),

  106.           fHasServerControl(false),

  107.           fStarted() {}

  108. 

  109.     ~CarlaNSM()

  110.     {

  111.         if (fOscServerThread != nullptr)

  112.         {

  113.             lo_server_thread_stop(fOscServerThread);

  114.             lo_server_thread_free(fOscServerThread);

  115.             fOscServerThread = nullptr;

  116.             fOscServer = nullptr;

  117.         }

  118. 

  119.         if (fOscAddress != nullptr)

  120.         {

  121.             lo_address_free(fOscAddress);

  122.             fOscAddress = nullptr;

  123.         }

  124.     }

  125. 

  126.     bool announce(const int pid, const char* const executableName)

  127.     {

  128.         CARLA_SAFE_ASSERT_RETURN(pid != 0, false);

  129.         CARLA_SAFE_ASSERT_RETURN(executableName != nullptr && executableName[0] != '\0', false);

  130. 

  131.         const char* const NSM_URL(std::getenv("NSM_URL"));

  132. 

  133.         if (NSM_URL == nullptr)

  134.             return false;

  135. 

  136.         const lo_address addr = lo_address_new_from_url(NSM_URL);

  137.         CARLA_SAFE_ASSERT_RETURN(addr != nullptr, false);

  138. 

  139.         const int proto = lo_address_get_protocol(addr);

  140. 

  141.         if (fOscServerThread == nullptr)

  142.         {

  143.             // create new OSC server

  144.             fOscServerThread = lo_server_thread_new_with_proto(nullptr, proto, _osc_error_handler);

  145.             CARLA_SAFE_ASSERT_RETURN(fOscServerThread != nullptr, false);

  146. 

  147.             // register message handlers

  148.             lo_server_thread_add_method(fOscServerThread, "/error",                       "sis",    _error_handler,     this);

  149.             lo_server_thread_add_method(fOscServerThread, "/reply",                       "ssss",   _reply_handler,     this);

  150.             lo_server_thread_add_method(fOscServerThread, "/nsm/client/open",             "sss",    _open_handler,      this);

  151.             lo_server_thread_add_method(fOscServerThread, "/nsm/client/save",              "",      _save_handler,      this);

  152.             lo_server_thread_add_method(fOscServerThread, "/nsm/client/session_is_loaded", "",      _loaded_handler,    this);

  153.             lo_server_thread_add_method(fOscServerThread, "/nsm/client/show_optional_gui", "",      _show_gui_handler,  this);

  154.             lo_server_thread_add_method(fOscServerThread, "/nsm/client/hide_optional_gui", "",      _hide_gui_handler,  this);

  155.             lo_server_thread_add_method(fOscServerThread, nullptr,                         nullptr, _broadcast_handler, this);

  156. 

  157.             fOscServer = lo_server_thread_get_server(fOscServerThread);

  158.         }

  159. 

  160. #ifndef BUILD_ANSI_TEST

  161.         lo_send_from(addr, fOscServer, LO_TT_IMMEDIATE, "/nsm/server/announce", "sssiii",

  162.                      "Carla", NSM_CLIENT_FEATURES, executableName, NSM_API_VERSION_MAJOR, NSM_API_VERSION_MINOR, pid);

  163. #endif

  164. 

  165.         lo_address_free(addr);

  166. 

  167.         return true;

  168.     }

  169. 

  170.     void start()

  171.     {

  172.         CARLA_SAFE_ASSERT_RETURN(fOscServerThread != nullptr,);

  173.         CARLA_SAFE_ASSERT_RETURN(! fStarted,);

  174. 

  175.         fStarted = true;

  176.         lo_server_thread_start(fOscServerThread);

  177.     }

  178. 

  179.     static CarlaNSM& getInstance()

  180.     {

  181.         static CarlaNSM sInstance;

  182.         return sInstance;

  183.     }

  184. 

  185. protected:

  186.     int handleError(const char* const method, const int code, const char* const message)

  187.     {

  188.         carla_stdout("CarlaNSM::handleError(\"%s\", %i, \"%s\")", method, code, message);

  189. 

  190.         if (gStandalone.engineCallback != nullptr)

  191.             gStandalone.engineCallback(gStandalone.engineCallbackPtr, CB::ENGINE_CALLBACK_NSM, 0, 0, code, 0.0f, message);

  192. 

  193.         return 1;

  194. 

  195.         // may be unused

  196.         (void)method;

  197.     }

  198. 

  199.     int handleReply(const char* const method, const char* const message, const char* const smName, const char* const features,

  200.                     const lo_message msg)

  201.     {

  202.         CARLA_SAFE_ASSERT_RETURN(fOscServerThread != nullptr, 1);

  203.         carla_stdout("CarlaNSM::handleReply(\"%s\", \"%s\", \"%s\", \"%s\")", method, message, smName, features);

  204. 

  205.         if (std::strcmp(method, "/nsm/server/announce") == 0)

  206.         {

  207.             char* const addressURL(lo_address_get_url(lo_message_get_source(msg)));

  208.             CARLA_SAFE_ASSERT_RETURN(addressURL != nullptr, 0);

  209. 

  210.             if (fOscAddress != nullptr)

  211.                 lo_address_free(fOscAddress);

  212. 

  213.             fOscAddress = lo_address_new_from_url(addressURL);

  214.             CARLA_SAFE_ASSERT_RETURN(fOscAddress != nullptr, 0);

  215. 

  216.             fHasBroadcast     = std::strstr(features, ":broadcast:")      != nullptr;

  217.             fHasOptionalGui   = std::strstr(features, ":optional-gui:")   != nullptr;

  218.             fHasServerControl = std::strstr(features, ":server_control:") != nullptr;

  219. 

  220.             // UI starts visible

  221.             if (fHasOptionalGui)

  222.                 lo_send_from(fOscAddress, fOscServer, LO_TT_IMMEDIATE, "/nsm/client/gui_is_shown", "");

  223. 

  224.             carla_stdout("Carla started via '%s', message: %s", smName, message);

  225. 

  226.             if (gStandalone.engineCallback != nullptr)

  227.             {

  228.                 int flags = 0;

  229. 

  230.                 if (fHasBroadcast)

  231.                     flags |= 1 << 0;

  232.                 if (fHasOptionalGui)

  233.                     flags |= 1 << 1;

  234.                 if (fHasServerControl)

  235.                     flags |= 1 << 2;

  236. 

  237.                 gStandalone.engineCallback(gStandalone.engineCallbackPtr, CB::ENGINE_CALLBACK_NSM, 0, 1, flags, 0.0f, smName);

  238.             }

  239.         }

  240.         else

  241.         {

  242.             carla_stdout("Got unknown NSM reply method '%s'", method);

  243.         }

  244. 

  245.         return 0;

  246.     }

  247. 

  248.     int handleOpen(const char* const projectPath, const char* const displayName, const char* const clientNameId)

  249.     {

  250.         CARLA_SAFE_ASSERT_RETURN(fOscAddress != nullptr, 1);

  251.         CARLA_SAFE_ASSERT_RETURN(fOscServer != nullptr, 1);

  252.         carla_stdout("CarlaNSM::handleOpen(\"%s\", \"%s\", \"%s\")", projectPath, displayName, clientNameId);

  253. 

  254.         if (carla_is_engine_running())

  255.             carla_engine_close();

  256. 

  257.         carla_engine_init("JACK", clientNameId);

  258. 

  259.         fProjectPath  = projectPath;

  260.         fProjectPath += ".carxp";

  261. 

  262.         fClientNameId = clientNameId;

  263. 

  264.         using namespace juce;

  265. 

  266.         const String jfilename = String(CharPointer_UTF8(fProjectPath));

  267. 

  268.         if (File(jfilename).existsAsFile())

  269.             carla_load_project(fProjectPath);

  270. 

  271.         lo_send_from(fOscAddress, fOscServer, LO_TT_IMMEDIATE, "/reply", "ss", "/nsm/client/open", "OK");

  272. 

  273.         if (gStandalone.engineCallback != nullptr)

  274.             gStandalone.engineCallback(gStandalone.engineCallbackPtr, CB::ENGINE_CALLBACK_NSM, 0, 2, 0, 0.0f, projectPath);

  275. 

  276.         // Broadcast ourselves

  277.         if (fHasBroadcast)

  278.         {

  279.             char* const oscServerAddress(lo_server_get_url(fOscServer));

  280. 

  281.             if (lo_message msg = lo_message_new())

  282.             {

  283.                 lo_message_add(msg, "sssss",

  284.                                     "/non/hello",

  285.                                     oscServerAddress,

  286.                                     "Carla",

  287.                                     CARLA_VERSION_STRING,

  288.                                     fClientNameId.buffer());

  289. 

  290.                 lo_send_message_from(fOscAddress, fOscServer, "/nsm/server/broadcast", msg);

  291.                 lo_message_free(msg);

  292.             }

  293. 

  294.             std::free(oscServerAddress);

  295.         }

  296. 

  297.         return 0;

  298.     }

  299. 

  300.     int handleSave()

  301.     {

  302.         CARLA_SAFE_ASSERT_RETURN(fOscAddress != nullptr, 1);

  303.         CARLA_SAFE_ASSERT_RETURN(fOscServer != nullptr, 1);

  304.         CARLA_SAFE_ASSERT_RETURN(fProjectPath.isNotEmpty(), 0);

  305.         carla_stdout("CarlaNSM::handleSave()");

  306. 

  307.         carla_save_project(fProjectPath);

  308. 

  309.         lo_send_from(fOscAddress, fOscServer, LO_TT_IMMEDIATE, "/reply", "ss", "/nsm/client/save", "OK");

  310. 

  311.         if (gStandalone.engineCallback != nullptr)

  312.             gStandalone.engineCallback(gStandalone.engineCallbackPtr, CB::ENGINE_CALLBACK_NSM, 0, 3, 0, 0.0f, nullptr);

  313. 

  314.         return 0;

  315.     }

  316. 

  317.     int handleSessionIsLoaded()

  318.     {

  319.         CARLA_SAFE_ASSERT_RETURN(fOscAddress != nullptr, 1);

  320.         CARLA_SAFE_ASSERT_RETURN(fOscServer != nullptr, 1);

  321.         carla_stdout("CarlaNSM::handleSessionIsLoaded()");

  322. 

  323.         if (gStandalone.engineCallback != nullptr)

  324.             gStandalone.engineCallback(gStandalone.engineCallbackPtr, CB::ENGINE_CALLBACK_NSM, 0, 4, 0, 0.0f, nullptr);

  325. 

  326.         return 0;

  327.     }

  328. 

  329.     int handleShowOptionalGui()

  330.     {

  331.         CARLA_SAFE_ASSERT_RETURN(fOscAddress != nullptr, 1);

  332.         CARLA_SAFE_ASSERT_RETURN(fOscServer != nullptr, 1);

  333.         carla_stdout("CarlaNSM::handleShowOptionalGui()");

  334. 

  335.         lo_send_from(fOscAddress, fOscServer, LO_TT_IMMEDIATE, "/nsm/client/gui_is_shown", "");

  336. 

  337.         if (gStandalone.engineCallback != nullptr)

  338.             gStandalone.engineCallback(gStandalone.engineCallbackPtr, CB::ENGINE_CALLBACK_NSM, 0, 5, 0, 0.0f, nullptr);

  339. 

  340.         return 0;

  341.     }

  342. 

  343.     int handleHideOptionalGui()

  344.     {

  345.         CARLA_SAFE_ASSERT_RETURN(fOscAddress != nullptr, 1);

  346.         CARLA_SAFE_ASSERT_RETURN(fOscServer != nullptr, 1);

  347.         carla_stdout("CarlaNSM::handleHideOptionalGui()");

  348. 

  349.         lo_send_from(fOscAddress, fOscServer, LO_TT_IMMEDIATE, "/nsm/client/gui_is_hidden", "");

  350. 

  351.         if (gStandalone.engineCallback != nullptr)

  352.             gStandalone.engineCallback(gStandalone.engineCallbackPtr, CB::ENGINE_CALLBACK_NSM, 0, 6, 0, 0.0f, nullptr);

  353. 

  354.         return 0;

  355.     }

  356. 

  357.     int handleBroadcast(const char* const path, const char* const types, lo_arg** const argv, const int argc,

  358.                         const lo_message msg)

  359.     {

  360.         CARLA_SAFE_ASSERT_RETURN(fOscAddress != nullptr, 1);

  361.         CARLA_SAFE_ASSERT_RETURN(fOscServer != nullptr, 1);

  362.         CARLA_SAFE_ASSERT_RETURN(argc >= 0, 0);

  363.         carla_stdout("CarlaNSM::handleBroadcast(%s, %s, %p, %i)", path, types, argv, argc);

  364. 

  365.         if (std::strcmp(path, "/non/hello") == 0)

  366.         {

  367.             CARLA_SAFE_ASSERT_RETURN(argc == 4, 0);

  368.             CARLA_SAFE_ASSERT_RETURN(std::strcmp(types, "ssss") == 0, 0);

  369. 

  370.             const char* const url  = &argv[0]->s;

  371.             //const char* const name     = &argv[1]->s;

  372.             //const char* const version  = &argv[2]->s;

  373.             //const char* const clientId = &argv[3]->s;

  374. 

  375.             const lo_address targetAddress(lo_address_new_from_url(url));

  376.             CARLA_SAFE_ASSERT_RETURN(targetAddress != nullptr, 0);

  377. 

  378.             char* const oscServerAddress(lo_server_get_url(fOscServer));

  379.             CARLA_SAFE_ASSERT_RETURN(oscServerAddress != nullptr, 0);

  380. 

  381.             if (lo_message msg2 = lo_message_new())

  382.             {

  383.                 lo_message_add(msg2, "ss",

  384.                                     fClientNameId.buffer(),

  385.                                     oscServerAddress);

  386. 

  387.                 lo_send_message_from(targetAddress, fOscServer, "/signal/hello", msg2);

  388. 

  389.                 lo_message_free(msg2);

  390. 

  391.                 carla_stdout("CarlaNSM::handleBroadcast - sent hello");

  392.             }

  393. 

  394.             lo_address_free(targetAddress);

  395.             std::free(oscServerAddress);

  396. 

  397.             return 0;

  398.         }

  399. 

  400.         if (std::strcmp(path, "/signal/hello") == 0)

  401.         {

  402.             carla_stdout("CarlaNSM::handleBroadcast - got hello");

  403. 

  404.             //const char* const name = &argv[0]->s;

  405.             const char* const url  = &argv[1]->s;

  406. 

  407.             const lo_address targetAddress(lo_address_new_from_url(url));

  408.             CARLA_SAFE_ASSERT_RETURN(targetAddress != nullptr, 0);

  409. 

  410.             char* const oscServerAddress(lo_server_get_url(fOscServer));

  411.             CARLA_SAFE_ASSERT_RETURN(oscServerAddress != nullptr, 0);

  412. 

  413.             //lo_send_from(targetAddress, fOscServer, LO_TT_IMMEDIATE, "/signal/list", "");

  414. 

  415.             if (lo_message msg2 = lo_message_new())

  416.             {

  417.                 lo_message_add(msg2, "ss",

  418.                                     fClientNameId.buffer(),

  419.                                     oscServerAddress);

  420. 

  421.                 lo_send_message_from(targetAddress, fOscServer, "/signal/hello", msg2);

  422. 

  423.                 lo_message_free(msg2);

  424. 

  425.                 carla_stdout("CarlaNSM::handleBroadcast - sent hello");

  426.             }

  427. 

  428.             lo_address_free(targetAddress);

  429.             std::free(oscServerAddress);

  430. 

  431.             return 0;

  432.         }

  433. 

  434.         if (std::strcmp(path, "/signal/list") == 0)

  435.         {

  436.             carla_stdout("CarlaNSM::handleBroadcast - got list");

  437.             CARLA_SAFE_ASSERT_RETURN(carla_is_engine_running(), 0);

  438. 

  439.             //const char* prefix = nullptr;

  440. 

  441.             //if (argc > 0)

  442.                 //prefix = &argv[0]->s;

  443. 

  444.             const lo_address targetAddress(lo_message_get_source(msg));

  445.             CARLA_SAFE_ASSERT_RETURN(targetAddress != nullptr, 0);

  446. 

  447.             CarlaString stripName;

  448. 

  449.             for (uint32_t i = 0, pluginCount = carla_get_current_plugin_count(); i < pluginCount; ++i)

  450.             {

  451.                 const CarlaPluginInfo* const pluginInfo(carla_get_plugin_info(i));

  452.                 CARLA_SAFE_ASSERT_CONTINUE(pluginInfo != nullptr);

  453. 

  454.                 for (uint32_t j=0, paramCount = carla_get_parameter_count(i); j < paramCount; ++j)

  455.                 {

  456.                     const CarlaParameterInfo* const paramInfo(carla_get_parameter_info(i, j));

  457.                     CARLA_SAFE_ASSERT_CONTINUE(paramInfo != nullptr);

  458. 

  459.                     const ParameterData* const paramData(carla_get_parameter_data(i, j));

  460.                     CARLA_SAFE_ASSERT_CONTINUE(paramData != nullptr);

  461. 

  462.                     const ParameterRanges* const paramRanges(carla_get_parameter_ranges(i, j));

  463.                     CARLA_SAFE_ASSERT_CONTINUE(paramRanges != nullptr);

  464. 

  465.                     if (paramData->type != CB::PARAMETER_INPUT && paramData->type != CB::PARAMETER_OUTPUT)

  466.                         continue;

  467.                     if ((paramData->hints & CB::PARAMETER_IS_ENABLED) == 0)

  468.                         continue;

  469.                     if ((paramData->hints & CB::PARAMETER_IS_AUTOMABLE) == 0)

  470.                         continue;

  471.                     if (paramData->hints & CB::PARAMETER_IS_READ_ONLY)

  472.                         continue;

  473. 

  474.                     if (lo_message msg2 = lo_message_new())

  475.                     {

  476.                         stripName = fClientNameId + "/strip/Unnamed/" + pluginInfo->name + "/" + paramInfo->name;

  477.                         stripName.replace(' ','_');

  478. 

  479.                         lo_message_add(msg2, "sssfff",

  480.                                               path,

  481.                                               stripName.buffer(),

  482.                                               paramData->type == CB::PARAMETER_INPUT ? "in" : "out",

  483.                                               paramRanges->min,

  484.                                               paramRanges->max,

  485.                                               paramRanges->def);

  486.                         lo_send_message_from(targetAddress, fOscServer, "/reply", msg2);

  487.                         lo_message_free(msg2);

  488. 

  489.                         carla_stdout("CarlaNSM::handleBroadcast - sent list at %i : %i, path: %s", i+1, j+1, stripName.buffer());

  490.                     }

  491. 

  492. #if 0

  493.                     if (prefix == nullptr /*|| strncmp(o->path(), prefix, std::strlen(prefix)) == 0*/)

  494.                     {

  495.                         lo_send_from(targetAddress, fOscServer, LO_TT_IMMEDIATE, "/reply", "sssfff",

  496.                                      path,

  497.                                      paramInfo->name,

  498.                                      paramData->type == CB::PARAMETER_INPUT ? "in" : "out",

  499.                                      paramRanges->min,

  500.                                      paramRanges->max,

  501.                                      paramRanges->def);

  502.                     }

  503. #endif

  504.                 }

  505.             }

  506. 

  507.             if (lo_message msg2 = lo_message_new())

  508.             {

  509.                 lo_message_add(msg2, "s", path);

  510. 

  511.                 lo_send_message_from(targetAddress, fOscServer, "/reply", msg2);

  512. 

  513.                 lo_message_free(msg2);

  514. 

  515.                 carla_stdout("CarlaNSM::handleBroadcast - sent list final");

  516.             }

  517. 

  518.             //lo_send_from(targetAddress, fOscServer, LO_TT_IMMEDIATE, "/reply", "s", path);

  519. 

  520.             //return 0;

  521.         }

  522. 

  523. #if 0

  524.         if (std::strcmp(path, "/reply") == 0)

  525.         {

  526.             CARLA_SAFE_ASSERT_RETURN(argc > 0, 0);

  527. 

  528.             const char* const method = &argv[0]->s;

  529. 

  530.             if (std::strcmp(method, "/signal/list") == 0)

  531.             {

  532.                 carla_stdout("CarlaNSM::handleBroadcast - got new list");

  533. 

  534.                 if (argc == 1)

  535.                     return 0;

  536.                 CARLA_SAFE_ASSERT_RETURN(argc == 6, 0);

  537. 

  538.                 const lo_address targetAddress(lo_message_get_source(msg));

  539.                 CARLA_SAFE_ASSERT_RETURN(targetAddress != nullptr, 0);

  540. 

  541.                 const char* const stripName   = &argv[1]->s;

  542.                 const char* const orientation = &argv[2]->s;

  543.                 const float min = argv[3]->f;

  544.                 const float max = argv[4]->f;

  545.                 const float def = argv[5]->f;

  546. 

  547.                 if (lo_message msg2 = lo_message_new())

  548.                 {

  549.                     lo_message_add(msg2, "sssfff",

  550.                                           method,

  551.                                           stripName,

  552.                                           orientation,

  553.                                           min,

  554.                                           max,

  555.                                           def);

  556.                     lo_send_message_from(targetAddress, fOscServer, "/reply", msg2);

  557.                     lo_message_free(msg2);

  558.                 }

  559.             }

  560.             else

  561.             {

  562.                 CARLA_SAFE_ASSERT(false);

  563.             }

  564. 

  565.             return 0;

  566.         }

  567. #endif

  568. 

  569.         // check if all args are strings

  570.         for (int i=0; i<argc; ++i)

  571.         {

  572.             if (types[i] != 's')

  573.                 return 0;

  574.         }

  575. 

  576.         for (int i=0; i<argc; ++i)

  577.             carla_stdout("%i: %s", i+1, &argv[i]->s);

  578. 

  579.         return 0;

  580.     }

  581. 

  582. private:

  583.     lo_address       fOscAddress;

  584.     lo_server        fOscServer;

  585.     lo_server_thread fOscServerThread;

  586.     CarlaString      fClientNameId;

  587.     CarlaString      fProjectPath;

  588. 

  589.     bool fHasBroadcast;

  590.     bool fHasOptionalGui;

  591.     bool fHasServerControl;

  592.     bool fStarted;

  593. 

  594.     #define handlePtr ((CarlaNSM*)data)

  595. 

  596.     static void _osc_error_handler(int num, const char* msg, const char* path)

  597.     {

  598.         carla_stderr2("CarlaNSM::_osc_error_handler(%i, \"%s\", \"%s\")", num, msg, path);

  599.     }

  600. 

  601.     static int _error_handler(const char*, const char* types, lo_arg** argv, int argc, lo_message, void* data)

  602.     {

  603.         CARLA_SAFE_ASSERT_RETURN(argc == 3, 1);

  604.         CARLA_SAFE_ASSERT_RETURN(std::strcmp(types, "sis") == 0, 1);

  605. 

  606.         const char* const method  = &argv[0]->s;

  607.         const int         code    =  argv[1]->i;

  608.         const char* const message = &argv[2]->s;

  609. 

  610.         return handlePtr->handleError(method, code, message);

  611.     }

  612. 

  613.     static int _reply_handler(const char*, const char* types, lo_arg** argv, int argc, lo_message msg, void* data)

  614.     {

  615.         CARLA_SAFE_ASSERT_RETURN(argc == 4, 1);

  616.         CARLA_SAFE_ASSERT_RETURN(std::strcmp(types, "ssss") == 0, 1);

  617. 

  618.         const char* const method   = &argv[0]->s;

  619.         const char* const message  = &argv[1]->s;

  620.         const char* const smName   = &argv[2]->s;

  621.         const char* const features = &argv[3]->s;

  622. 

  623.         return handlePtr->handleReply(method, message, smName, features, msg);

  624.     }

  625. 

  626.     static int _open_handler(const char*, const char* types, lo_arg** argv, int argc, lo_message, void* data)

  627.     {

  628.         CARLA_SAFE_ASSERT_RETURN(argc == 3, 1);

  629.         CARLA_SAFE_ASSERT_RETURN(std::strcmp(types, "sss") == 0, 1);

  630. 

  631.         const char* const projectPath  = &argv[0]->s;

  632.         const char* const displayName  = &argv[1]->s;

  633.         const char* const clientNameId = &argv[2]->s;

  634. 

  635.         return handlePtr->handleOpen(projectPath, displayName, clientNameId);

  636.     }

  637. 

  638.     static int _save_handler(const char*, const char*, lo_arg**, int argc, lo_message, void* data)

  639.     {

  640.         CARLA_SAFE_ASSERT_RETURN(argc == 0, 1);

  641. 

  642.         return handlePtr->handleSave();

  643.     }

  644. 

  645.     static int _loaded_handler(const char*, const char*, lo_arg**, int argc, lo_message, void* data)

  646.     {

  647.         CARLA_SAFE_ASSERT_RETURN(argc == 0, 1);

  648. 

  649.         return handlePtr->handleSessionIsLoaded();

  650.     }

  651. 

  652.     static int _show_gui_handler(const char*, const char*, lo_arg**, int argc, lo_message, void* data)

  653.     {

  654.         CARLA_SAFE_ASSERT_RETURN(argc == 0, 1);

  655. 

  656.         return handlePtr->handleShowOptionalGui();

  657.     }

  658. 

  659.     static int _hide_gui_handler(const char*, const char*, lo_arg**, int argc, lo_message, void* data)

  660.     {

  661.         CARLA_SAFE_ASSERT_RETURN(argc == 0, 1);

  662. 

  663.         return handlePtr->handleHideOptionalGui();

  664.     }

  665. 

  666.     static int _broadcast_handler(const char* path, const char* types, lo_arg** argv, int argc, lo_message msg, void* data)

  667.     {

  668.         return handlePtr->handleBroadcast(path, types, argv, argc, msg);

  669.     }

  670. 

  671.     #undef handlePtr

  672. 

  673.     CARLA_PREVENT_HEAP_ALLOCATION

  674.     CARLA_DECLARE_NON_COPY_CLASS(CarlaNSM)

  675. };

  676. 

  677. #endif // HAVE_LIBLO

  678. 

  679. // -------------------------------------------------------------------------------------------------------------------

  680. // API

  681. 

  682. #define CARLA_COMMON_NEED_CHECKSTRINGPTR

  683. #include "CarlaHostCommon.cpp"

  684. 

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

  686. 

  687. uint carla_get_engine_driver_count()

  688. {

  689.     carla_debug("carla_get_engine_driver_count()");

  690. 

  691.     return CarlaEngine::getDriverCount();

  692. }

  693. 

  694. const char* carla_get_engine_driver_name(uint index)

  695. {

  696.     carla_debug("carla_get_engine_driver_name(%i)", index);

  697. 

  698.     return CarlaEngine::getDriverName(index);

  699. }

  700. 

  701. const char* const* carla_get_engine_driver_device_names(uint index)

  702. {

  703.     carla_debug("carla_get_engine_driver_device_names(%i)", index);

  704. 

  705.     return CarlaEngine::getDriverDeviceNames(index);

  706. }

  707. 

  708. const EngineDriverDeviceInfo* carla_get_engine_driver_device_info(uint index, const char* name)

  709. {

  710.     CARLA_SAFE_ASSERT_RETURN(name != nullptr && name[0] != '\0', nullptr);

  711.     carla_debug("carla_get_engine_driver_device_info(%i, \"%s\")", index, name);

  712. 

  713.     if (const EngineDriverDeviceInfo* const ret = CarlaEngine::getDriverDeviceInfo(index, name))

  714.     {

  715.         static EngineDriverDeviceInfo devInfo;

  716.         static const uint32_t nullBufferSizes[] = { 0   };

  717.         static const double   nullSampleRates[] = { 0.0 };

  718. 

  719.         devInfo.hints       = ret->hints;

  720.         devInfo.bufferSizes = (ret->bufferSizes != nullptr) ? ret->bufferSizes : nullBufferSizes;

  721.         devInfo.sampleRates = (ret->sampleRates != nullptr) ? ret->sampleRates : nullSampleRates;

  722.         return &devInfo;

  723.     }

  724. 

  725.     return nullptr;

  726. }

  727. 

  728. // -------------------------------------------------------------------------------------------------------------------

  729. 

  730. CarlaEngine* carla_get_engine()

  731. {

  732.     carla_debug("carla_get_engine()");

  733. 

  734.     return gStandalone.engine;

  735. }

  736. 

  737. // -------------------------------------------------------------------------------------------------------------------

  738. 

  739. static void carla_engine_init_common()

  740. {

  741.     gStandalone.engine->setCallback(gStandalone.engineCallback, gStandalone.engineCallbackPtr);

  742.     gStandalone.engine->setFileCallback(gStandalone.fileCallback, gStandalone.fileCallbackPtr);

  743. 

  744. #ifdef BUILD_BRIDGE

  745.     using juce::File;

  746.     File juceBinaryDir(File::getSpecialLocation(File::currentExecutableFile).getParentDirectory());

  747. 

  748.     /*

  749.     if (const char* const uisAlwaysOnTop = std::getenv("ENGINE_OPTION_FORCE_STEREO"))

  750.         gStandalone.engine->setOption(CB::ENGINE_OPTION_FORCE_STEREO, (std::strcmp(uisAlwaysOnTop, "true") == 0) ? 1 : 0, nullptr);

  751. 

  752.     if (const char* const uisAlwaysOnTop = std::getenv("ENGINE_OPTION_PREFER_PLUGIN_BRIDGES"))

  753.         gStandalone.engine->setOption(CB::ENGINE_OPTION_PREFER_PLUGIN_BRIDGES, (std::strcmp(uisAlwaysOnTop, "true") == 0) ? 1 : 0, nullptr);

  754. 

  755.     if (const char* const uisAlwaysOnTop = std::getenv("ENGINE_OPTION_PREFER_UI_BRIDGES"))

  756.         gStandalone.engine->setOption(CB::ENGINE_OPTION_PREFER_UI_BRIDGES, (std::strcmp(uisAlwaysOnTop, "true") == 0) ? 1 : 0, nullptr);

  757.     */

  758. 

  759.     if (const char* const uisAlwaysOnTop = std::getenv("ENGINE_OPTION_UIS_ALWAYS_ON_TOP"))

  760.         gStandalone.engine->setOption(CB::ENGINE_OPTION_UIS_ALWAYS_ON_TOP, (std::strcmp(uisAlwaysOnTop, "true") == 0) ? 1 : 0, nullptr);

  761. 

  762.     if (const char* const maxParameters = std::getenv("ENGINE_OPTION_MAX_PARAMETERS"))

  763.         gStandalone.engine->setOption(CB::ENGINE_OPTION_MAX_PARAMETERS,     std::atoi(maxParameters), nullptr);

  764. 

  765.     if (const char* const uiBridgesTimeout = std::getenv("ENGINE_OPTION_UI_BRIDGES_TIMEOUT"))

  766.         gStandalone.engine->setOption(CB::ENGINE_OPTION_UI_BRIDGES_TIMEOUT, std::atoi(uiBridgesTimeout), nullptr);

  767. 

  768.     if (const char* const pathLADSPA = std::getenv("ENGINE_OPTION_PLUGIN_PATH_LADSPA"))

  769.         gStandalone.engine->setOption(CB::ENGINE_OPTION_PLUGIN_PATH, CB::PLUGIN_LADSPA, pathLADSPA);

  770. 

  771.     if (const char* const pathDSSI = std::getenv("ENGINE_OPTION_PLUGIN_PATH_DSSI"))

  772.         gStandalone.engine->setOption(CB::ENGINE_OPTION_PLUGIN_PATH, CB::PLUGIN_DSSI, pathDSSI);

  773. 

  774.     if (const char* const pathLV2 = std::getenv("ENGINE_OPTION_PLUGIN_PATH_LV2"))

  775.         gStandalone.engine->setOption(CB::ENGINE_OPTION_PLUGIN_PATH, CB::PLUGIN_LV2, pathLV2);

  776. 

  777.     if (const char* const pathVST2 = std::getenv("ENGINE_OPTION_PLUGIN_PATH_VST2"))

  778.         gStandalone.engine->setOption(CB::ENGINE_OPTION_PLUGIN_PATH, CB::PLUGIN_VST2, pathVST2);

  779. 

  780.     if (const char* const pathVST3 = std::getenv("ENGINE_OPTION_PLUGIN_PATH_VST3"))

  781.         gStandalone.engine->setOption(CB::ENGINE_OPTION_PLUGIN_PATH, CB::PLUGIN_VST3, pathVST3);

  782. 

  783.     if (const char* const pathAU = std::getenv("ENGINE_OPTION_PLUGIN_PATH_AU"))

  784.         gStandalone.engine->setOption(CB::ENGINE_OPTION_PLUGIN_PATH, CB::PLUGIN_AU, pathAU);

  785. 

  786.     if (const char* const pathGIG = std::getenv("ENGINE_OPTION_PLUGIN_PATH_GIG"))

  787.         gStandalone.engine->setOption(CB::ENGINE_OPTION_PLUGIN_PATH, CB::PLUGIN_GIG, pathGIG);

  788. 

  789.     if (const char* const pathSF2 = std::getenv("ENGINE_OPTION_PLUGIN_PATH_SF2"))

  790.         gStandalone.engine->setOption(CB::ENGINE_OPTION_PLUGIN_PATH, CB::PLUGIN_SF2, pathSF2);

  791. 

  792.     if (const char* const pathSFZ = std::getenv("ENGINE_OPTION_PLUGIN_PATH_SFZ"))

  793.         gStandalone.engine->setOption(CB::ENGINE_OPTION_PLUGIN_PATH, CB::PLUGIN_SFZ, pathSFZ);

  794. 

  795.     if (const char* const binaryDir = std::getenv("ENGINE_OPTION_PATH_BINARIES"))

  796.         gStandalone.engine->setOption(CB::ENGINE_OPTION_PATH_BINARIES,   0, binaryDir);

  797.     else

  798.         gStandalone.engine->setOption(CB::ENGINE_OPTION_PATH_BINARIES,   0, juceBinaryDir.getFullPathName().toRawUTF8());

  799. 

  800.     if (const char* const resourceDir = std::getenv("ENGINE_OPTION_PATH_RESOURCES"))

  801.         gStandalone.engine->setOption(CB::ENGINE_OPTION_PATH_RESOURCES,  0, resourceDir);

  802.     else

  803.         gStandalone.engine->setOption(CB::ENGINE_OPTION_PATH_RESOURCES,  0, juceBinaryDir.getChildFile("resources").getFullPathName().toRawUTF8());

  804. 

  805.     if (const char* const preventBadBehaviour = std::getenv("ENGINE_OPTION_PREVENT_BAD_BEHAVIOUR"))

  806.         gStandalone.engine->setOption(CB::ENGINE_OPTION_PREVENT_BAD_BEHAVIOUR, (std::strcmp(preventBadBehaviour, "true") == 0) ? 1 : 0, nullptr);

  807. 

  808.     if (const char* const frontendWinId = std::getenv("ENGINE_OPTION_FRONTEND_WIN_ID"))

  809.         gStandalone.engine->setOption(CB::ENGINE_OPTION_FRONTEND_WIN_ID, 0, frontendWinId);

  810. #else

  811.     gStandalone.engine->setOption(CB::ENGINE_OPTION_FORCE_STEREO,          gStandalone.engineOptions.forceStereo         ? 1 : 0,        nullptr);

  812.     gStandalone.engine->setOption(CB::ENGINE_OPTION_PREFER_PLUGIN_BRIDGES, gStandalone.engineOptions.preferPluginBridges ? 1 : 0,        nullptr);

  813.     gStandalone.engine->setOption(CB::ENGINE_OPTION_PREFER_UI_BRIDGES,     gStandalone.engineOptions.preferUiBridges     ? 1 : 0,        nullptr);

  814.     gStandalone.engine->setOption(CB::ENGINE_OPTION_UIS_ALWAYS_ON_TOP,     gStandalone.engineOptions.uisAlwaysOnTop      ? 1 : 0,        nullptr);

  815.     gStandalone.engine->setOption(CB::ENGINE_OPTION_MAX_PARAMETERS,        static_cast<int>(gStandalone.engineOptions.maxParameters),    nullptr);

  816.     gStandalone.engine->setOption(CB::ENGINE_OPTION_UI_BRIDGES_TIMEOUT,    static_cast<int>(gStandalone.engineOptions.uiBridgesTimeout), nullptr);

  817.     gStandalone.engine->setOption(CB::ENGINE_OPTION_AUDIO_NUM_PERIODS,     static_cast<int>(gStandalone.engineOptions.audioNumPeriods),  nullptr);

  818.     gStandalone.engine->setOption(CB::ENGINE_OPTION_AUDIO_BUFFER_SIZE,     static_cast<int>(gStandalone.engineOptions.audioBufferSize),  nullptr);

  819.     gStandalone.engine->setOption(CB::ENGINE_OPTION_AUDIO_SAMPLE_RATE,     static_cast<int>(gStandalone.engineOptions.audioSampleRate),  nullptr);

  820. 

  821.     if (gStandalone.engineOptions.audioDevice != nullptr)

  822.         gStandalone.engine->setOption(CB::ENGINE_OPTION_AUDIO_DEVICE,      0, gStandalone.engineOptions.audioDevice);

  823. 

  824.     if (gStandalone.engineOptions.pathLADSPA != nullptr)

  825.         gStandalone.engine->setOption(CB::ENGINE_OPTION_PLUGIN_PATH,       CB::PLUGIN_LADSPA, gStandalone.engineOptions.pathLADSPA);

  826. 

  827.     if (gStandalone.engineOptions.pathDSSI != nullptr)

  828.         gStandalone.engine->setOption(CB::ENGINE_OPTION_PLUGIN_PATH,       CB::PLUGIN_DSSI, gStandalone.engineOptions.pathDSSI);

  829. 

  830.     if (gStandalone.engineOptions.pathLV2 != nullptr)

  831.         gStandalone.engine->setOption(CB::ENGINE_OPTION_PLUGIN_PATH,       CB::PLUGIN_LV2, gStandalone.engineOptions.pathLV2);

  832. 

  833.     if (gStandalone.engineOptions.pathVST2 != nullptr)

  834.         gStandalone.engine->setOption(CB::ENGINE_OPTION_PLUGIN_PATH,       CB::PLUGIN_VST2, gStandalone.engineOptions.pathVST2);

  835. 

  836.     if (gStandalone.engineOptions.pathVST3 != nullptr)

  837.         gStandalone.engine->setOption(CB::ENGINE_OPTION_PLUGIN_PATH,       CB::PLUGIN_VST3, gStandalone.engineOptions.pathVST3);

  838. 

  839.     if (gStandalone.engineOptions.pathAU != nullptr)

  840.         gStandalone.engine->setOption(CB::ENGINE_OPTION_PLUGIN_PATH,       CB::PLUGIN_AU, gStandalone.engineOptions.pathAU);

  841. 

  842.     if (gStandalone.engineOptions.pathGIG != nullptr)

  843.         gStandalone.engine->setOption(CB::ENGINE_OPTION_PLUGIN_PATH,       CB::PLUGIN_GIG, gStandalone.engineOptions.pathGIG);

  844. 

  845.     if (gStandalone.engineOptions.pathSF2 != nullptr)

  846.         gStandalone.engine->setOption(CB::ENGINE_OPTION_PLUGIN_PATH,       CB::PLUGIN_SF2, gStandalone.engineOptions.pathSF2);

  847. 

  848.     if (gStandalone.engineOptions.pathSFZ != nullptr)

  849.         gStandalone.engine->setOption(CB::ENGINE_OPTION_PLUGIN_PATH,       CB::PLUGIN_SFZ, gStandalone.engineOptions.pathSFZ);

  850. 

  851.     if (gStandalone.engineOptions.binaryDir != nullptr && gStandalone.engineOptions.binaryDir[0] != '\0')

  852.         gStandalone.engine->setOption(CB::ENGINE_OPTION_PATH_BINARIES,     0, gStandalone.engineOptions.binaryDir);

  853. 

  854.     if (gStandalone.engineOptions.resourceDir != nullptr && gStandalone.engineOptions.resourceDir[0] != '\0')

  855.         gStandalone.engine->setOption(CB::ENGINE_OPTION_PATH_RESOURCES,    0, gStandalone.engineOptions.resourceDir);

  856. 

  857.     gStandalone.engine->setOption(CB::ENGINE_OPTION_PREVENT_BAD_BEHAVIOUR,    gStandalone.engineOptions.preventBadBehaviour ? 1 : 0,  nullptr);

  858. 

  859.     if (gStandalone.engineOptions.frontendWinId != 0)

  860.     {

  861.         char strBuf[STR_MAX+1];

  862.         strBuf[STR_MAX] = '\0';

  863.         std::snprintf(strBuf, STR_MAX, P_UINTPTR, gStandalone.engineOptions.frontendWinId);

  864.         gStandalone.engine->setOption(CB::ENGINE_OPTION_FRONTEND_WIN_ID, 0, strBuf);

  865.     }

  866.     else

  867.         gStandalone.engine->setOption(CB::ENGINE_OPTION_FRONTEND_WIN_ID, 0, "0");

  868. #endif

  869. }

  870. 

  871. bool carla_engine_init(const char* driverName, const char* clientName)

  872. {

  873.     CARLA_SAFE_ASSERT_RETURN(driverName != nullptr && driverName[0] != '\0', false);

  874.     CARLA_SAFE_ASSERT_RETURN(clientName != nullptr && clientName[0] != '\0', false);

  875.     carla_debug("carla_engine_init(\"%s\", \"%s\")", driverName, clientName);

  876. 

  877.     if (gStandalone.engine != nullptr)

  878.     {

  879.         carla_stderr2("Engine is already running");

  880.         gStandalone.lastError = "Engine is already running";

  881.         return false;

  882.     }

  883. 

  884. #ifdef CARLA_OS_WIN

  885.     carla_setenv("WINEASIO_CLIENT_NAME", clientName);

  886. #endif

  887. 

  888.     // TODO: make this an option, put somewhere else

  889.     if (std::getenv("WINE_RT") == nullptr)

  890.     {

  891.         carla_setenv("WINE_RT", "15");

  892.         carla_setenv("WINE_SVR_RT", "10");

  893.     }

  894. 

  895.     gStandalone.engine = CarlaEngine::newDriverByName(driverName);

  896. 

  897.     if (gStandalone.engine == nullptr)

  898.     {

  899.         carla_stderr2("The seleted audio driver is not available");

  900.         gStandalone.lastError = "The seleted audio driver is not available";

  901.         return false;

  902.     }

  903. 

  904. #ifdef BUILD_BRIDGE

  905.     gStandalone.engine->setOption(CB::ENGINE_OPTION_PROCESS_MODE,          CB::ENGINE_PROCESS_MODE_MULTIPLE_CLIENTS,                  nullptr);

  906.     gStandalone.engine->setOption(CB::ENGINE_OPTION_TRANSPORT_MODE,        CB::ENGINE_TRANSPORT_MODE_JACK,                            nullptr);

  907.     gStandalone.engine->setOption(CB::ENGINE_OPTION_FORCE_STEREO,          false,                                                     nullptr);

  908.     gStandalone.engine->setOption(CB::ENGINE_OPTION_PREFER_PLUGIN_BRIDGES, false,                                                     nullptr);

  909.     gStandalone.engine->setOption(CB::ENGINE_OPTION_PREFER_UI_BRIDGES,     false,                                                     nullptr);

  910. #else

  911.     gStandalone.engine->setOption(CB::ENGINE_OPTION_PROCESS_MODE,          static_cast<int>(gStandalone.engineOptions.processMode),   nullptr);

  912.     gStandalone.engine->setOption(CB::ENGINE_OPTION_TRANSPORT_MODE,        static_cast<int>(gStandalone.engineOptions.transportMode), nullptr);

  913. #endif

  914. 

  915.     carla_engine_init_common();

  916. 

  917.     if (gStandalone.engine->init(clientName))

  918.     {

  919. #ifndef BUILD_BRIDGE

  920.         juce::initialiseJuce_GUI();

  921. #endif

  922.         gStandalone.lastError = "No error";

  923.         return true;

  924.     }

  925.     else

  926.     {

  927.         gStandalone.lastError = gStandalone.engine->getLastError();

  928.         delete gStandalone.engine;

  929.         gStandalone.engine = nullptr;

  930.         return false;

  931.     }

  932. }

  933. 

  934. #ifdef BUILD_BRIDGE

  935. bool carla_engine_init_bridge(const char audioBaseName[6+1], const char rtClientBaseName[6+1], const char nonRtClientBaseName[6+1],

  936.                               const char nonRtServerBaseName[6+1], const char* clientName)

  937. {

  938.     CARLA_SAFE_ASSERT_RETURN(audioBaseName != nullptr && audioBaseName[0] != '\0', false);

  939.     CARLA_SAFE_ASSERT_RETURN(rtClientBaseName != nullptr && rtClientBaseName[0] != '\0', false);

  940.     CARLA_SAFE_ASSERT_RETURN(nonRtClientBaseName != nullptr && nonRtClientBaseName[0] != '\0', false);

  941.     CARLA_SAFE_ASSERT_RETURN(nonRtServerBaseName != nullptr && nonRtServerBaseName[0] != '\0', false);

  942.     CARLA_SAFE_ASSERT_RETURN(clientName != nullptr && clientName[0] != '\0', false);

  943.     carla_debug("carla_engine_init_bridge(\"%s\", \"%s\", \"%s\", \"%s\", \"%s\")", audioBaseName, rtClientBaseName, nonRtClientBaseName, nonRtServerBaseName, clientName);

  944. 

  945.     if (gStandalone.engine != nullptr)

  946.     {

  947.         carla_stderr2("Engine is already running");

  948.         gStandalone.lastError = "Engine is already running";

  949.         return false;

  950.     }

  951. 

  952.     gStandalone.engine = CarlaEngine::newBridge(audioBaseName, rtClientBaseName, nonRtClientBaseName, nonRtServerBaseName);

  953. 

  954.     if (gStandalone.engine == nullptr)

  955.     {

  956.         carla_stderr2("The seleted audio driver is not available!");

  957.         gStandalone.lastError = "The seleted audio driver is not available!";

  958.         return false;

  959.     }

  960. 

  961.     carla_engine_init_common();

  962. 

  963.     gStandalone.engine->setOption(CB::ENGINE_OPTION_PROCESS_MODE,   CB::ENGINE_PROCESS_MODE_BRIDGE,   nullptr);

  964.     gStandalone.engine->setOption(CB::ENGINE_OPTION_TRANSPORT_MODE, CB::ENGINE_TRANSPORT_MODE_BRIDGE, nullptr);

  965. 

  966.     if (gStandalone.engine->init(clientName))

  967.     {

  968.         gStandalone.lastError = "No error";

  969.         return true;

  970.     }

  971.     else

  972.     {

  973.         gStandalone.lastError = gStandalone.engine->getLastError();

  974.         delete gStandalone.engine;

  975.         gStandalone.engine = nullptr;

  976.         return false;

  977.     }

  978. }

  979. #endif

  980. 

  981. bool carla_engine_close()

  982. {

  983.     carla_debug("carla_engine_close()");

  984. 

  985.     if (gStandalone.engine == nullptr)

  986.     {

  987.         carla_stderr2("Engine is not running");

  988.         gStandalone.lastError = "Engine is not running";

  989.         return false;

  990.     }

  991. 

  992.     gStandalone.engine->setAboutToClose();

  993.     gStandalone.engine->removeAllPlugins();

  994. 

  995.     const bool closed(gStandalone.engine->close());

  996. 

  997.     if (! closed)

  998.         gStandalone.lastError = gStandalone.engine->getLastError();

  999. 

  1000. #ifndef BUILD_BRIDGE

  1001.     juce::shutdownJuce_GUI();

  1002. #endif

  1003.     delete gStandalone.engine;

  1004.     gStandalone.engine = nullptr;

  1005. 

  1006.     return closed;

  1007. }

  1008. 

  1009. void carla_engine_idle()

  1010. {

  1011.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr,);

  1012. 

  1013.     gStandalone.engine->idle();

  1014. }

  1015. 

  1016. bool carla_is_engine_running()

  1017. {

  1018.     return (gStandalone.engine != nullptr && gStandalone.engine->isRunning());

  1019. }

  1020. 

  1021. void carla_set_engine_about_to_close()

  1022. {

  1023.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr,);

  1024.     carla_debug("carla_set_engine_about_to_close()");

  1025. 

  1026.     gStandalone.engine->setAboutToClose();

  1027. }

  1028. 

  1029. void carla_set_engine_callback(EngineCallbackFunc func, void* ptr)

  1030. {

  1031.     carla_debug("carla_set_engine_callback(%p, %p)", func, ptr);

  1032. 

  1033.     gStandalone.engineCallback    = func;

  1034.     gStandalone.engineCallbackPtr = ptr;

  1035. 

  1036.     if (gStandalone.engine != nullptr)

  1037.         gStandalone.engine->setCallback(func, ptr);

  1038. 

  1039. //#ifdef WANT_LOGS

  1040. //    gLogThread.setCallback(func, ptr);

  1041. //#endif

  1042. }

  1043. 

  1044. #ifndef BUILD_BRIDGE

  1045. void carla_set_engine_option(EngineOption option, int value, const char* valueStr)

  1046. {

  1047.     carla_debug("carla_set_engine_option(%i:%s, %i, \"%s\")", option, CB::EngineOption2Str(option), value, valueStr);

  1048. 

  1049.     switch (option)

  1050.     {

  1051.     case CB::ENGINE_OPTION_DEBUG:

  1052.         break;

  1053. 

  1054.     case CB::ENGINE_OPTION_PROCESS_MODE:

  1055.         CARLA_SAFE_ASSERT_RETURN(value >= CB::ENGINE_PROCESS_MODE_SINGLE_CLIENT && value < CB::ENGINE_PROCESS_MODE_BRIDGE,);

  1056.         gStandalone.engineOptions.processMode = static_cast<CB::EngineProcessMode>(value);

  1057.         break;

  1058. 

  1059.     case CB::ENGINE_OPTION_TRANSPORT_MODE:

  1060.         CARLA_SAFE_ASSERT_RETURN(value >= CB::ENGINE_TRANSPORT_MODE_INTERNAL && value < CB::ENGINE_TRANSPORT_MODE_BRIDGE,);

  1061.         gStandalone.engineOptions.transportMode = static_cast<CB::EngineTransportMode>(value);

  1062.         break;

  1063. 

  1064.     case CB::ENGINE_OPTION_FORCE_STEREO:

  1065.         CARLA_SAFE_ASSERT_RETURN(value == 0 || value == 1,);

  1066.         gStandalone.engineOptions.forceStereo = (value != 0);

  1067.         break;

  1068. 

  1069.     case CB::ENGINE_OPTION_PREFER_PLUGIN_BRIDGES:

  1070.         CARLA_SAFE_ASSERT_RETURN(value == 0 || value == 1,);

  1071.         gStandalone.engineOptions.preferPluginBridges = (value != 0);

  1072.         break;

  1073. 

  1074.     case CB::ENGINE_OPTION_PREFER_UI_BRIDGES:

  1075.         CARLA_SAFE_ASSERT_RETURN(value == 0 || value == 1,);

  1076.         gStandalone.engineOptions.preferUiBridges = (value != 0);

  1077.         break;

  1078. 

  1079.     case CB::ENGINE_OPTION_UIS_ALWAYS_ON_TOP:

  1080.         CARLA_SAFE_ASSERT_RETURN(value == 0 || value == 1,);

  1081.         gStandalone.engineOptions.uisAlwaysOnTop = (value != 0);

  1082.         break;

  1083. 

  1084.     case CB::ENGINE_OPTION_MAX_PARAMETERS:

  1085.         CARLA_SAFE_ASSERT_RETURN(value >= 0,);

  1086.         gStandalone.engineOptions.maxParameters = static_cast<uint>(value);

  1087.         break;

  1088. 

  1089.     case CB::ENGINE_OPTION_UI_BRIDGES_TIMEOUT:

  1090.         CARLA_SAFE_ASSERT_RETURN(value >= 0,);

  1091.         gStandalone.engineOptions.uiBridgesTimeout = static_cast<uint>(value);

  1092.         break;

  1093. 

  1094.     case CB::ENGINE_OPTION_AUDIO_NUM_PERIODS:

  1095.         CARLA_SAFE_ASSERT_RETURN(value >= 2 && value <= 3,);

  1096.         gStandalone.engineOptions.audioNumPeriods = static_cast<uint>(value);

  1097.         break;

  1098. 

  1099.     case CB::ENGINE_OPTION_AUDIO_BUFFER_SIZE:

  1100.         CARLA_SAFE_ASSERT_RETURN(value >= 8,);

  1101.         gStandalone.engineOptions.audioBufferSize = static_cast<uint>(value);

  1102.         break;

  1103. 

  1104.     case CB::ENGINE_OPTION_AUDIO_SAMPLE_RATE:

  1105.         CARLA_SAFE_ASSERT_RETURN(value >= 22050,);

  1106.         gStandalone.engineOptions.audioSampleRate = static_cast<uint>(value);

  1107.         break;

  1108. 

  1109.     case CB::ENGINE_OPTION_AUDIO_DEVICE:

  1110.         CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  1111. 

  1112.         if (gStandalone.engineOptions.audioDevice != nullptr)

  1113.             delete[] gStandalone.engineOptions.audioDevice;

  1114. 

  1115.         gStandalone.engineOptions.audioDevice = carla_strdup_safe(valueStr);

  1116.         break;

  1117. 

  1118.     case CB::ENGINE_OPTION_PLUGIN_PATH:

  1119.         CARLA_SAFE_ASSERT_RETURN(value > CB::PLUGIN_NONE,);

  1120.         CARLA_SAFE_ASSERT_RETURN(value <= CB::PLUGIN_SFZ,);

  1121.         CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  1122. 

  1123.         switch (value)

  1124.         {

  1125.         case CB::PLUGIN_LADSPA:

  1126.             if (gStandalone.engineOptions.pathLADSPA != nullptr)

  1127.                 delete[] gStandalone.engineOptions.pathLADSPA;

  1128.             gStandalone.engineOptions.pathLADSPA = carla_strdup_safe(valueStr);

  1129.             break;

  1130.         case CB::PLUGIN_DSSI:

  1131.             if (gStandalone.engineOptions.pathDSSI != nullptr)

  1132.                 delete[] gStandalone.engineOptions.pathDSSI;

  1133.             gStandalone.engineOptions.pathDSSI = carla_strdup_safe(valueStr);

  1134.             break;

  1135.         case CB::PLUGIN_LV2:

  1136.             if (gStandalone.engineOptions.pathLV2 != nullptr)

  1137.                 delete[] gStandalone.engineOptions.pathLV2;

  1138.             gStandalone.engineOptions.pathLV2 = carla_strdup_safe(valueStr);

  1139.             break;

  1140.         case CB::PLUGIN_VST2:

  1141.             if (gStandalone.engineOptions.pathVST2 != nullptr)

  1142.                 delete[] gStandalone.engineOptions.pathVST2;

  1143.             gStandalone.engineOptions.pathVST2 = carla_strdup_safe(valueStr);

  1144.             break;

  1145.         case CB::PLUGIN_VST3:

  1146.             if (gStandalone.engineOptions.pathVST3 != nullptr)

  1147.                 delete[] gStandalone.engineOptions.pathVST3;

  1148.             gStandalone.engineOptions.pathVST3 = carla_strdup_safe(valueStr);

  1149.             break;

  1150.         case CB::PLUGIN_AU:

  1151.             if (gStandalone.engineOptions.pathAU != nullptr)

  1152.                 delete[] gStandalone.engineOptions.pathAU;

  1153.             gStandalone.engineOptions.pathAU = carla_strdup_safe(valueStr);

  1154.             break;

  1155.         case CB::PLUGIN_GIG:

  1156.             if (gStandalone.engineOptions.pathGIG != nullptr)

  1157.                 delete[] gStandalone.engineOptions.pathGIG;

  1158.             gStandalone.engineOptions.pathGIG = carla_strdup_safe(valueStr);

  1159.             break;

  1160.         case CB::PLUGIN_SF2:

  1161.             if (gStandalone.engineOptions.pathSF2 != nullptr)

  1162.                 delete[] gStandalone.engineOptions.pathSF2;

  1163.             gStandalone.engineOptions.pathSF2 = carla_strdup_safe(valueStr);

  1164.             break;

  1165.         case CB::PLUGIN_SFZ:

  1166.             if (gStandalone.engineOptions.pathSFZ != nullptr)

  1167.                 delete[] gStandalone.engineOptions.pathSFZ;

  1168.             gStandalone.engineOptions.pathSFZ = carla_strdup_safe(valueStr);

  1169.             break;

  1170.         }

  1171.         break;

  1172. 

  1173.     case CB::ENGINE_OPTION_PATH_BINARIES:

  1174.         CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr && valueStr[0] != '\0',);

  1175. 

  1176.         if (gStandalone.engineOptions.binaryDir != nullptr)

  1177.             delete[] gStandalone.engineOptions.binaryDir;

  1178. 

  1179.         gStandalone.engineOptions.binaryDir = carla_strdup_safe(valueStr);

  1180.         break;

  1181. 

  1182.     case CB::ENGINE_OPTION_PATH_RESOURCES:

  1183.         CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr && valueStr[0] != '\0',);

  1184. 

  1185.         if (gStandalone.engineOptions.resourceDir != nullptr)

  1186.             delete[] gStandalone.engineOptions.resourceDir;

  1187. 

  1188.         gStandalone.engineOptions.resourceDir = carla_strdup_safe(valueStr);

  1189.         break;

  1190. 

  1191.     case CB::ENGINE_OPTION_PREVENT_BAD_BEHAVIOUR:

  1192.         CARLA_SAFE_ASSERT_RETURN(value == 0 || value == 1,);

  1193.         gStandalone.engineOptions.preventBadBehaviour = (value != 0);

  1194.         break;

  1195. 

  1196.     case CB::ENGINE_OPTION_FRONTEND_WIN_ID:

  1197.         CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr && valueStr[0] != '\0',);

  1198.         const long long winId(std::strtoll(valueStr, nullptr, 16));

  1199.         CARLA_SAFE_ASSERT_RETURN(winId >= 0,);

  1200.         gStandalone.engineOptions.frontendWinId = static_cast<uintptr_t>(winId);

  1201.         break;

  1202.     }

  1203. 

  1204.     if (gStandalone.engine != nullptr)

  1205.         gStandalone.engine->setOption(option, value, valueStr);

  1206. }

  1207. #endif

  1208. 

  1209. void carla_set_file_callback(FileCallbackFunc func, void* ptr)

  1210. {

  1211.     carla_debug("carla_set_file_callback(%p, %p)", func, ptr);

  1212. 

  1213.     gStandalone.fileCallback    = func;

  1214.     gStandalone.fileCallbackPtr = ptr;

  1215. 

  1216.     if (gStandalone.engine != nullptr)

  1217.         gStandalone.engine->setFileCallback(func, ptr);

  1218. }

  1219. 

  1220. // -------------------------------------------------------------------------------------------------------------------

  1221. 

  1222. bool carla_load_file(const char* filename)

  1223. {

  1224.     CARLA_SAFE_ASSERT_RETURN(filename != nullptr && filename[0] != '\0', false);

  1225.     carla_debug("carla_load_file(\"%s\")", filename);

  1226. 

  1227.     if (gStandalone.engine != nullptr)

  1228.         return gStandalone.engine->loadFile(filename);

  1229. 

  1230.     carla_stderr2("Engine is not running");

  1231.     gStandalone.lastError = "Engine is not running";

  1232.     return false;

  1233. }

  1234. 

  1235. bool carla_load_project(const char* filename)

  1236. {

  1237.     CARLA_SAFE_ASSERT_RETURN(filename != nullptr && filename[0] != '\0', false);

  1238.     carla_debug("carla_load_project(\"%s\")", filename);

  1239. 

  1240.     if (gStandalone.engine != nullptr)

  1241.         return gStandalone.engine->loadProject(filename);

  1242. 

  1243.     carla_stderr2("Engine is not running");

  1244.     gStandalone.lastError = "Engine is not running";

  1245.     return false;

  1246. }

  1247. 

  1248. bool carla_save_project(const char* filename)

  1249. {

  1250.     CARLA_SAFE_ASSERT_RETURN(filename != nullptr && filename[0] != '\0', false);

  1251.     carla_debug("carla_save_project(\"%s\")", filename);

  1252. 

  1253.     if (gStandalone.engine != nullptr)

  1254.         return gStandalone.engine->saveProject(filename);

  1255. 

  1256.     carla_stderr2("Engine was never initiated");

  1257.     gStandalone.lastError = "Engine was never initiated";

  1258.     return false;

  1259. }

  1260. 

  1261. #ifndef BUILD_BRIDGE

  1262. // -------------------------------------------------------------------------------------------------------------------

  1263. 

  1264. bool carla_patchbay_connect(uint groupIdA, uint portIdA, uint groupIdB, uint portIdB)

  1265. {

  1266.     carla_debug("carla_patchbay_connect(%u, %u, %u, %u)", groupIdA, portIdA, groupIdB, portIdB);

  1267. 

  1268.     if (gStandalone.engine != nullptr)

  1269.         return gStandalone.engine->patchbayConnect(groupIdA, portIdA, groupIdB, portIdB);

  1270. 

  1271.     carla_stderr2("Engine is not running");

  1272.     gStandalone.lastError = "Engine is not running";

  1273.     return false;

  1274. }

  1275. 

  1276. bool carla_patchbay_disconnect(uint connectionId)

  1277. {

  1278.     carla_debug("carla_patchbay_disconnect(%i)", connectionId);

  1279. 

  1280.     if (gStandalone.engine != nullptr)

  1281.         return gStandalone.engine->patchbayDisconnect(connectionId);

  1282. 

  1283.     carla_stderr2("Engine is not running");

  1284.     gStandalone.lastError = "Engine is not running";

  1285.     return false;

  1286. }

  1287. 

  1288. bool carla_patchbay_refresh(bool external)

  1289. {

  1290.     carla_debug("carla_patchbay_refresh(%s)", bool2str(external));

  1291. 

  1292.     if (gStandalone.engine != nullptr)

  1293.         return gStandalone.engine->patchbayRefresh(external);

  1294. 

  1295.     carla_stderr2("Engine is not running");

  1296.     gStandalone.lastError = "Engine is not running";

  1297.     return false;

  1298. }

  1299. 

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

  1301. 

  1302. void carla_transport_play()

  1303. {

  1304.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr && gStandalone.engine->isRunning(),);

  1305.     carla_debug("carla_transport_play()");

  1306. 

  1307.     gStandalone.engine->transportPlay();

  1308. }

  1309. 

  1310. void carla_transport_pause()

  1311. {

  1312.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr && gStandalone.engine->isRunning(),);

  1313.     carla_debug("carla_transport_pause()");

  1314. 

  1315.     gStandalone.engine->transportPause();

  1316. }

  1317. 

  1318. void carla_transport_relocate(uint64_t frame)

  1319. {

  1320.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr && gStandalone.engine->isRunning(),);

  1321.     carla_debug("carla_transport_relocate(%i)", frame);

  1322. 

  1323.     gStandalone.engine->transportRelocate(frame);

  1324. }

  1325. 

  1326. uint64_t carla_get_current_transport_frame()

  1327. {

  1328.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr && gStandalone.engine->isRunning(), 0);

  1329. 

  1330.     const CB::EngineTimeInfo& timeInfo(gStandalone.engine->getTimeInfo());

  1331.     return timeInfo.frame;

  1332. }

  1333. 

  1334. const CarlaTransportInfo* carla_get_transport_info()

  1335. {

  1336.     static CarlaTransportInfo retInfo;

  1337. 

  1338.     // reset

  1339.     retInfo.playing = false;

  1340.     retInfo.frame   = 0;

  1341.     retInfo.bar     = 0;

  1342.     retInfo.beat    = 0;

  1343.     retInfo.tick    = 0;

  1344.     retInfo.bpm     = 0.0;

  1345. 

  1346.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr && gStandalone.engine->isRunning(), &retInfo);

  1347. 

  1348.     const CB::EngineTimeInfo& timeInfo(gStandalone.engine->getTimeInfo());

  1349. 

  1350.     retInfo.playing = timeInfo.playing;

  1351.     retInfo.frame   = timeInfo.frame;

  1352. 

  1353.     if (timeInfo.valid & CB::EngineTimeInfo::kValidBBT)

  1354.     {

  1355.         retInfo.bar  = timeInfo.bbt.bar;

  1356.         retInfo.beat = timeInfo.bbt.beat;

  1357.         retInfo.tick = timeInfo.bbt.tick;

  1358.         retInfo.bpm  = timeInfo.bbt.beatsPerMinute;

  1359.     }

  1360. 

  1361.     return &retInfo;

  1362. }

  1363. #endif

  1364. 

  1365. // -------------------------------------------------------------------------------------------------------------------

  1366. 

  1367. uint32_t carla_get_current_plugin_count()

  1368. {

  1369.     if (gStandalone.engine != nullptr)

  1370.         return gStandalone.engine->getCurrentPluginCount();

  1371. 

  1372.     return 0;

  1373. }

  1374. 

  1375. uint32_t carla_get_max_plugin_number()

  1376. {

  1377.     if (gStandalone.engine != nullptr)

  1378.         return gStandalone.engine->getMaxPluginNumber();

  1379. 

  1380.     return 0;

  1381. }

  1382. 

  1383. // -------------------------------------------------------------------------------------------------------------------

  1384. 

  1385. bool carla_add_plugin(BinaryType btype, PluginType ptype, const char* filename, const char* name, const char* label, int64_t uniqueId, const void* extraPtr, uint options)

  1386. {

  1387.     carla_debug("carla_add_plugin(%i:%s, %i:%s, \"%s\", \"%s\", \"%s\", " P_INT64 ", %p, %u)", btype, CB::BinaryType2Str(btype), ptype, CB::PluginType2Str(ptype), filename, name, label, uniqueId, extraPtr, options);

  1388. 

  1389.     if (gStandalone.engine != nullptr)

  1390.         return gStandalone.engine->addPlugin(btype, ptype, filename, name, label, uniqueId, extraPtr, options);

  1391. 

  1392.     carla_stderr2("Engine is not running");

  1393.     gStandalone.lastError = "Engine is not running";

  1394.     return false;

  1395. }

  1396. 

  1397. bool carla_remove_plugin(uint pluginId)

  1398. {

  1399.     carla_debug("carla_remove_plugin(%i)", pluginId);

  1400. 

  1401.     if (gStandalone.engine != nullptr)

  1402.         return gStandalone.engine->removePlugin(pluginId);

  1403. 

  1404.     carla_stderr2("Engine is not running");

  1405.     gStandalone.lastError = "Engine is not running";

  1406.     return false;

  1407. }

  1408. 

  1409. bool carla_remove_all_plugins()

  1410. {

  1411.     carla_debug("carla_remove_all_plugins()");

  1412. 

  1413.     if (gStandalone.engine != nullptr)

  1414.         return gStandalone.engine->removeAllPlugins();

  1415. 

  1416.     carla_stderr2("Engine is not running");

  1417.     gStandalone.lastError = "Engine is not running";

  1418.     return false;

  1419. }

  1420. 

  1421. #ifndef BUILD_BRIDGE

  1422. const char* carla_rename_plugin(uint pluginId, const char* newName)

  1423. {

  1424.     CARLA_SAFE_ASSERT_RETURN(newName != nullptr && newName[0] != '\0', nullptr);

  1425.     carla_debug("carla_rename_plugin(%i, \"%s\")", pluginId, newName);

  1426. 

  1427.     if (gStandalone.engine != nullptr)

  1428.         return gStandalone.engine->renamePlugin(pluginId, newName);

  1429. 

  1430.     carla_stderr2("Engine is not running");

  1431.     gStandalone.lastError = "Engine is not running";

  1432.     return nullptr;

  1433. }

  1434. 

  1435. bool carla_clone_plugin(uint pluginId)

  1436. {

  1437.     carla_debug("carla_clone_plugin(%i)", pluginId);

  1438. 

  1439.     if (gStandalone.engine != nullptr)

  1440.         return gStandalone.engine->clonePlugin(pluginId);

  1441. 

  1442.     carla_stderr2("Engine is not running");

  1443.     gStandalone.lastError = "Engine is not running";

  1444.     return false;

  1445. }

  1446. 

  1447. bool carla_replace_plugin(uint pluginId)

  1448. {

  1449.     carla_debug("carla_replace_plugin(%i)", pluginId);

  1450. 

  1451.     if (gStandalone.engine != nullptr)

  1452.         return gStandalone.engine->replacePlugin(pluginId);

  1453. 

  1454.     carla_stderr2("Engine is not running");

  1455.     gStandalone.lastError = "Engine is not running";

  1456.     return false;

  1457. }

  1458. 

  1459. bool carla_switch_plugins(uint pluginIdA, uint pluginIdB)

  1460. {

  1461.     CARLA_SAFE_ASSERT_RETURN(pluginIdA != pluginIdB, false);

  1462.     carla_debug("carla_switch_plugins(%i, %i)", pluginIdA, pluginIdB);

  1463. 

  1464.     if (gStandalone.engine != nullptr)

  1465.         return gStandalone.engine->switchPlugins(pluginIdA, pluginIdB);

  1466. 

  1467.     carla_stderr2("Engine is not running");

  1468.     gStandalone.lastError = "Engine is not running";

  1469.     return false;

  1470. }

  1471. #endif

  1472. 

  1473. // -------------------------------------------------------------------------------------------------------------------

  1474. 

  1475. bool carla_load_plugin_state(uint pluginId, const char* filename)

  1476. {

  1477.     CARLA_SAFE_ASSERT_RETURN(filename != nullptr && filename[0] != '\0', false);

  1478.     carla_debug("carla_load_plugin_state(%i, \"%s\")", pluginId, filename);

  1479. 

  1480.     if (gStandalone.engine == nullptr || ! gStandalone.engine->isRunning())

  1481.     {

  1482.         carla_stderr2("Engine is not running");

  1483.         gStandalone.lastError = "Engine is not running";

  1484.         return false;

  1485.     }

  1486. 

  1487.     if (CarlaPlugin* const plugin = gStandalone.engine->getPlugin(pluginId))

  1488.         return plugin->loadStateFromFile(filename);

  1489. 

  1490.     carla_stderr2("carla_load_plugin_state(%i, \"%s\") - could not find plugin", pluginId, filename);

  1491.     return false;

  1492. }

  1493. 

  1494. bool carla_save_plugin_state(uint pluginId, const char* filename)

  1495. {

  1496.     CARLA_SAFE_ASSERT_RETURN(filename != nullptr && filename[0] != '\0', false);

  1497.     carla_debug("carla_save_plugin_state(%i, \"%s\")", pluginId, filename);

  1498. 

  1499.     if (gStandalone.engine == nullptr)

  1500.     {

  1501.         carla_stderr2("Engine is not running");

  1502.         gStandalone.lastError = "Engine is not running";

  1503.         return false;

  1504.     }

  1505. 

  1506.     // allow to save even if engine isn't running

  1507. 

  1508.     if (CarlaPlugin* const plugin = gStandalone.engine->getPlugin(pluginId))

  1509.         return plugin->saveStateToFile(filename);

  1510. 

  1511.     carla_stderr2("carla_save_plugin_state(%i, \"%s\") - could not find plugin", pluginId, filename);

  1512.     return false;

  1513. }

  1514. 

  1515. // -------------------------------------------------------------------------------------------------------------------

  1516. 

  1517. const CarlaPluginInfo* carla_get_plugin_info(uint pluginId)

  1518. {

  1519.     carla_debug("carla_get_plugin_info(%i)", pluginId);

  1520. 

  1521.     static CarlaPluginInfo info;

  1522. 

  1523.     // reset

  1524.     info.type             = CB::PLUGIN_NONE;

  1525.     info.category         = CB::PLUGIN_CATEGORY_NONE;

  1526.     info.hints            = 0x0;

  1527.     info.optionsAvailable = 0x0;

  1528.     info.optionsEnabled   = 0x0;

  1529.     info.filename         = gNullCharPtr;

  1530.     info.name             = gNullCharPtr;

  1531.     info.iconName         = gNullCharPtr;

  1532.     info.uniqueId         = 0;

  1533. 

  1534.     // cleanup

  1535.     if (info.label != gNullCharPtr)

  1536.     {

  1537.         delete[] info.label;

  1538.         info.label = gNullCharPtr;

  1539.     }

  1540. 

  1541.     if (info.maker != gNullCharPtr)

  1542.     {

  1543.         delete[] info.maker;

  1544.         info.maker = gNullCharPtr;

  1545.     }

  1546. 

  1547.     if (info.copyright != gNullCharPtr)

  1548.     {

  1549.         delete[] info.copyright;

  1550.         info.copyright = gNullCharPtr;

  1551.     }

  1552. 

  1553.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, &info);

  1554. 

  1555.     if (CarlaPlugin* const plugin = gStandalone.engine->getPlugin(pluginId))

  1556.     {

  1557.         char strBufLabel[STR_MAX+1];

  1558.         char strBufMaker[STR_MAX+1];

  1559.         char strBufCopyright[STR_MAX+1];

  1560. 

  1561.         carla_zeroChar(strBufLabel, STR_MAX+1);

  1562.         carla_zeroChar(strBufMaker, STR_MAX+1);

  1563.         carla_zeroChar(strBufCopyright, STR_MAX+1);

  1564. 

  1565.         info.type     = plugin->getType();

  1566.         info.category = plugin->getCategory();

  1567.         info.hints    = plugin->getHints();

  1568.         info.filename = plugin->getFilename();

  1569.         info.name     = plugin->getName();

  1570.         info.iconName = plugin->getIconName();

  1571.         info.uniqueId = plugin->getUniqueId();

  1572. 

  1573.         info.optionsAvailable = plugin->getOptionsAvailable();

  1574.         info.optionsEnabled   = plugin->getOptionsEnabled();

  1575. 

  1576.         plugin->getLabel(strBufLabel);

  1577.         info.label = carla_strdup_safe(strBufLabel);

  1578. 

  1579.         plugin->getMaker(strBufMaker);

  1580.         info.maker = carla_strdup_safe(strBufMaker);

  1581. 

  1582.         plugin->getCopyright(strBufCopyright);

  1583.         info.copyright = carla_strdup_safe(strBufCopyright);

  1584. 

  1585.         checkStringPtr(info.filename);

  1586.         checkStringPtr(info.name);

  1587.         checkStringPtr(info.iconName);

  1588.         checkStringPtr(info.label);

  1589.         checkStringPtr(info.maker);

  1590.         checkStringPtr(info.copyright);

  1591. 

  1592.         return &info;

  1593.     }

  1594. 

  1595.     carla_stderr2("carla_get_plugin_info(%i) - could not find plugin", pluginId);

  1596.     return &info;

  1597. }

  1598. 

  1599. const CarlaPortCountInfo* carla_get_audio_port_count_info(uint pluginId)

  1600. {

  1601.     carla_debug("carla_get_audio_port_count_info(%i)", pluginId);

  1602. 

  1603.     static CarlaPortCountInfo info;

  1604. 

  1605.     // reset

  1606.     info.ins   = 0;

  1607.     info.outs  = 0;

  1608. 

  1609.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, &info);

  1610. 

  1611.     if (CarlaPlugin* const plugin = gStandalone.engine->getPlugin(pluginId))

  1612.     {

  1613.         info.ins   = plugin->getAudioInCount();

  1614.         info.outs  = plugin->getAudioOutCount();

  1615.         return &info;

  1616.     }

  1617. 

  1618.     carla_stderr2("carla_get_audio_port_count_info(%i) - could not find plugin", pluginId);

  1619.     return &info;

  1620. }

  1621. 

  1622. const CarlaPortCountInfo* carla_get_midi_port_count_info(uint pluginId)

  1623. {

  1624.     carla_debug("carla_get_midi_port_count_info(%i)", pluginId);

  1625. 

  1626.     static CarlaPortCountInfo info;

  1627. 

  1628.     // reset

  1629.     info.ins   = 0;

  1630.     info.outs  = 0;

  1631. 

  1632.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, &info);

  1633. 

  1634.     if (CarlaPlugin* const plugin = gStandalone.engine->getPlugin(pluginId))

  1635.     {

  1636.         info.ins   = plugin->getMidiInCount();

  1637.         info.outs  = plugin->getMidiOutCount();

  1638.         return &info;

  1639.     }

  1640. 

  1641.     carla_stderr2("carla_get_midi_port_count_info(%i) - could not find plugin", pluginId);

  1642.     return &info;

  1643. }

  1644. 

  1645. const CarlaPortCountInfo* carla_get_parameter_count_info(uint pluginId)

  1646. {

  1647.     carla_debug("carla_get_parameter_count_info(%i)", pluginId);

  1648. 

  1649.     static CarlaPortCountInfo info;

  1650. 

  1651.     // reset

  1652.     info.ins   = 0;

  1653.     info.outs  = 0;

  1654. 

  1655.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, &info);

  1656. 

  1657.     if (CarlaPlugin* const plugin = gStandalone.engine->getPlugin(pluginId))

  1658.     {

  1659.         plugin->getParameterCountInfo(info.ins, info.outs);

  1660.         return &info;

  1661.     }

  1662. 

  1663.     carla_stderr2("carla_get_parameter_count_info(%i) - could not find plugin", pluginId);

  1664.     return &info;

  1665. }

  1666. 

  1667. const CarlaParameterInfo* carla_get_parameter_info(uint pluginId, uint32_t parameterId)

  1668. {

  1669.     carla_debug("carla_get_parameter_info(%i, %i)", pluginId, parameterId);

  1670. 

  1671.     static CarlaParameterInfo info;

  1672. 

  1673.     // reset

  1674.     info.scalePointCount = 0;

  1675. 

  1676.     // cleanup

  1677.     if (info.name != gNullCharPtr)

  1678.     {

  1679.         delete[] info.name;

  1680.         info.name = gNullCharPtr;

  1681.     }

  1682. 

  1683.     if (info.symbol != gNullCharPtr)

  1684.     {

  1685.         delete[] info.symbol;

  1686.         info.symbol = gNullCharPtr;

  1687.     }

  1688. 

  1689.     if (info.unit != gNullCharPtr)

  1690.     {

  1691.         delete[] info.unit;

  1692.         info.unit = gNullCharPtr;

  1693.     }

  1694. 

  1695.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, &info);

  1696. 

  1697.     if (CarlaPlugin* const plugin = gStandalone.engine->getPlugin(pluginId))

  1698.     {

  1699.         if (parameterId < plugin->getParameterCount())

  1700.         {

  1701.             char strBufName[STR_MAX+1];

  1702.             char strBufSymbol[STR_MAX+1];

  1703.             char strBufUnit[STR_MAX+1];

  1704. 

  1705.             carla_zeroChar(strBufName, STR_MAX+1);

  1706.             carla_zeroChar(strBufSymbol, STR_MAX+1);

  1707.             carla_zeroChar(strBufUnit, STR_MAX+1);

  1708. 

  1709.             info.scalePointCount = plugin->getParameterScalePointCount(parameterId);

  1710. 

  1711.             plugin->getParameterName(parameterId, strBufName);

  1712.             info.name = carla_strdup_safe(strBufName);

  1713. 

  1714.             plugin->getParameterSymbol(parameterId, strBufSymbol);

  1715.             info.symbol = carla_strdup_safe(strBufSymbol);

  1716. 

  1717.             plugin->getParameterUnit(parameterId, strBufUnit);

  1718.             info.unit = carla_strdup_safe(strBufUnit);

  1719. 

  1720.             checkStringPtr(info.name);

  1721.             checkStringPtr(info.symbol);

  1722.             checkStringPtr(info.unit);

  1723.         }

  1724.         else

  1725.             carla_stderr2("carla_get_parameter_info(%i, %i) - parameterId out of bounds", pluginId, parameterId);

  1726. 

  1727.         return &info;

  1728.     }

  1729. 

  1730.     carla_stderr2("carla_get_parameter_info(%i, %i) - could not find plugin", pluginId, parameterId);

  1731.     return &info;

  1732. }

  1733. 

  1734. const CarlaScalePointInfo* carla_get_parameter_scalepoint_info(uint pluginId, uint32_t parameterId, uint32_t scalePointId)

  1735. {

  1736.     carla_debug("carla_get_parameter_scalepoint_info(%i, %i, %i)", pluginId, parameterId, scalePointId);

  1737.     CARLA_ASSERT(gStandalone.engine != nullptr);

  1738. 

  1739.     static CarlaScalePointInfo info;

  1740. 

  1741.     // reset

  1742.     info.value = 0.0f;

  1743. 

  1744.     // cleanup

  1745.     if (info.label != gNullCharPtr)

  1746.     {

  1747.         delete[] info.label;

  1748.         info.label = gNullCharPtr;

  1749.     }

  1750. 

  1751.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, &info);

  1752. 

  1753.     if (CarlaPlugin* const plugin = gStandalone.engine->getPlugin(pluginId))

  1754.     {

  1755.         if (parameterId < plugin->getParameterCount())

  1756.         {

  1757.             if (scalePointId < plugin->getParameterScalePointCount(parameterId))

  1758.             {

  1759.                 char strBufLabel[STR_MAX+1];

  1760.                 carla_zeroChar(strBufLabel, STR_MAX+1);

  1761. 

  1762.                 info.value = plugin->getParameterScalePointValue(parameterId, scalePointId);

  1763. 

  1764.                 plugin->getParameterScalePointLabel(parameterId, scalePointId, strBufLabel);

  1765.                 info.label = carla_strdup_safe(strBufLabel);

  1766.                 checkStringPtr(info.label);

  1767.             }

  1768.             else

  1769.                 carla_stderr2("carla_get_parameter_scalepoint_info(%i, %i, %i) - scalePointId out of bounds", pluginId, parameterId, scalePointId);

  1770.         }

  1771.         else

  1772.             carla_stderr2("carla_get_parameter_scalepoint_info(%i, %i, %i) - parameterId out of bounds", pluginId, parameterId, scalePointId);

  1773. 

  1774.         return &info;

  1775.     }

  1776. 

  1777.     carla_stderr2("carla_get_parameter_scalepoint_info(%i, %i, %i) - could not find plugin", pluginId, parameterId, scalePointId);

  1778.     return &info;

  1779. }

  1780. 

  1781. // -------------------------------------------------------------------------------------------------------------------

  1782. 

  1783. const ParameterData* carla_get_parameter_data(uint pluginId, uint32_t parameterId)

  1784. {

  1785.     carla_debug("carla_get_parameter_data(%i, %i)", pluginId, parameterId);

  1786. 

  1787.     static const ParameterData fallbackParameterData = { CB::PARAMETER_UNKNOWN, 0x0, CB::PARAMETER_NULL, -1, -1, 0 };

  1788. 

  1789.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, &fallbackParameterData);

  1790. 

  1791.     if (CarlaPlugin* const plugin = gStandalone.engine->getPlugin(pluginId))

  1792.     {

  1793.         if (parameterId < plugin->getParameterCount())

  1794.             return &plugin->getParameterData(parameterId);

  1795. 

  1796.         carla_stderr2("carla_get_parameter_data(%i, %i) - parameterId out of bounds", pluginId, parameterId);

  1797.         return &fallbackParameterData;

  1798.     }

  1799. 

  1800.     carla_stderr2("carla_get_parameter_data(%i, %i) - could not find plugin", pluginId, parameterId);

  1801.     return &fallbackParameterData;

  1802. }

  1803. 

  1804. const ParameterRanges* carla_get_parameter_ranges(uint pluginId, uint32_t parameterId)

  1805. {

  1806.     carla_debug("carla_get_parameter_ranges(%i, %i)", pluginId, parameterId);

  1807. 

  1808.     static const ParameterRanges fallbackParamRanges = { 0.0f, 0.0f, 1.0f, 0.01f, 0.0001f, 0.1f };

  1809. 

  1810.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, &fallbackParamRanges);

  1811. 

  1812.     if (CarlaPlugin* const plugin = gStandalone.engine->getPlugin(pluginId))

  1813.     {

  1814.         if (parameterId < plugin->getParameterCount())

  1815.             return &plugin->getParameterRanges(parameterId);

  1816. 

  1817.         carla_stderr2("carla_get_parameter_ranges(%i, %i) - parameterId out of bounds", pluginId, parameterId);

  1818.         return &fallbackParamRanges;

  1819.     }

  1820. 

  1821.     carla_stderr2("carla_get_parameter_ranges(%i, %i) - could not find plugin", pluginId, parameterId);

  1822.     return &fallbackParamRanges;

  1823. }

  1824. 

  1825. const MidiProgramData* carla_get_midi_program_data(uint pluginId, uint32_t midiProgramId)

  1826. {

  1827.     carla_debug("carla_get_midi_program_data(%i, %i)", pluginId, midiProgramId);

  1828. 

  1829.     static MidiProgramData midiProgData;

  1830. 

  1831.     // reset

  1832.     midiProgData.bank    = 0;

  1833.     midiProgData.program = 0;

  1834.     midiProgData.name    = gNullCharPtr;

  1835. 

  1836.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, &midiProgData);

  1837. 

  1838.     if (CarlaPlugin* const plugin = gStandalone.engine->getPlugin(pluginId))

  1839.     {

  1840.         if (midiProgramId < plugin->getMidiProgramCount())

  1841.         {

  1842.             const MidiProgramData& ret(plugin->getMidiProgramData(midiProgramId));

  1843.             carla_copyStruct<MidiProgramData>(midiProgData, ret);

  1844.             checkStringPtr(midiProgData.name);

  1845.             return &midiProgData;

  1846.         }

  1847. 

  1848.         carla_stderr2("carla_get_midi_program_data(%i, %i) - midiProgramId out of bounds", pluginId, midiProgramId);

  1849.         return &midiProgData;

  1850.     }

  1851. 

  1852.     carla_stderr2("carla_get_midi_program_data(%i, %i) - could not find plugin", pluginId, midiProgramId);

  1853.     return &midiProgData;

  1854. }

  1855. 

  1856. const CustomData* carla_get_custom_data(uint pluginId, uint32_t customDataId)

  1857. {

  1858.     carla_debug("carla_get_custom_data(%i, %i)", pluginId, customDataId);

  1859. 

  1860.     static CustomData customData;

  1861. 

  1862.     // reset

  1863.     customData.type  = gNullCharPtr;

  1864.     customData.key   = gNullCharPtr;

  1865.     customData.value = gNullCharPtr;

  1866. 

  1867.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, &customData);

  1868. 

  1869.     if (CarlaPlugin* const plugin = gStandalone.engine->getPlugin(pluginId))

  1870.     {

  1871.         if (customDataId < plugin->getCustomDataCount())

  1872.         {

  1873.             const CustomData& ret(plugin->getCustomData(customDataId));

  1874.             carla_copyStruct<CustomData>(customData, ret);

  1875.             checkStringPtr(customData.type);

  1876.             checkStringPtr(customData.key);

  1877.             checkStringPtr(customData.value);

  1878.             return &customData;

  1879.         }

  1880. 

  1881.         carla_stderr2("carla_get_custom_data(%i, %i) - customDataId out of bounds", pluginId, customDataId);

  1882.         return &customData;

  1883.     }

  1884. 

  1885.     carla_stderr2("carla_get_custom_data(%i, %i) - could not find plugin", pluginId, customDataId);

  1886.     return &customData;

  1887. }

  1888. 

  1889. const char* carla_get_chunk_data(uint pluginId)

  1890. {

  1891.     carla_debug("carla_get_chunk_data(%i)", pluginId);

  1892. 

  1893.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, nullptr);

  1894. 

  1895.     static CarlaString chunkData;

  1896. 

  1897.     // cleanup

  1898.     chunkData.clear();

  1899. 

  1900.     if (CarlaPlugin* const plugin = gStandalone.engine->getPlugin(pluginId))

  1901.     {

  1902.         if (plugin->getOptionsEnabled() & CB::PLUGIN_OPTION_USE_CHUNKS)

  1903.         {

  1904.             void* data = nullptr;

  1905.             const std::size_t dataSize(plugin->getChunkData(&data));

  1906. 

  1907.             if (data != nullptr && dataSize > 0)

  1908.             {

  1909.                 chunkData = CarlaString::asBase64(data, static_cast<std::size_t>(dataSize));

  1910.                 return chunkData;

  1911.             }

  1912.             else

  1913.                 carla_stderr2("carla_get_chunk_data(%i) - got invalid chunk data", pluginId);

  1914.         }

  1915.         else

  1916.             carla_stderr2("carla_get_chunk_data(%i) - plugin does not use chunks", pluginId);

  1917. 

  1918.         return nullptr;

  1919.     }

  1920. 

  1921.     carla_stderr2("carla_get_chunk_data(%i) - could not find plugin", pluginId);

  1922.     return nullptr;

  1923. }

  1924. 

  1925. // -------------------------------------------------------------------------------------------------------------------

  1926. 

  1927. uint32_t carla_get_parameter_count(uint pluginId)

  1928. {

  1929.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, 0);

  1930.     carla_debug("carla_get_parameter_count(%i)", pluginId);

  1931. 

  1932.     if (CarlaPlugin* const plugin = gStandalone.engine->getPlugin(pluginId))

  1933.         return plugin->getParameterCount();

  1934. 

  1935.     carla_stderr2("carla_get_parameter_count(%i) - could not find plugin", pluginId);

  1936.     return 0;

  1937. }

  1938. 

  1939. uint32_t carla_get_program_count(uint pluginId)

  1940. {

  1941.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, 0);

  1942.     carla_debug("carla_get_program_count(%i)", pluginId);

  1943. 

  1944.     if (CarlaPlugin* const plugin = gStandalone.engine->getPlugin(pluginId))

  1945.         return plugin->getProgramCount();

  1946. 

  1947.     carla_stderr2("carla_get_program_count(%i) - could not find plugin", pluginId);

  1948.     return 0;

  1949. }

  1950. 

  1951. uint32_t carla_get_midi_program_count(uint pluginId)

  1952. {

  1953.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, 0);

  1954.     carla_debug("carla_get_midi_program_count(%i)", pluginId);

  1955. 

  1956.     if (CarlaPlugin* const plugin = gStandalone.engine->getPlugin(pluginId))

  1957.         return plugin->getMidiProgramCount();

  1958. 

  1959.     carla_stderr2("carla_get_midi_program_count(%i) - could not find plugin", pluginId);

  1960.     return 0;

  1961. }

  1962. 

  1963. uint32_t carla_get_custom_data_count(uint pluginId)

  1964. {

  1965.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, 0);

  1966.     carla_debug("carla_get_custom_data_count(%i)", pluginId);

  1967. 

  1968.     if (CarlaPlugin* const plugin = gStandalone.engine->getPlugin(pluginId))

  1969.         return plugin->getCustomDataCount();

  1970. 

  1971.     carla_stderr2("carla_get_custom_data_count(%i) - could not find plugin", pluginId);

  1972.     return 0;

  1973. }

  1974. 

  1975. // -------------------------------------------------------------------------------------------------------------------

  1976. 

  1977. const char* carla_get_parameter_text(uint pluginId, uint32_t parameterId)

  1978. {

  1979.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, nullptr);

  1980.     carla_debug("carla_get_parameter_text(%i, %i)", pluginId, parameterId);

  1981. 

  1982.     static char textBuf[STR_MAX+1];

  1983. 

  1984.     if (CarlaPlugin* const plugin = gStandalone.engine->getPlugin(pluginId))

  1985.     {

  1986.         if (parameterId < plugin->getParameterCount())

  1987.         {

  1988.             carla_zeroChar(textBuf, STR_MAX+1);

  1989.             plugin->getParameterText(parameterId, textBuf);

  1990.             return textBuf;

  1991.         }

  1992. 

  1993.         carla_stderr2("carla_get_parameter_text(%i, %i) - parameterId out of bounds", pluginId, parameterId);

  1994.         return nullptr;

  1995.     }

  1996. 

  1997.     carla_stderr2("carla_get_parameter_text(%i, %i) - could not find plugin", pluginId, parameterId);

  1998.     return nullptr;

  1999. }

  2000. 

  2001. const char* carla_get_program_name(uint pluginId, uint32_t programId)

  2002. {

  2003.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, nullptr);

  2004.     carla_debug("carla_get_program_name(%i, %i)", pluginId, programId);

  2005. 

  2006.     static char programName[STR_MAX+1];

  2007. 

  2008.     if (CarlaPlugin* const plugin = gStandalone.engine->getPlugin(pluginId))

  2009.     {

  2010.         if (programId < plugin->getProgramCount())

  2011.         {

  2012.             carla_zeroChar(programName, STR_MAX+1);

  2013.             plugin->getProgramName(programId, programName);

  2014.             return programName;

  2015.         }

  2016. 

  2017.         carla_stderr2("carla_get_program_name(%i, %i) - programId out of bounds", pluginId, programId);

  2018.         return nullptr;

  2019.     }

  2020. 

  2021.     carla_stderr2("carla_get_program_name(%i, %i) - could not find plugin", pluginId, programId);

  2022.     return nullptr;

  2023. }

  2024. 

  2025. const char* carla_get_midi_program_name(uint pluginId, uint32_t midiProgramId)

  2026. {

  2027.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, nullptr);

  2028.     carla_debug("carla_get_midi_program_name(%i, %i)", pluginId, midiProgramId);

  2029. 

  2030.     static char midiProgramName[STR_MAX+1];

  2031. 

  2032.     if (CarlaPlugin* const plugin = gStandalone.engine->getPlugin(pluginId))

  2033.     {

  2034.         if (midiProgramId < plugin->getMidiProgramCount())

  2035.         {

  2036.             carla_zeroChar(midiProgramName, STR_MAX+1);

  2037.             plugin->getMidiProgramName(midiProgramId, midiProgramName);

  2038.             return midiProgramName;

  2039.         }

  2040. 

  2041.         carla_stderr2("carla_get_midi_program_name(%i, %i) - midiProgramId out of bounds", pluginId, midiProgramId);

  2042.         return nullptr;

  2043.     }

  2044. 

  2045.     carla_stderr2("carla_get_midi_program_name(%i, %i) - could not find plugin", pluginId, midiProgramId);

  2046.     return nullptr;

  2047. }

  2048. 

  2049. const char* carla_get_real_plugin_name(uint pluginId)

  2050. {

  2051.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, nullptr);

  2052.     carla_debug("carla_get_real_plugin_name(%i)", pluginId);

  2053. 

  2054.     static char realPluginName[STR_MAX+1];

  2055. 

  2056.     if (CarlaPlugin* const plugin = gStandalone.engine->getPlugin(pluginId))

  2057.     {

  2058.         carla_zeroChar(realPluginName, STR_MAX+1);

  2059.         plugin->getRealName(realPluginName);

  2060.         return realPluginName;

  2061.     }

  2062. 

  2063.     carla_stderr2("carla_get_real_plugin_name(%i) - could not find plugin", pluginId);

  2064.     return nullptr;

  2065. }

  2066. 

  2067. // -------------------------------------------------------------------------------------------------------------------

  2068. 

  2069. int32_t carla_get_current_program_index(uint pluginId)

  2070. {

  2071.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, -1);

  2072.     carla_debug("carla_get_current_program_index(%i)", pluginId);

  2073. 

  2074.     if (CarlaPlugin* const plugin = gStandalone.engine->getPlugin(pluginId))

  2075.         return plugin->getCurrentProgram();

  2076. 

  2077.     carla_stderr2("carla_get_current_program_index(%i) - could not find plugin", pluginId);

  2078.     return -1;

  2079. }

  2080. 

  2081. int32_t carla_get_current_midi_program_index(uint pluginId)

  2082. {

  2083.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, -1);

  2084.     carla_debug("carla_get_current_midi_program_index(%i)", pluginId);

  2085. 

  2086.     if (CarlaPlugin* const plugin = gStandalone.engine->getPlugin(pluginId))

  2087.         return plugin->getCurrentMidiProgram();

  2088. 

  2089.     carla_stderr2("carla_get_current_midi_program_index(%i) - could not find plugin", pluginId);

  2090.     return -1;

  2091. }

  2092. 

  2093. // -------------------------------------------------------------------------------------------------------------------

  2094. 

  2095. float carla_get_default_parameter_value(uint pluginId, uint32_t parameterId)

  2096. {

  2097.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, 0.0f);

  2098.     carla_debug("carla_get_default_parameter_value(%i, %i)", pluginId, parameterId);

  2099. 

  2100.     if (CarlaPlugin* const plugin = gStandalone.engine->getPlugin(pluginId))

  2101.     {

  2102.         if (parameterId < plugin->getParameterCount())

  2103.             return plugin->getParameterRanges(parameterId).def;

  2104. 

  2105.         carla_stderr2("carla_get_default_parameter_value(%i, %i) - parameterId out of bounds", pluginId, parameterId);

  2106.         return 0.0f;

  2107.     }

  2108. 

  2109.     carla_stderr2("carla_get_default_parameter_value(%i, %i) - could not find plugin", pluginId, parameterId);

  2110.     return 0.0f;

  2111. }

  2112. 

  2113. float carla_get_current_parameter_value(uint pluginId, uint32_t parameterId)

  2114. {

  2115.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, 0.0f);

  2116. 

  2117.     if (CarlaPlugin* const plugin = gStandalone.engine->getPlugin(pluginId))

  2118.     {

  2119.         if (parameterId < plugin->getParameterCount())

  2120.             return plugin->getParameterValue(parameterId);

  2121. 

  2122.         carla_stderr2("carla_get_current_parameter_value(%i, %i) - parameterId out of bounds", pluginId, parameterId);

  2123.         return 0.0f;

  2124.     }

  2125. 

  2126.     carla_stderr2("carla_get_current_parameter_value(%i, %i) - could not find plugin", pluginId, parameterId);

  2127.     return 0.0f;

  2128. }

  2129. 

  2130. float carla_get_internal_parameter_value(uint pluginId, int32_t parameterId)

  2131. {

  2132. #ifdef BUILD_BRIDGE

  2133.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, 0.0f);

  2134. #else

  2135.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, (parameterId == CB::PARAMETER_CTRL_CHANNEL) ? -1.0f : 0.0f);

  2136. #endif

  2137.     CARLA_SAFE_ASSERT_RETURN(parameterId != CB::PARAMETER_NULL && parameterId > CB::PARAMETER_MAX, 0.0f);

  2138. 

  2139.     if (CarlaPlugin* const plugin = gStandalone.engine->getPlugin(pluginId))

  2140.         return plugin->getInternalParameterValue(parameterId);

  2141. 

  2142.     carla_stderr2("carla_get_internal_parameter_value(%i, %i) - could not find plugin", pluginId, parameterId);

  2143.     return 0.0f;

  2144. }

  2145. 

  2146. // -------------------------------------------------------------------------------------------------------------------

  2147. 

  2148. float carla_get_input_peak_value(uint pluginId, bool isLeft)

  2149. {

  2150.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, 0.0f);

  2151. 

  2152.     return gStandalone.engine->getInputPeak(pluginId, isLeft);

  2153. }

  2154. 

  2155. float carla_get_output_peak_value(uint pluginId, bool isLeft)

  2156. {

  2157.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, 0.0f);

  2158. 

  2159.     return gStandalone.engine->getOutputPeak(pluginId, isLeft);

  2160. }

  2161. 

  2162. // -------------------------------------------------------------------------------------------------------------------

  2163. 

  2164. void carla_set_active(uint pluginId, bool onOff)

  2165. {

  2166.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr,);

  2167.     carla_debug("carla_set_active(%i, %s)", pluginId, bool2str(onOff));

  2168. 

  2169.     if (CarlaPlugin* const plugin = gStandalone.engine->getPlugin(pluginId))

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

  2171. 

  2172.     carla_stderr2("carla_set_active(%i, %s) - could not find plugin", pluginId, bool2str(onOff));

  2173. }

  2174. 

  2175. #ifndef BUILD_BRIDGE

  2176. void carla_set_drywet(uint pluginId, float value)

  2177. {

  2178.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr,);

  2179.     carla_debug("carla_set_drywet(%i, %f)", pluginId, value);

  2180. 

  2181.     if (CarlaPlugin* const plugin = gStandalone.engine->getPlugin(pluginId))

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

  2183. 

  2184.     carla_stderr2("carla_set_drywet(%i, %f) - could not find plugin", pluginId, value);

  2185. }

  2186. 

  2187. void carla_set_volume(uint pluginId, float value)

  2188. {

  2189.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr,);

  2190.     carla_debug("carla_set_volume(%i, %f)", pluginId, value);

  2191. 

  2192.     if (CarlaPlugin* const plugin = gStandalone.engine->getPlugin(pluginId))

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

  2194. 

  2195.     carla_stderr2("carla_set_volume(%i, %f) - could not find plugin", pluginId, value);

  2196. }

  2197. 

  2198. void carla_set_balance_left(uint pluginId, float value)

  2199. {

  2200.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr,);

  2201.     carla_debug("carla_set_balance_left(%i, %f)", pluginId, value);

  2202. 

  2203.     if (CarlaPlugin* const plugin = gStandalone.engine->getPlugin(pluginId))

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

  2205. 

  2206.     carla_stderr2("carla_set_balance_left(%i, %f) - could not find plugin", pluginId, value);

  2207. }

  2208. 

  2209. void carla_set_balance_right(uint pluginId, float value)

  2210. {

  2211.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr,);

  2212.     carla_debug("carla_set_balance_right(%i, %f)", pluginId, value);

  2213. 

  2214.     if (CarlaPlugin* const plugin = gStandalone.engine->getPlugin(pluginId))

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

  2216. 

  2217.     carla_stderr2("carla_set_balance_right(%i, %f) - could not find plugin", pluginId, value);

  2218. }

  2219. 

  2220. void carla_set_panning(uint pluginId, float value)

  2221. {

  2222.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr,);

  2223.     carla_debug("carla_set_panning(%i, %f)", pluginId, value);

  2224. 

  2225.     if (CarlaPlugin* const plugin = gStandalone.engine->getPlugin(pluginId))

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

  2227. 

  2228.     carla_stderr2("carla_set_panning(%i, %f) - could not find plugin", pluginId, value);

  2229. }

  2230. 

  2231. void carla_set_ctrl_channel(uint pluginId, int8_t channel)

  2232. {

  2233.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr,);

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

  2235.     carla_debug("carla_set_ctrl_channel(%i, %i)", pluginId, channel);

  2236. 

  2237.     if (CarlaPlugin* const plugin = gStandalone.engine->getPlugin(pluginId))

  2238.         return plugin->setCtrlChannel(channel, true, false);

  2239. 

  2240.     carla_stderr2("carla_set_ctrl_channel(%i, %i) - could not find plugin", pluginId, channel);

  2241. }

  2242. 

  2243. void carla_set_option(uint pluginId, uint option, bool yesNo)

  2244. {

  2245.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr,);

  2246.     carla_debug("carla_set_option(%i, %i, %s)", pluginId, option, bool2str(yesNo));

  2247. 

  2248.     if (CarlaPlugin* const plugin = gStandalone.engine->getPlugin(pluginId))

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

  2250. 

  2251.     carla_stderr2("carla_set_option(%i, %i, %s) - could not find plugin", pluginId, option, bool2str(yesNo));

  2252. }

  2253. #endif

  2254. 

  2255. // -------------------------------------------------------------------------------------------------------------------

  2256. 

  2257. void carla_set_parameter_value(uint pluginId, uint32_t parameterId, float value)

  2258. {

  2259.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr,);

  2260.     carla_debug("carla_set_parameter_value(%i, %i, %f)", pluginId, parameterId, value);

  2261. 

  2262.     if (CarlaPlugin* const plugin = gStandalone.engine->getPlugin(pluginId))

  2263.     {

  2264.         if (parameterId < plugin->getParameterCount())

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

  2266. 

  2267.         carla_stderr2("carla_set_parameter_value(%i, %i, %f) - parameterId out of bounds", pluginId, parameterId, value);

  2268.         return;

  2269.     }

  2270. 

  2271.     carla_stderr2("carla_set_parameter_value(%i, %i, %f) - could not find plugin", pluginId, parameterId, value);

  2272. }

  2273. 

  2274. #ifndef BUILD_BRIDGE

  2275. void carla_set_parameter_midi_channel(uint pluginId, uint32_t parameterId, uint8_t channel)

  2276. {

  2277.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr,);

  2278.     CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

  2279.     carla_debug("carla_set_parameter_midi_channel(%i, %i, %i)", pluginId, parameterId, channel);

  2280. 

  2281.     if (CarlaPlugin* const plugin = gStandalone.engine->getPlugin(pluginId))

  2282.     {

  2283.         if (parameterId < plugin->getParameterCount())

  2284.             return plugin->setParameterMidiChannel(parameterId, channel, true, false);

  2285. 

  2286.         carla_stderr2("carla_set_parameter_midi_channel(%i, %i, %i) - parameterId out of bounds", pluginId, parameterId, channel);

  2287.         return;

  2288.     }

  2289. 

  2290.     carla_stderr2("carla_set_parameter_midi_channel(%i, %i, %i) - could not find plugin", pluginId, parameterId, channel);

  2291. }

  2292. 

  2293. void carla_set_parameter_midi_cc(uint pluginId, uint32_t parameterId, int16_t cc)

  2294. {

  2295.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr,);

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

  2297.     carla_debug("carla_set_parameter_midi_cc(%i, %i, %i)", pluginId, parameterId, cc);

  2298. 

  2299.     if (CarlaPlugin* const plugin = gStandalone.engine->getPlugin(pluginId))

  2300.     {

  2301.         if (parameterId < plugin->getParameterCount())

  2302.             return plugin->setParameterMidiCC(parameterId, cc, true, false);

  2303. 

  2304.         carla_stderr2("carla_set_parameter_midi_cc(%i, %i, %i) - parameterId out of bounds", pluginId, parameterId, cc);

  2305.         return;

  2306.     }

  2307. 

  2308.     carla_stderr2("carla_set_parameter_midi_cc(%i, %i, %i) - could not find plugin", pluginId, parameterId, cc);

  2309. }

  2310. #endif

  2311. 

  2312. // -------------------------------------------------------------------------------------------------------------------

  2313. 

  2314. void carla_set_program(uint pluginId, uint32_t programId)

  2315. {

  2316.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr,);

  2317.     carla_debug("carla_set_program(%i, %i)", pluginId, programId);

  2318. 

  2319.     if (CarlaPlugin* const plugin = gStandalone.engine->getPlugin(pluginId))

  2320.     {

  2321.         if (programId < plugin->getProgramCount())

  2322.             return plugin->setProgram(static_cast<int32_t>(programId), true, true, false);

  2323. 

  2324.         carla_stderr2("carla_set_program(%i, %i) - programId out of bounds", pluginId, programId);

  2325.         return;

  2326.     }

  2327. 

  2328.     carla_stderr2("carla_set_program(%i, %i) - could not find plugin", pluginId, programId);

  2329. }

  2330. 

  2331. void carla_set_midi_program(uint pluginId, uint32_t midiProgramId)

  2332. {

  2333.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr,);

  2334.     carla_debug("carla_set_midi_program(%i, %i)", pluginId, midiProgramId);

  2335. 

  2336.     if (CarlaPlugin* const plugin = gStandalone.engine->getPlugin(pluginId))

  2337.     {

  2338.         if (midiProgramId < plugin->getMidiProgramCount())

  2339.             return plugin->setMidiProgram(static_cast<int32_t>(midiProgramId), true, true, false);

  2340. 

  2341.         carla_stderr2("carla_set_midi_program(%i, %i) - midiProgramId out of bounds", pluginId, midiProgramId);

  2342.         return;

  2343.     }

  2344. 

  2345.     carla_stderr2("carla_set_midi_program(%i, %i) - could not find plugin", pluginId, midiProgramId);

  2346. }

  2347. 

  2348. // -------------------------------------------------------------------------------------------------------------------

  2349. 

  2350. void carla_set_custom_data(uint pluginId, const char* type, const char* key, const char* value)

  2351. {

  2352.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr,);

  2353.     CARLA_SAFE_ASSERT_RETURN(type != nullptr && type[0] != '\0',);

  2354.     CARLA_SAFE_ASSERT_RETURN(key != nullptr && key[0] != '\0',);

  2355.     CARLA_SAFE_ASSERT_RETURN(value != nullptr,);

  2356.     carla_debug("carla_set_custom_data(%i, \"%s\", \"%s\", \"%s\")", pluginId, type, key, value);

  2357. 

  2358.     if (CarlaPlugin* const plugin = gStandalone.engine->getPlugin(pluginId))

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

  2360. 

  2361.     carla_stderr2("carla_set_custom_data(%i, \"%s\", \"%s\", \"%s\") - could not find plugin", pluginId, type, key, value);

  2362. }

  2363. 

  2364. void carla_set_chunk_data(uint pluginId, const char* chunkData)

  2365. {

  2366.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr,);

  2367.     CARLA_SAFE_ASSERT_RETURN(chunkData != nullptr && chunkData[0] != '\0',);

  2368.     carla_debug("carla_set_chunk_data(%i, \"%s\")", pluginId, chunkData);

  2369. 

  2370.     if (CarlaPlugin* const plugin = gStandalone.engine->getPlugin(pluginId))

  2371.     {

  2372.         if (plugin->getOptionsEnabled() & CB::PLUGIN_OPTION_USE_CHUNKS)

  2373.         {

  2374.             std::vector<uint8_t> chunk(carla_getChunkFromBase64String(chunkData));

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

  2376.         }

  2377. 

  2378.         carla_stderr2("carla_set_chunk_data(%i, \"%s\") - plugin does not use chunks", pluginId, chunkData);

  2379.         return;

  2380.     }

  2381. 

  2382.     carla_stderr2("carla_set_chunk_data(%i, \"%s\") - could not find plugin", pluginId, chunkData);

  2383. }

  2384. 

  2385. // -------------------------------------------------------------------------------------------------------------------

  2386. 

  2387. void carla_prepare_for_save(uint pluginId)

  2388. {

  2389.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr,);

  2390.     carla_debug("carla_prepare_for_save(%i)", pluginId);

  2391. 

  2392.     if (CarlaPlugin* const plugin = gStandalone.engine->getPlugin(pluginId))

  2393.         return plugin->prepareForSave();

  2394. 

  2395.     carla_stderr2("carla_prepare_for_save(%i) - could not find plugin", pluginId);

  2396. }

  2397. 

  2398. void carla_reset_parameters(uint pluginId)

  2399. {

  2400.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr,);

  2401.     carla_debug("carla_reset_parameters(%i)", pluginId);

  2402. 

  2403.     if (CarlaPlugin* const plugin = gStandalone.engine->getPlugin(pluginId))

  2404.         return plugin->resetParameters();

  2405. 

  2406.     carla_stderr2("carla_reset_parameters(%i) - could not find plugin", pluginId);

  2407. }

  2408. 

  2409. void carla_randomize_parameters(uint pluginId)

  2410. {

  2411.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr,);

  2412.     carla_debug("carla_randomize_parameters(%i)", pluginId);

  2413. 

  2414.     if (CarlaPlugin* const plugin = gStandalone.engine->getPlugin(pluginId))

  2415.         return plugin->randomizeParameters();

  2416. 

  2417.     carla_stderr2("carla_randomize_parameters(%i) - could not find plugin", pluginId);

  2418. }

  2419. 

  2420. #ifndef BUILD_BRIDGE

  2421. void carla_send_midi_note(uint pluginId, uint8_t channel, uint8_t note, uint8_t velocity)

  2422. {

  2423.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr && gStandalone.engine->isRunning(),);

  2424.     carla_debug("carla_send_midi_note(%i, %i, %i, %i)", pluginId, channel, note, velocity);

  2425. 

  2426.     if (CarlaPlugin* const plugin = gStandalone.engine->getPlugin(pluginId))

  2427.         return plugin->sendMidiSingleNote(channel, note, velocity, true, true, false);

  2428. 

  2429.     carla_stderr2("carla_send_midi_note(%i, %i, %i, %i) - could not find plugin", pluginId, channel, note, velocity);

  2430. }

  2431. #endif

  2432. 

  2433. void carla_show_custom_ui(uint pluginId, bool yesNo)

  2434. {

  2435.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr,);

  2436.     carla_debug("carla_show_custom_ui(%i, %s)", pluginId, bool2str(yesNo));

  2437. 

  2438.     if (CarlaPlugin* const plugin = gStandalone.engine->getPlugin(pluginId))

  2439.         return plugin->showCustomUI(yesNo);

  2440. 

  2441.     carla_stderr2("carla_show_custom_ui(%i, %s) - could not find plugin", pluginId, bool2str(yesNo));

  2442. }

  2443. 

  2444. // -------------------------------------------------------------------------------------------------------------------

  2445. 

  2446. uint32_t carla_get_buffer_size()

  2447. {

  2448.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, 0);

  2449.     carla_debug("carla_get_buffer_size()");

  2450. 

  2451.     return gStandalone.engine->getBufferSize();

  2452. }

  2453. 

  2454. double carla_get_sample_rate()

  2455. {

  2456.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, 0.0);

  2457.     carla_debug("carla_get_sample_rate()");

  2458. 

  2459.     return gStandalone.engine->getSampleRate();

  2460. }

  2461. 

  2462. // -------------------------------------------------------------------------------------------------------------------

  2463. 

  2464. const char* carla_get_last_error()

  2465. {

  2466.     carla_debug("carla_get_last_error()");

  2467. 

  2468.     if (gStandalone.engine != nullptr)

  2469.         return gStandalone.engine->getLastError();

  2470. 

  2471.     return gStandalone.lastError;

  2472. }

  2473. 

  2474. const char* carla_get_host_osc_url_tcp()

  2475. {

  2476.     carla_debug("carla_get_host_osc_url_tcp()");

  2477. 

  2478. #ifdef HAVE_LIBLO

  2479.     if (gStandalone.engine == nullptr)

  2480.     {

  2481.         carla_stderr2("Engine is not running");

  2482.         gStandalone.lastError = "Engine is not running";

  2483.         return nullptr;

  2484.     }

  2485. 

  2486.     return gStandalone.engine->getOscServerPathTCP();

  2487. #else

  2488.     return nullptr;

  2489. #endif

  2490. }

  2491. 

  2492. const char* carla_get_host_osc_url_udp()

  2493. {

  2494.     carla_debug("carla_get_host_osc_url_udp()");

  2495. 

  2496. #ifdef HAVE_LIBLO

  2497.     if (gStandalone.engine == nullptr)

  2498.     {

  2499.         carla_stderr2("Engine is not running");

  2500.         gStandalone.lastError = "Engine is not running";

  2501.         return nullptr;

  2502.     }

  2503. 

  2504.     return gStandalone.engine->getOscServerPathUDP();

  2505. #else

  2506.     return nullptr;

  2507. #endif

  2508. }

  2509. 

  2510. // -------------------------------------------------------------------------------------------------------------------

  2511. 

  2512. bool carla_nsm_init(int pid, const char* executableName)

  2513. {

  2514. #ifdef HAVE_LIBLO

  2515.     return CarlaNSM::getInstance().announce(pid, executableName);

  2516. #else

  2517.     return false;

  2518. 

  2519.     // unused

  2520.     (void)pid; (void)executableName;

  2521. #endif

  2522. }

  2523. 

  2524. void carla_nsm_ready()

  2525. {

  2526. #ifdef HAVE_LIBLO

  2527.     CarlaNSM::getInstance().start();

  2528. #endif

  2529. }

  2530. 

  2531. // -------------------------------------------------------------------------------------------------------------------

  2532. 

  2533. #include "CarlaPluginUI.cpp"

  2534. #include "CarlaDssiUtils.cpp"

  2535. #include "CarlaPatchbayUtils.cpp"

  2536. #include "CarlaPipeUtils.cpp"

  2537. #include "CarlaStateUtils.cpp"

  2538. #include "CarlaJuceEvents.cpp"

  2539. 

  2540. // -------------------------------------------------------------------------------------------------------------------