falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 42 Activity
Audio plugin host https://kx.studio/carla
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
173 Commits
16 Branches
304MB
Tree: 59cd6d0196
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '59cd6d0196'
${ noResults }
Carla/source/backend/standalone/CarlaStandalone.cpp

1971 lines
64KB
Raw Blame History 

  1. /*

  2.  * Carla Standalone

  3.  * Copyright (C) 2011-2013 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 GPL.txt file

  16.  */

  17. 

  18. #include "CarlaStandalone.hpp"

  19. 

  20. #include "CarlaBackendUtils.hpp"

  21. #include "CarlaEngine.hpp"

  22. #include "CarlaPlugin.hpp"

  23. #include "CarlaMIDI.h"

  24. #include "CarlaNative.h"

  25. 

  26. #if 0

  27. extern "C" {

  28. #include "siginfo.c"

  29. }

  30. #endif

  31. 

  32. using CarlaBackend::CarlaEngine;

  33. using CarlaBackend::CarlaPlugin;

  34. 

  35. using CarlaBackend::CallbackFunc;

  36. using CarlaBackend::EngineOptions;

  37. 

  38. // -------------------------------------------------------------------------------------------------------------------

  39. 

  40. // Single, standalone engine

  41. struct CarlaBackendStandalone {

  42.     CallbackFunc  callback;

  43.     void*         callbackPtr;

  44.     CarlaEngine*  engine;

  45.     CarlaString   lastError;

  46.     CarlaString   procName;

  47.     EngineOptions options;

  48. 

  49.     CarlaBackendStandalone()

  50.         : callback(nullptr),

  51.           callbackPtr(nullptr),

  52.           engine(nullptr) {}

  53. 

  54. } standalone;

  55. 

  56. // -------------------------------------------------------------------------------------------------------------------

  57. // Helpers

  58. 

  59. CarlaEngine* carla_get_standalone_engine()

  60. {

  61.     return standalone.engine;

  62. }

  63. 

  64. // -------------------------------------------------------------------------------------------------------------------

  65. // API

  66. 

  67. const char* carla_get_extended_license_text()

  68. {

  69.     carla_debug("carla_get_extended_license_text()");

  70. 

  71.     static CarlaString retText;

  72. 

  73.     if (retText.isEmpty())

  74.     {

  75.         retText  = "<p>This current Carla build is using the following features and 3rd-party code:</p>";

  76.         retText += "<ul>";

  77. 

  78. #ifdef WANT_LADSPA

  79.         retText += "<li>LADSPA plugin support, http://www.ladspa.org/</li>";

  80. #endif

  81. #ifdef WANT_DSSI

  82.         retText += "<li>DSSI plugin support, http://dssi.sourceforge.net/</li>";

  83. #endif

  84. #ifdef WANT_LV2

  85.         retText += "<li>LV2 plugin support, http://lv2plug.in/</li>";

  86. #endif

  87. #ifdef WANT_VST

  88. # ifdef VESTIGE_HEADER

  89.         retText += "<li>VST plugin support, using VeSTige header by Javier Serrano Polo</li>";

  90. # else

  91.         retText += "<li>VST plugin support, using official VST SDK 2.4 (trademark of Steinberg Media Technologies GmbH)</li>";

  92. # endif

  93. #endif

  94. #ifdef WANT_ZYNADDSUBFX

  95.         retText += "<li>ZynAddSubFX plugin code, http://zynaddsubfx.sf.net/</li>";

  96. #endif

  97. #ifdef WANT_FLUIDSYNTH

  98.         retText += "<li>FluidSynth library for SF2 support, http://www.fluidsynth.org/</li>";

  99. #endif

  100. #ifdef WANT_LINUXSAMPLER

  101.         retText += "<li>LinuxSampler library for GIG and SFZ support*, http://www.linuxsampler.org/</li>";

  102. #endif

  103.         retText += "<li>liblo library for OSC support, http://liblo.sourceforge.net/</li>";

  104. #ifdef WANT_LV2

  105.         retText += "<li>serd, sord, sratom and lilv libraries for LV2 discovery, http://drobilla.net/software/lilv/</li>";

  106. #endif

  107. #ifdef CARLA_ENGINE_RTAUDIO

  108.         retText += "<li>RtAudio and RtMidi libraries for extra Audio and MIDI support, http://www.music.mcgill.ca/~gary/rtaudio/</li>";

  109. #endif

  110.         retText += "</ul>";

  111. 

  112. #ifdef WANT_LINUXSAMPLER

  113.         retText += "<p>(*) Using LinuxSampler code in commercial hardware or software products is not allowed without prior written authorization by the authors.</p>";

  114. #endif

  115.     }

  116. 

  117.     return retText;

  118. }

  119. 

  120. // -------------------------------------------------------------------------------------------------------------------

  121. 

  122. unsigned int carla_get_engine_driver_count()

  123. {

  124.     carla_debug("carla_get_engine_driver_count()");

  125. 

  126.     return CarlaEngine::getDriverCount();

  127. }

  128. 

  129. const char* carla_get_engine_driver_name(unsigned int index)

  130. {

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

  132. 

  133.     return CarlaEngine::getDriverName(index);

  134. }

  135. 

  136. // -------------------------------------------------------------------------------------------------------------------

  137. 

  138. unsigned int carla_get_internal_plugin_count()

  139. {

  140.     carla_debug("carla_get_internal_plugin_count()");

  141. 

  142.     return static_cast<unsigned int>(CarlaPlugin::getNativePluginCount());

  143. }

  144. 

  145. const CarlaNativePluginInfo* carla_get_internal_plugin_info(unsigned int internalPluginId)

  146. {

  147.     carla_debug("carla_get_internal_plugin_info(%i)", internalPluginId);

  148. 

  149.     static CarlaNativePluginInfo info;

  150. 

  151.     const PluginDescriptor* const nativePlugin = CarlaPlugin::getNativePluginDescriptor(internalPluginId);

  152. 

  153.     // as internal plugin, this must never fail

  154.     CARLA_ASSERT(nativePlugin != nullptr);

  155. 

  156.     if (nativePlugin == nullptr)

  157.         return nullptr;

  158. 

  159.      info.category  = static_cast<CarlaPluginCategory>(nativePlugin->category);

  160.      info.hints     = 0x0;

  161. 

  162.     if (nativePlugin->hints & PLUGIN_IS_RTSAFE)

  163.          info.hints |= CarlaBackend::PLUGIN_IS_RTSAFE;

  164.      if (nativePlugin->hints & PLUGIN_IS_SYNTH)

  165.          info.hints |= CarlaBackend::PLUGIN_IS_SYNTH;

  166.      if (nativePlugin->hints & PLUGIN_HAS_GUI)

  167.          info.hints |= CarlaBackend::PLUGIN_HAS_GUI;

  168.      if (nativePlugin->hints & PLUGIN_USES_SINGLE_THREAD)

  169.          info.hints |= CarlaBackend::PLUGIN_HAS_SINGLE_THREAD;

  170. 

  171.      info.audioIns  = nativePlugin->audioIns;

  172.      info.audioOuts = nativePlugin->audioOuts;

  173.      info.midiIns   = nativePlugin->midiIns;

  174.      info.midiOuts  = nativePlugin->midiOuts;

  175.      info.parameterIns  = nativePlugin->parameterIns;

  176.      info.parameterOuts = nativePlugin->parameterOuts;

  177. 

  178.      info.name      = nativePlugin->name;

  179.      info.label     = nativePlugin->label;

  180.      info.maker     = nativePlugin->maker;

  181.      info.copyright = nativePlugin->copyright;

  182. 

  183.     return &info;

  184. }

  185. 

  186. // -------------------------------------------------------------------------------------------------------------------

  187. 

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

  189. {

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

  191.     CARLA_ASSERT(standalone.engine == nullptr);

  192.     CARLA_ASSERT(driverName != nullptr);

  193.     CARLA_ASSERT(clientName != nullptr);

  194. 

  195. #if 0

  196.     static bool sigInfoInitiated = false;

  197. 

  198.     if (! sigInfoInitiated)

  199.     {

  200.         setup_siginfo();

  201.         sigInfoInitiated = true;

  202.     }

  203. #endif

  204. 

  205.     standalone.engine = CarlaEngine::newDriverByName(driverName);

  206. 

  207.     if (standalone.engine == nullptr)

  208.     {

  209.         standalone.lastError = "The seleted audio driver is not available!";

  210.         return false;

  211.     }

  212. 

  213. #ifndef Q_OS_WIN

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

  215.     if (getenv("WINE_RT") == nullptr)

  216.     {

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

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

  219.     }

  220. #endif

  221. 

  222.     if (standalone.callback != nullptr)

  223.         standalone.engine->setCallback(standalone.callback, nullptr);

  224. 

  225. #ifndef BUILD_BRIDGE

  226.     standalone.engine->setOption(CarlaBackend::OPTION_PROCESS_MODE,               static_cast<int>(standalone.options.processMode),   nullptr);

  227.     standalone.engine->setOption(CarlaBackend::OPTION_TRANSPORT_MODE,             static_cast<int>(standalone.options.transportMode), nullptr);

  228.     standalone.engine->setOption(CarlaBackend::OPTION_FORCE_STEREO,               standalone.options.forceStereo ? 1 : 0,             nullptr);

  229.     standalone.engine->setOption(CarlaBackend::OPTION_PREFER_PLUGIN_BRIDGES,      standalone.options.preferPluginBridges ? 1 : 0,     nullptr);

  230.     standalone.engine->setOption(CarlaBackend::OPTION_PREFER_UI_BRIDGES,          standalone.options.preferUiBridges ? 1 : 0,         nullptr);

  231. # ifdef WANT_DSSI

  232.     standalone.engine->setOption(CarlaBackend::OPTION_USE_DSSI_VST_CHUNKS,        standalone.options.useDssiVstChunks ? 1 : 0,        nullptr);

  233. # endif

  234.     standalone.engine->setOption(CarlaBackend::OPTION_MAX_PARAMETERS,             static_cast<int>(standalone.options.maxParameters),       nullptr);

  235.     standalone.engine->setOption(CarlaBackend::OPTION_PREFERRED_BUFFER_SIZE,      static_cast<int>(standalone.options.preferredBufferSize), nullptr);

  236.     standalone.engine->setOption(CarlaBackend::OPTION_PREFERRED_SAMPLE_RATE,      static_cast<int>(standalone.options.preferredSampleRate), nullptr);

  237.     standalone.engine->setOption(CarlaBackend::OPTION_OSC_UI_TIMEOUT,             static_cast<int>(standalone.options.oscUiTimeout),        nullptr);

  238.     standalone.engine->setOption(CarlaBackend::OPTION_PATH_BRIDGE_NATIVE,      0, standalone.options.bridge_native);

  239.     standalone.engine->setOption(CarlaBackend::OPTION_PATH_BRIDGE_POSIX32,     0, standalone.options.bridge_posix32);

  240.     standalone.engine->setOption(CarlaBackend::OPTION_PATH_BRIDGE_POSIX64,     0, standalone.options.bridge_posix64);

  241.     standalone.engine->setOption(CarlaBackend::OPTION_PATH_BRIDGE_WIN32,       0, standalone.options.bridge_win32);

  242.     standalone.engine->setOption(CarlaBackend::OPTION_PATH_BRIDGE_WIN64,       0, standalone.options.bridge_win64);

  243. # ifdef WANT_LV2

  244.     standalone.engine->setOption(CarlaBackend::OPTION_PATH_BRIDGE_LV2_GTK2,    0, standalone.options.bridge_lv2gtk2);

  245.     standalone.engine->setOption(CarlaBackend::OPTION_PATH_BRIDGE_LV2_GTK3,    0, standalone.options.bridge_lv2gtk3);

  246.     standalone.engine->setOption(CarlaBackend::OPTION_PATH_BRIDGE_LV2_QT4,     0, standalone.options.bridge_lv2qt4);

  247.     standalone.engine->setOption(CarlaBackend::OPTION_PATH_BRIDGE_LV2_QT5,     0, standalone.options.bridge_lv2qt5);

  248.     standalone.engine->setOption(CarlaBackend::OPTION_PATH_BRIDGE_LV2_COCOA,   0, standalone.options.bridge_lv2cocoa);

  249.     standalone.engine->setOption(CarlaBackend::OPTION_PATH_BRIDGE_LV2_WINDOWS, 0, standalone.options.bridge_lv2win);

  250.     standalone.engine->setOption(CarlaBackend::OPTION_PATH_BRIDGE_LV2_X11,     0, standalone.options.bridge_lv2qt4);

  251. # endif

  252. # ifdef WANT_VST

  253.     standalone.engine->setOption(CarlaBackend::OPTION_PATH_BRIDGE_VST_COCOA,   0, standalone.options.bridge_vstcocoa);

  254.     standalone.engine->setOption(CarlaBackend::OPTION_PATH_BRIDGE_VST_HWND,    0, standalone.options.bridge_vsthwnd);

  255.     standalone.engine->setOption(CarlaBackend::OPTION_PATH_BRIDGE_VST_X11,     0, standalone.options.bridge_vstx11);

  256. # endif

  257. 

  258.     if (standalone.procName.isNotEmpty())

  259.         standalone.engine->setOption(CarlaBackend::OPTION_PROCESS_NAME, 0, standalone.procName);

  260. #endif

  261. 

  262.     const bool initiated = standalone.engine->init(clientName);

  263. 

  264.     if (initiated)

  265.     {

  266.         standalone.lastError = "no error";

  267.     }

  268.     else

  269.     {

  270.         standalone.lastError = standalone.engine->getLastError();

  271.         delete standalone.engine;

  272.         standalone.engine = nullptr;

  273.     }

  274. 

  275.     return initiated;

  276. }

  277. 

  278. bool carla_engine_close()

  279. {

  280.     carla_debug("carla_engine_close()");

  281.     CARLA_ASSERT(standalone.engine != nullptr);

  282. 

  283.     if (standalone.engine == nullptr)

  284.     {

  285.         standalone.lastError = "Engine is not started";

  286.         return false;

  287.     }

  288. 

  289.     standalone.engine->setAboutToClose();

  290.     standalone.engine->removeAllPlugins();

  291. 

  292.     const bool closed = standalone.engine->close();

  293. 

  294.     delete standalone.engine;

  295.     standalone.engine = nullptr;

  296. 

  297.     return closed;

  298. }

  299. 

  300. void carla_engine_idle()

  301. {

  302.     CARLA_ASSERT(standalone.engine != nullptr);

  303. 

  304.     if (standalone.engine != nullptr)

  305.         standalone.engine->idle();

  306. }

  307. 

  308. bool carla_is_engine_running()

  309. {

  310.     carla_debug("carla_is_engine_running()");

  311. 

  312.     return (standalone.engine != nullptr && standalone.engine->isRunning());

  313. }

  314. 

  315. void carla_set_engine_about_to_close()

  316. {

  317.     carla_debug("carla_set_engine_about_to_close()");

  318.     CARLA_ASSERT(standalone.engine != nullptr);

  319. 

  320.     if (standalone.engine != nullptr)

  321.         standalone.engine->setAboutToClose();

  322. }

  323. 

  324. void carla_set_engine_callback(CarlaBackend::CallbackFunc func, void* ptr)

  325. {

  326.     carla_debug("carla_set_engine_callback(%p)", func);

  327. 

  328.     standalone.callback    = func;

  329.     standalone.callbackPtr = ptr;

  330. 

  331.     if (standalone.engine != nullptr)

  332.         standalone.engine->setCallback(func, ptr);

  333. }

  334. 

  335. void carla_set_engine_option(CarlaBackend::OptionsType option, int value, const char* valueStr)

  336. {

  337.     carla_debug("carla_set_engine_option(%s, %i, \"%s\")", CarlaBackend::OptionsType2Str(option), value, valueStr);

  338. 

  339. #ifndef BUILD_BRIDGE

  340.     if (standalone.engine != nullptr)

  341.         standalone.engine->setOption(option, value, valueStr);

  342. #endif

  343. 

  344.     switch (option)

  345.     {

  346.     case CarlaBackend::OPTION_PROCESS_NAME:

  347.         standalone.procName = valueStr;

  348.         break;

  349. 

  350.     case CarlaBackend::OPTION_PROCESS_MODE:

  351.         if (value < CarlaBackend::PROCESS_MODE_SINGLE_CLIENT || value > CarlaBackend::PROCESS_MODE_PATCHBAY)

  352.             return carla_stderr2("carla_set_engine_option(OPTION_PROCESS_MODE, %i, \"%s\") - invalid value", value, valueStr);

  353. 

  354.         standalone.options.processMode = static_cast<CarlaBackend::ProcessMode>(value);

  355.         break;

  356. 

  357.     case CarlaBackend::OPTION_TRANSPORT_MODE:

  358.         if (value < CarlaBackend::TRANSPORT_MODE_INTERNAL || value > CarlaBackend::TRANSPORT_MODE_JACK)

  359.             return carla_stderr2("carla_set_engine_option(OPTION_TRANSPORT_MODE, %i, \"%s\") - invalid value", value, valueStr);

  360. 

  361.         standalone.options.transportMode = static_cast<CarlaBackend::TransportMode>(value);

  362.         break;

  363. 

  364.     case CarlaBackend::OPTION_FORCE_STEREO:

  365.         standalone.options.forceStereo = (value != 0);

  366.         break;

  367. 

  368.     case CarlaBackend::OPTION_PREFER_PLUGIN_BRIDGES:

  369.         standalone.options.preferPluginBridges = (value != 0);

  370.         break;

  371. 

  372.     case CarlaBackend::OPTION_PREFER_UI_BRIDGES:

  373.         standalone.options.preferUiBridges = (value != 0);

  374.         break;

  375. 

  376. #ifdef WANT_DSSI

  377.     case CarlaBackend::OPTION_USE_DSSI_VST_CHUNKS:

  378.         standalone.options.useDssiVstChunks = (value != 0);

  379.         break;

  380. #endif

  381. 

  382.     case CarlaBackend::OPTION_MAX_PARAMETERS:

  383.         standalone.options.maxParameters = (value > 0) ? static_cast<unsigned int>(value) : CarlaBackend::MAX_DEFAULT_PARAMETERS;

  384.         break;

  385. 

  386.     case CarlaBackend::OPTION_OSC_UI_TIMEOUT:

  387.         standalone.options.oscUiTimeout = static_cast<unsigned int>(value);

  388.         break;

  389. 

  390.     case CarlaBackend::OPTION_PREFERRED_BUFFER_SIZE:

  391.         standalone.options.preferredBufferSize = static_cast<unsigned int>(value);

  392.         break;

  393. 

  394.     case CarlaBackend::OPTION_PREFERRED_SAMPLE_RATE:

  395.         standalone.options.preferredSampleRate = static_cast<unsigned int>(value);

  396.         break;

  397. 

  398. #ifndef BUILD_BRIDGE

  399.     case CarlaBackend::OPTION_PATH_BRIDGE_NATIVE:

  400.         standalone.options.bridge_native = valueStr;

  401.         break;

  402.     case CarlaBackend::OPTION_PATH_BRIDGE_POSIX32:

  403.         standalone.options.bridge_posix32 = valueStr;

  404.         break;

  405.     case CarlaBackend::OPTION_PATH_BRIDGE_POSIX64:

  406.         standalone.options.bridge_posix64 = valueStr;

  407.         break;

  408.     case CarlaBackend::OPTION_PATH_BRIDGE_WIN32:

  409.         standalone.options.bridge_win32 = valueStr;

  410.         break;

  411.     case CarlaBackend::OPTION_PATH_BRIDGE_WIN64:

  412.         standalone.options.bridge_win64 = valueStr;

  413.         break;

  414. #endif

  415. #ifdef WANT_LV2

  416.     case CarlaBackend::OPTION_PATH_BRIDGE_LV2_GTK2:

  417.         standalone.options.bridge_lv2gtk2 = valueStr;

  418.         break;

  419.     case CarlaBackend::OPTION_PATH_BRIDGE_LV2_GTK3:

  420.         standalone.options.bridge_lv2gtk3 = valueStr;

  421.         break;

  422.     case CarlaBackend::OPTION_PATH_BRIDGE_LV2_QT4:

  423.         standalone.options.bridge_lv2qt4 = valueStr;

  424.         break;

  425.     case CarlaBackend::OPTION_PATH_BRIDGE_LV2_QT5:

  426.         standalone.options.bridge_lv2qt5 = valueStr;

  427.         break;

  428.     case CarlaBackend::OPTION_PATH_BRIDGE_LV2_COCOA:

  429.         standalone.options.bridge_lv2cocoa = valueStr;

  430.         break;

  431.     case CarlaBackend::OPTION_PATH_BRIDGE_LV2_WINDOWS:

  432.         standalone.options.bridge_lv2win = valueStr;

  433.         break;

  434.     case CarlaBackend::OPTION_PATH_BRIDGE_LV2_X11:

  435.         standalone.options.bridge_lv2x11 = valueStr;

  436.         break;

  437. #endif

  438. #ifdef WANT_VST

  439.     case CarlaBackend::OPTION_PATH_BRIDGE_VST_COCOA:

  440.         standalone.options.bridge_vstcocoa = valueStr;

  441.         break;

  442.     case CarlaBackend::OPTION_PATH_BRIDGE_VST_HWND:

  443.         standalone.options.bridge_vsthwnd = valueStr;

  444.         break;

  445.     case CarlaBackend::OPTION_PATH_BRIDGE_VST_X11:

  446.         standalone.options.bridge_vstx11 = valueStr;

  447.         break;

  448. #endif

  449.     }

  450. }

  451. 

  452. // -------------------------------------------------------------------------------------------------------------------

  453. 

  454. bool carla_load_project(const char* filename)

  455. {

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

  457.     CARLA_ASSERT(standalone.engine != nullptr);

  458.     CARLA_ASSERT(filename != nullptr);

  459. 

  460.     if (standalone.engine != nullptr)

  461.         return standalone.engine->loadProject(filename);

  462. 

  463.     standalone.lastError = "Engine is not started";

  464.     return false;

  465. }

  466. 

  467. bool carla_save_project(const char* filename)

  468. {

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

  470.     CARLA_ASSERT(standalone.engine != nullptr);

  471.     CARLA_ASSERT(filename != nullptr);

  472. 

  473.     if (standalone.engine != nullptr)

  474.         return standalone.engine->saveProject(filename);

  475. 

  476.     standalone.lastError = "Engine is not started";

  477.     return false;

  478. }

  479. 

  480. // -------------------------------------------------------------------------------------------------------------------

  481. 

  482. void carla_transport_play()

  483. {

  484.     carla_debug("carla_transport_play()");

  485.     CARLA_ASSERT(standalone.engine != nullptr);

  486. 

  487.     if (standalone.engine != nullptr)

  488.         return standalone.engine->transportPlay();

  489. }

  490. 

  491. void carla_transport_pause()

  492. {

  493.     carla_debug("carla_transport_pause()");

  494.     CARLA_ASSERT(standalone.engine != nullptr);

  495. 

  496.     if (standalone.engine != nullptr)

  497.         return standalone.engine->transportPause();

  498. }

  499. 

  500. void carla_transport_relocate(uint32_t frames)

  501. {

  502.     carla_debug("carla_transport_relocate(%i)", frames);

  503.     CARLA_ASSERT(standalone.engine != nullptr);

  504. 

  505.     if (standalone.engine != nullptr)

  506.         return standalone.engine->transportRelocate(frames);

  507. }

  508. 

  509. // -------------------------------------------------------------------------------------------------------------------

  510. 

  511. bool carla_add_plugin(CarlaBackend::BinaryType btype, CarlaBackend::PluginType ptype, const char* filename, const char* const name, const char* label, const void* extraStuff)

  512. {

  513.     carla_debug("carla_add_plugin(%s, %s, \"%s\", \"%s\", \"%s\", %p)", CarlaBackend::BinaryType2Str(btype), CarlaBackend::PluginType2Str(ptype), filename, name, label, extraStuff);

  514.     CARLA_ASSERT(standalone.engine != nullptr);

  515. 

  516.     if (standalone.engine != nullptr && standalone.engine->isRunning())

  517.         return standalone.engine->addPlugin(btype, ptype, filename, name, label, extraStuff);

  518. 

  519.     standalone.lastError = "Engine is not started";

  520.     return false;

  521. }

  522. 

  523. bool carla_remove_plugin(unsigned int pluginId)

  524. {

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

  526.     CARLA_ASSERT(standalone.engine != nullptr);

  527. 

  528.     if (standalone.engine != nullptr && standalone.engine->isRunning())

  529.         return standalone.engine->removePlugin(pluginId);

  530. 

  531.     standalone.lastError = "Engine is not started";

  532.     return false;

  533. }

  534. 

  535. void carla_remove_all_plugins()

  536. {

  537.     carla_debug("carla_remove_all_plugins()");

  538.     CARLA_ASSERT(standalone.engine != nullptr);

  539. 

  540.     if (standalone.engine != nullptr && standalone.engine->isRunning())

  541.         standalone.engine->removeAllPlugins();

  542. }

  543. 

  544. bool carla_load_plugin_state(unsigned int pluginId, const char* filename)

  545. {

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

  547.     CARLA_ASSERT(standalone.engine != nullptr);

  548. 

  549.     if (standalone.engine == nullptr)

  550.         return false;

  551. 

  552.     if (CarlaPlugin* const plugin = standalone.engine->getPlugin(pluginId))

  553.         return plugin->loadStateFromFile(filename);

  554. 

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

  556.     return false;

  557. }

  558. 

  559. bool carla_save_plugin_state(unsigned int pluginId, const char* filename)

  560. {

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

  562.     CARLA_ASSERT(standalone.engine != nullptr);

  563. 

  564.     if (standalone.engine == nullptr)

  565.         return false;

  566. 

  567.     if (CarlaPlugin* const plugin = standalone.engine->getPlugin(pluginId))

  568.         return plugin->saveStateToFile(filename);

  569. 

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

  571.     return false;

  572. }

  573. 

  574. // -------------------------------------------------------------------------------------------------------------------

  575. 

  576. const CarlaPluginInfo* carla_get_plugin_info(unsigned int pluginId)

  577. {

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

  579.     CARLA_ASSERT(standalone.engine != nullptr);

  580. 

  581.     static CarlaPluginInfo info;

  582. 

  583.     // reset

  584.     info.type     = CarlaBackend::PLUGIN_NONE;

  585.     info.category = CarlaBackend::PLUGIN_CATEGORY_NONE;

  586.     info.hints    = 0x0;

  587.     info.hints    = 0x0;

  588.     info.binary   = nullptr;

  589.     info.name     = nullptr;

  590.     info.uniqueId = 0;

  591.     info.latency  = 0;

  592.     info.optionsAvailable = 0x0;

  593.     info.optionsEnabled   = 0x0;

  594. 

  595.     // cleanup

  596.     if (info.label != nullptr)

  597.     {

  598.         delete[] info.label;

  599.         info.label = nullptr;

  600.     }

  601. 

  602.     if (info.maker != nullptr)

  603.     {

  604.         delete[] info.maker;

  605.         info.maker = nullptr;

  606.     }

  607. 

  608.     if (info.copyright != nullptr)

  609.     {

  610.         delete[] info.copyright;

  611.         info.copyright = nullptr;

  612.     }

  613. 

  614.     if (standalone.engine == nullptr)

  615.         return &info;

  616. 

  617.     if (CarlaPlugin* const plugin = standalone.engine->getPlugin(pluginId))

  618.     {

  619.         char strBufLabel[STR_MAX] = { 0 };

  620.         char strBufMaker[STR_MAX] = { 0 };

  621.         char strBufCopyright[STR_MAX] = { 0 };

  622. 

  623.         info.type     = plugin->type();

  624.         info.category = plugin->category();

  625.         info.hints    = plugin->hints();

  626.         info.binary   = plugin->filename();

  627.         info.name     = plugin->name();

  628.         info.uniqueId = plugin->uniqueId();

  629.         info.latency  = plugin->latency();

  630. 

  631.         info.optionsAvailable = plugin->availableOptions();

  632.         info.optionsEnabled   = plugin->options();

  633. 

  634.         plugin->getLabel(strBufLabel);

  635.         info.label = carla_strdup(strBufLabel);

  636. 

  637.         plugin->getMaker(strBufMaker);

  638.         info.maker = carla_strdup(strBufMaker);

  639. 

  640.         plugin->getCopyright(strBufCopyright);

  641.         info.copyright = carla_strdup(strBufCopyright);

  642. 

  643.         return &info;

  644.     }

  645. 

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

  647.     return &info;

  648. }

  649. 

  650. const CarlaPortCountInfo* carla_get_audio_port_count_info(unsigned int pluginId)

  651. {

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

  653.     CARLA_ASSERT(standalone.engine != nullptr);

  654. 

  655.     static CarlaPortCountInfo info;

  656. 

  657.     // reset

  658.     info.ins   = 0;

  659.     info.outs  = 0;

  660.     info.total = 0;

  661. 

  662.     if (standalone.engine == nullptr)

  663.         return &info;

  664. 

  665.     if (CarlaPlugin* const plugin = standalone.engine->getPlugin(pluginId))

  666.     {

  667.         info.ins   = plugin->audioInCount();

  668.         info.outs  = plugin->audioOutCount();

  669.         info.total = info.ins + info.outs;

  670.         return &info;

  671.     }

  672. 

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

  674.     return &info;

  675. }

  676. 

  677. const CarlaPortCountInfo* carla_get_midi_port_count_info(unsigned int pluginId)

  678. {

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

  680.     CARLA_ASSERT(standalone.engine != nullptr);

  681. 

  682.     static CarlaPortCountInfo info;

  683. 

  684.     // reset

  685.     info.ins   = 0;

  686.     info.outs  = 0;

  687.     info.total = 0;

  688. 

  689.     if (standalone.engine == nullptr)

  690.         return &info;

  691. 

  692.     if (CarlaPlugin* const plugin = standalone.engine->getPlugin(pluginId))

  693.     {

  694.         info.ins   = plugin->midiInCount();

  695.         info.outs  = plugin->midiOutCount();

  696.         info.total = info.ins + info.outs;

  697.         return &info;

  698.     }

  699. 

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

  701.     return &info;

  702. }

  703. 

  704. const CarlaPortCountInfo* carla_get_parameter_count_info(unsigned int pluginId)

  705. {

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

  707.     CARLA_ASSERT(standalone.engine != nullptr);

  708. 

  709.     static CarlaPortCountInfo info;

  710. 

  711.     // reset

  712.     info.ins   = 0;

  713.     info.outs  = 0;

  714.     info.total = 0;

  715. 

  716.     if (standalone.engine == nullptr)

  717.         return &info;

  718. 

  719.     if (CarlaPlugin* const plugin = standalone.engine->getPlugin(pluginId))

  720.     {

  721.         plugin->getParameterCountInfo(&info.ins, &info.outs, &info.total);

  722.         return &info;

  723.     }

  724. 

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

  726.     return &info;

  727. }

  728. 

  729. const CarlaParameterInfo* carla_get_parameter_info(unsigned int pluginId, uint32_t parameterId)

  730. {

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

  732.     CARLA_ASSERT(standalone.engine != nullptr);

  733. 

  734.     static CarlaParameterInfo info;

  735. 

  736.     // reset

  737.     info.scalePointCount = 0;

  738. 

  739.     // cleanup

  740.     if (info.name != nullptr)

  741.     {

  742.         delete[] info.name;

  743.         info.name = nullptr;

  744.     }

  745. 

  746.     if (info.symbol != nullptr)

  747.     {

  748.         delete[] info.symbol;

  749.         info.symbol = nullptr;

  750.     }

  751. 

  752.     if (info.unit != nullptr)

  753.     {

  754.         delete[] info.unit;

  755.         info.unit = nullptr;

  756.     }

  757. 

  758.     if (standalone.engine == nullptr)

  759.         return &info;

  760. 

  761.     if (CarlaPlugin* const plugin = standalone.engine->getPlugin(pluginId))

  762.     {

  763.         if (parameterId < plugin->parameterCount())

  764.         {

  765.             char strBufName[STR_MAX] = { 0 };

  766.             char strBufSymbol[STR_MAX] = { 0 };

  767.             char strBufUnit[STR_MAX] = { 0 };

  768. 

  769.             info.scalePointCount = plugin->parameterScalePointCount(parameterId);

  770. 

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

  772.             info.name = carla_strdup(strBufName);

  773. 

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

  775.             info.symbol = carla_strdup(strBufSymbol);

  776. 

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

  778.             info.unit = carla_strdup(strBufUnit);

  779.         }

  780.         else

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

  782. 

  783.         return &info;

  784.     }

  785. 

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

  787.     return &info;

  788. }

  789. 

  790. const CarlaScalePointInfo* carla_get_parameter_scalepoint_info(unsigned int pluginId, uint32_t parameterId, uint32_t scalePointId)

  791. {

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

  793.     CARLA_ASSERT(standalone.engine != nullptr);

  794. 

  795.     static CarlaScalePointInfo info;

  796. 

  797.     // reset

  798.     info.value = 0.0f;

  799. 

  800.     // cleanup

  801.     if (info.label != nullptr)

  802.     {

  803.         delete[] info.label;

  804.         info.label = nullptr;

  805.     }

  806. 

  807.     if (standalone.engine == nullptr)

  808.         return &info;

  809. 

  810.     if (CarlaPlugin* const plugin = standalone.engine->getPlugin(pluginId))

  811.     {

  812.         if (parameterId < plugin->parameterCount())

  813.         {

  814.             if (scalePointId < plugin->parameterScalePointCount(parameterId))

  815.             {

  816.                 char strBufLabel[STR_MAX] = { 0 };

  817. 

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

  819. 

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

  821.                 info.label = carla_strdup(strBufLabel);

  822.             }

  823.             else

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

  825.         }

  826.         else

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

  828. 

  829.         return &info;

  830.     }

  831. 

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

  833.     return &info;

  834. }

  835. 

  836. // -------------------------------------------------------------------------------------------------------------------

  837. 

  838. const CarlaBackend::ParameterData* carla_get_parameter_data(unsigned int pluginId, uint32_t parameterId)

  839. {

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

  841.     CARLA_ASSERT(standalone.engine != nullptr);

  842. 

  843.     static CarlaBackend::ParameterData data;

  844. 

  845.     if (standalone.engine == nullptr)

  846.         return &data;

  847. 

  848.     if (CarlaPlugin* const plugin = standalone.engine->getPlugin(pluginId))

  849.     {

  850.         if (parameterId < plugin->parameterCount())

  851.             return &plugin->parameterData(parameterId);

  852. 

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

  854.         return &data;

  855.     }

  856. 

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

  858.     return &data;

  859. }

  860. 

  861. const CarlaBackend::ParameterRanges* carla_get_parameter_ranges(unsigned int pluginId, uint32_t parameterId)

  862. {

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

  864.     CARLA_ASSERT(standalone.engine != nullptr);

  865. 

  866.     static CarlaBackend::ParameterRanges ranges;

  867. 

  868.     if (standalone.engine == nullptr)

  869.         return &ranges;

  870. 

  871.     if (CarlaPlugin* const plugin = standalone.engine->getPlugin(pluginId))

  872.     {

  873.         if (parameterId < plugin->parameterCount())

  874.             return &plugin->parameterRanges(parameterId);

  875. 

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

  877.         return &ranges;

  878.     }

  879. 

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

  881.     return &ranges;

  882. }

  883. 

  884. const CarlaBackend::MidiProgramData* carla_get_midi_program_data(unsigned int pluginId, uint32_t midiProgramId)

  885. {

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

  887.     CARLA_ASSERT(standalone.engine != nullptr);

  888. 

  889.     static CarlaBackend::MidiProgramData data;

  890. 

  891.     if (standalone.engine == nullptr)

  892.         return &data;

  893. 

  894.     if (CarlaPlugin* const plugin = standalone.engine->getPlugin(pluginId))

  895.     {

  896.         if (midiProgramId < plugin->midiProgramCount())

  897.             return &plugin->midiProgramData(midiProgramId);

  898. 

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

  900.         return &data;

  901.     }

  902. 

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

  904.     return &data;

  905. }

  906. 

  907. const CarlaBackend::CustomData* carla_get_custom_data(unsigned int pluginId, uint32_t customDataId)

  908. {

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

  910.     CARLA_ASSERT(standalone.engine != nullptr);

  911. 

  912.     static CarlaBackend::CustomData data;

  913. 

  914.     if (standalone.engine == nullptr)

  915.         return &data;

  916. 

  917.     if (CarlaPlugin* const plugin = standalone.engine->getPlugin(pluginId))

  918.     {

  919.         if (customDataId < plugin->customDataCount())

  920.             return &plugin->customData(customDataId);

  921. 

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

  923.         return &data;

  924.     }

  925. 

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

  927.     return &data;

  928. }

  929. 

  930. const char* carla_get_chunk_data(unsigned int pluginId)

  931. {

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

  933.     CARLA_ASSERT(standalone.engine != nullptr);

  934. 

  935.     if (standalone.engine == nullptr)

  936.         return nullptr;

  937. 

  938.     static CarlaString chunkData;

  939. 

  940.     // cleanup

  941.     chunkData.clear();

  942. 

  943.     if (CarlaPlugin* const plugin = standalone.engine->getPlugin(pluginId))

  944.     {

  945.         if (plugin->options() & CarlaBackend::PLUGIN_OPTION_USE_CHUNKS)

  946.         {

  947.             void* data = nullptr;

  948.             const int32_t dataSize = plugin->chunkData(&data);

  949. 

  950.             if (data != nullptr && dataSize >= 4)

  951.             {

  952.                 chunkData.importBinaryAsBase64((const uint8_t*)data, static_cast<size_t>(dataSize));

  953.                 return (const char*)chunkData;

  954.             }

  955.             else

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

  957.         }

  958.         else

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

  960. 

  961.         return nullptr;

  962.     }

  963. 

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

  965.     return nullptr;

  966. }

  967. 

  968. // -------------------------------------------------------------------------------------------------------------------

  969. 

  970. uint32_t carla_get_parameter_count(unsigned int pluginId)

  971. {

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

  973.     CARLA_ASSERT(standalone.engine != nullptr);

  974. 

  975.     if (standalone.engine == nullptr)

  976.         return 0;

  977. 

  978.     if (CarlaPlugin* const plugin = standalone.engine->getPlugin(pluginId))

  979.         return plugin->parameterCount();

  980. 

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

  982.     return 0;

  983. }

  984. 

  985. uint32_t carla_get_program_count(unsigned int pluginId)

  986. {

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

  988.     CARLA_ASSERT(standalone.engine != nullptr);

  989. 

  990.     if (standalone.engine == nullptr)

  991.         return 0;

  992. 

  993.     if (CarlaPlugin* const plugin = standalone.engine->getPlugin(pluginId))

  994.         return plugin->programCount();

  995. 

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

  997.     return 0;

  998. }

  999. 

  1000. uint32_t carla_get_midi_program_count(unsigned int pluginId)

  1001. {

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

  1003.     CARLA_ASSERT(standalone.engine != nullptr);

  1004. 

  1005.     if (standalone.engine == nullptr)

  1006.         return 0;

  1007. 

  1008.     if (CarlaPlugin* const plugin = standalone.engine->getPlugin(pluginId))

  1009.         return plugin->midiProgramCount();

  1010. 

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

  1012.     return 0;

  1013. }

  1014. 

  1015. uint32_t carla_get_custom_data_count(unsigned int pluginId)

  1016. {

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

  1018.     CARLA_ASSERT(standalone.engine != nullptr);

  1019. 

  1020.     if (standalone.engine == nullptr)

  1021.         return 0;

  1022. 

  1023.     if (CarlaPlugin* const plugin = standalone.engine->getPlugin(pluginId))

  1024.         return plugin->customDataCount();

  1025. 

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

  1027.     return 0;

  1028. }

  1029. 

  1030. // -------------------------------------------------------------------------------------------------------------------

  1031. 

  1032. const char* carla_get_parameter_text(unsigned int pluginId, uint32_t parameterId)

  1033. {

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

  1035.     CARLA_ASSERT(standalone.engine != nullptr);

  1036. 

  1037.     if (standalone.engine == nullptr)

  1038.         return nullptr;

  1039. 

  1040.     static char textBuf[STR_MAX];

  1041.     carla_zeroMem(textBuf, sizeof(char)*STR_MAX);

  1042. 

  1043.     if (CarlaPlugin* const plugin = standalone.engine->getPlugin(pluginId))

  1044.     {

  1045.         if (parameterId < plugin->parameterCount())

  1046.         {

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

  1048.             return textBuf;

  1049.         }

  1050. 

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

  1052.         return nullptr;

  1053.     }

  1054. 

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

  1056.     return nullptr;

  1057. }

  1058. 

  1059. const char* carla_get_program_name(unsigned int pluginId, uint32_t programId)

  1060. {

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

  1062.     CARLA_ASSERT(standalone.engine != nullptr);

  1063. 

  1064.     if (standalone.engine == nullptr)

  1065.         return nullptr;

  1066. 

  1067.     static char programName[STR_MAX];

  1068.     carla_zeroMem(programName, sizeof(char)*STR_MAX);

  1069. 

  1070.     if (CarlaPlugin* const plugin = standalone.engine->getPlugin(pluginId))

  1071.     {

  1072.         if (programId < plugin->programCount())

  1073.         {

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

  1075. 

  1076.             return programName;

  1077.         }

  1078. 

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

  1080.         return nullptr;

  1081.     }

  1082. 

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

  1084.     return nullptr;

  1085. }

  1086. 

  1087. const char* carla_get_midi_program_name(unsigned int pluginId, uint32_t midiProgramId)

  1088. {

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

  1090.     CARLA_ASSERT(standalone.engine != nullptr);

  1091. 

  1092.     if (standalone.engine == nullptr)

  1093.         return nullptr;

  1094. 

  1095.     static char midiProgramName[STR_MAX];

  1096.     carla_zeroMem(midiProgramName, sizeof(char)*STR_MAX);

  1097. 

  1098.     if (CarlaPlugin* const plugin = standalone.engine->getPlugin(pluginId))

  1099.     {

  1100.         if (midiProgramId < plugin->midiProgramCount())

  1101.         {

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

  1103. 

  1104.             return midiProgramName;

  1105.         }

  1106. 

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

  1108.         return nullptr;

  1109.     }

  1110. 

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

  1112.     return nullptr;

  1113. }

  1114. 

  1115. const char* carla_get_real_plugin_name(unsigned int pluginId)

  1116. {

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

  1118.     CARLA_ASSERT(standalone.engine != nullptr);

  1119. 

  1120.     if (standalone.engine == nullptr)

  1121.         return nullptr;

  1122. 

  1123.     static char realPluginName[STR_MAX];

  1124.     carla_zeroMem(realPluginName, sizeof(char)*STR_MAX);

  1125. 

  1126.     if (CarlaPlugin* const plugin = standalone.engine->getPlugin(pluginId))

  1127.     {

  1128.         plugin->getRealName(realPluginName);

  1129. 

  1130.         return realPluginName;

  1131.     }

  1132. 

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

  1134.     return nullptr;

  1135. }

  1136. 

  1137. // -------------------------------------------------------------------------------------------------------------------

  1138. 

  1139. int32_t carla_get_current_program_index(unsigned int pluginId)

  1140. {

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

  1142.     CARLA_ASSERT(standalone.engine != nullptr);

  1143. 

  1144.     if (standalone.engine == nullptr)

  1145.         return -1;

  1146. 

  1147.     if (CarlaPlugin* const plugin = standalone.engine->getPlugin(pluginId))

  1148.         return plugin->currentProgram();

  1149. 

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

  1151.     return -1;

  1152. }

  1153. 

  1154. int32_t carla_get_current_midi_program_index(unsigned int pluginId)

  1155. {

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

  1157.     CARLA_ASSERT(standalone.engine != nullptr);

  1158. 

  1159.     if (standalone.engine == nullptr)

  1160.         return -1;

  1161. 

  1162.     if (CarlaPlugin* const plugin = standalone.engine->getPlugin(pluginId))

  1163.         return plugin->currentMidiProgram();

  1164. 

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

  1166.     return -1;

  1167. }

  1168. 

  1169. // -------------------------------------------------------------------------------------------------------------------

  1170. 

  1171. float carla_get_default_parameter_value(unsigned int pluginId, uint32_t parameterId)

  1172. {

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

  1174.     CARLA_ASSERT(standalone.engine != nullptr);

  1175. 

  1176.     if (standalone.engine == nullptr)

  1177.         return 0.0f;

  1178. 

  1179.     if (CarlaPlugin* const plugin = standalone.engine->getPlugin(pluginId))

  1180.     {

  1181.         if (parameterId < plugin->parameterCount())

  1182.             return plugin->parameterRanges(parameterId).def;

  1183. 

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

  1185.         return 0.0f;

  1186.     }

  1187. 

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

  1189.     return 0.0f;

  1190. }

  1191. 

  1192. float carla_get_current_parameter_value(unsigned int pluginId, uint32_t parameterId)

  1193. {

  1194.     carla_debug("carla_get_current_parameter_value(%i, %i)", pluginId, parameterId);

  1195.     CARLA_ASSERT(standalone.engine != nullptr);

  1196. 

  1197.     if (standalone.engine == nullptr)

  1198.         return 0.0f;

  1199. 

  1200.     if (CarlaPlugin* const plugin = standalone.engine->getPlugin(pluginId))

  1201.     {

  1202.         if (parameterId < plugin->parameterCount())

  1203.             return plugin->getParameterValue(parameterId);

  1204. 

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

  1206.         return 0.0f;

  1207.     }

  1208. 

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

  1210.     return 0.0f;

  1211. }

  1212. 

  1213. // -------------------------------------------------------------------------------------------------------------------

  1214. 

  1215. float carla_get_input_peak_value(unsigned int pluginId, unsigned short portId)

  1216. {

  1217.     CARLA_ASSERT(standalone.engine != nullptr);

  1218.     CARLA_ASSERT(portId == 1 || portId == 2);

  1219. 

  1220.     if (standalone.engine == nullptr)

  1221.         return 0.0f;

  1222. 

  1223.     if (pluginId >= standalone.engine->currentPluginCount())

  1224.     {

  1225.         carla_stderr2("carla_get_input_peak_value(%i, %i) - invalid plugin value", pluginId, portId);

  1226.         return 0.0f;

  1227.     }

  1228. 

  1229.     if (portId == 1 || portId == 2)

  1230.        return standalone.engine->getInputPeak(pluginId, portId);

  1231. 

  1232.     carla_stderr2("carla_get_input_peak_value(%i, %i) - invalid port value", pluginId, portId);

  1233.     return 0.0f;

  1234. }

  1235. 

  1236. float carla_get_output_peak_value(unsigned int pluginId, unsigned short portId)

  1237. {

  1238.     CARLA_ASSERT(standalone.engine != nullptr);

  1239.     CARLA_ASSERT(portId == 1 || portId == 2);

  1240. 

  1241.     if (standalone.engine == nullptr)

  1242.         return 0.0f;

  1243. 

  1244.     if (pluginId >= standalone.engine->currentPluginCount())

  1245.     {

  1246.         carla_stderr2("carla_get_input_peak_value(%i, %i) - invalid plugin value", pluginId, portId);

  1247.         return 0.0f;

  1248.     }

  1249. 

  1250.     if (portId == 1 || portId == 2)

  1251.        return standalone.engine->getOutputPeak(pluginId, portId);

  1252. 

  1253.     carla_stderr2("carla_get_output_peak_value(%i, %i) - invalid port value", pluginId, portId);

  1254.     return 0.0f;

  1255. }

  1256. 

  1257. // -------------------------------------------------------------------------------------------------------------------

  1258. 

  1259. void carla_set_option(unsigned int pluginId, unsigned int option, bool yesNo)

  1260. {

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

  1262.     CARLA_ASSERT(standalone.engine != nullptr);

  1263. 

  1264.     if (standalone.engine == nullptr)

  1265.         return;

  1266. 

  1267.     if (CarlaPlugin* const plugin = standalone.engine->getPlugin(pluginId))

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

  1269. 

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

  1271. }

  1272. 

  1273. void carla_set_active(unsigned int pluginId, bool onOff)

  1274. {

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

  1276.     CARLA_ASSERT(standalone.engine != nullptr);

  1277. 

  1278.     if (standalone.engine == nullptr)

  1279.         return;

  1280. 

  1281.     if (CarlaPlugin* const plugin = standalone.engine->getPlugin(pluginId))

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

  1283. 

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

  1285. }

  1286. 

  1287. void carla_set_drywet(unsigned int pluginId, float value)

  1288. {

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

  1290.     CARLA_ASSERT(standalone.engine != nullptr);

  1291. 

  1292.     if (standalone.engine == nullptr)

  1293.         return;

  1294. 

  1295.     if (CarlaPlugin* const plugin = standalone.engine->getPlugin(pluginId))

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

  1297. 

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

  1299. }

  1300. 

  1301. void carla_set_volume(unsigned int pluginId, float value)

  1302. {

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

  1304.     CARLA_ASSERT(standalone.engine != nullptr);

  1305. 

  1306.     if (standalone.engine == nullptr)

  1307.         return;

  1308. 

  1309.     if (CarlaPlugin* const plugin = standalone.engine->getPlugin(pluginId))

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

  1311. 

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

  1313. }

  1314. 

  1315. void carla_set_balance_left(unsigned int pluginId, float value)

  1316. {

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

  1318.     CARLA_ASSERT(standalone.engine != nullptr);

  1319. 

  1320.     if (standalone.engine == nullptr)

  1321.         return;

  1322. 

  1323.     if (CarlaPlugin* const plugin = standalone.engine->getPlugin(pluginId))

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

  1325. 

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

  1327. }

  1328. 

  1329. void carla_set_balance_right(unsigned int pluginId, float value)

  1330. {

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

  1332.     CARLA_ASSERT(standalone.engine != nullptr);

  1333. 

  1334.     if (standalone.engine == nullptr)

  1335.         return;

  1336. 

  1337.     if (CarlaPlugin* const plugin = standalone.engine->getPlugin(pluginId))

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

  1339. 

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

  1341. }

  1342. 

  1343. void carla_set_panning(unsigned int pluginId, float value)

  1344. {

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

  1346.     CARLA_ASSERT(standalone.engine != nullptr);

  1347. 

  1348.     if (standalone.engine == nullptr)

  1349.         return;

  1350. 

  1351.     if (CarlaPlugin* const plugin = standalone.engine->getPlugin(pluginId))

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

  1353. 

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

  1355. }

  1356. 

  1357. void carla_set_ctrl_channel(unsigned int pluginId, int8_t channel)

  1358. {

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

  1360.     CARLA_ASSERT(standalone.engine != nullptr);

  1361. 

  1362.     if (standalone.engine == nullptr)

  1363.         return;

  1364. 

  1365.     if (CarlaPlugin* const plugin = standalone.engine->getPlugin(pluginId))

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

  1367. 

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

  1369. }

  1370. 

  1371. // -------------------------------------------------------------------------------------------------------------------

  1372. 

  1373. void carla_set_parameter_value(unsigned int pluginId, uint32_t parameterId, float value)

  1374. {

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

  1376.     CARLA_ASSERT(standalone.engine != nullptr);

  1377. 

  1378.     if (standalone.engine == nullptr)

  1379.         return;

  1380. 

  1381.     if (CarlaPlugin* const plugin = standalone.engine->getPlugin(pluginId))

  1382.     {

  1383.         if (parameterId < plugin->parameterCount())

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

  1385. 

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

  1387.         return;

  1388.     }

  1389. 

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

  1391. }

  1392. 

  1393. void carla_set_parameter_midi_channel(unsigned int pluginId, uint32_t parameterId, uint8_t channel)

  1394. {

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

  1396.     CARLA_ASSERT(standalone.engine != nullptr);

  1397.     CARLA_ASSERT(channel < MAX_MIDI_CHANNELS);

  1398. 

  1399.     if (channel >= MAX_MIDI_CHANNELS)

  1400.     {

  1401.         carla_stderr2("carla_set_parameter_midi_channel(%i, %i, %i) - invalid channel number", pluginId, parameterId, channel);

  1402.         return;

  1403.     }

  1404. 

  1405.     if (standalone.engine == nullptr)

  1406.         return;

  1407. 

  1408.     if (CarlaPlugin* const plugin = standalone.engine->getPlugin(pluginId))

  1409.     {

  1410.         if (parameterId < plugin->parameterCount())

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

  1412. 

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

  1414.         return;

  1415.     }

  1416. 

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

  1418. }

  1419. 

  1420. void carla_set_parameter_midi_cc(unsigned int pluginId, uint32_t parameterId, int16_t cc)

  1421. {

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

  1423.     CARLA_ASSERT(standalone.engine != nullptr);

  1424.     CARLA_ASSERT(cc >= -1 && cc <= 0x5F);

  1425. 

  1426.     if (cc < -1)

  1427.     {

  1428.         cc = -1;

  1429.     }

  1430.     else if (cc > 0x5F) // 95

  1431.     {

  1432.         carla_stderr2("carla_set_parameter_midi_cc(%i, %i, %i) - invalid cc number", pluginId, parameterId, cc);

  1433.         return;

  1434.     }

  1435. 

  1436.     if (standalone.engine == nullptr)

  1437.         return;

  1438. 

  1439.     if (CarlaPlugin* const plugin = standalone.engine->getPlugin(pluginId))

  1440.     {

  1441.         if (parameterId < plugin->parameterCount())

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

  1443. 

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

  1445.         return;

  1446.     }

  1447. 

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

  1449. }

  1450. 

  1451. void carla_set_program(unsigned int pluginId, uint32_t programId)

  1452. {

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

  1454.     CARLA_ASSERT(standalone.engine != nullptr);

  1455. 

  1456.     if (standalone.engine == nullptr)

  1457.         return;

  1458. 

  1459.     if (CarlaPlugin* const plugin = standalone.engine->getPlugin(pluginId))

  1460.     {

  1461.         if (programId < plugin->programCount())

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

  1463. 

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

  1465.         return;

  1466.     }

  1467. 

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

  1469. }

  1470. 

  1471. void carla_set_midi_program(unsigned int pluginId, uint32_t midiProgramId)

  1472. {

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

  1474.     CARLA_ASSERT(standalone.engine != nullptr);

  1475. 

  1476.     if (standalone.engine == nullptr)

  1477.         return;

  1478. 

  1479.     if (CarlaPlugin* const plugin = standalone.engine->getPlugin(pluginId))

  1480.     {

  1481.         if (midiProgramId < plugin->midiProgramCount())

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

  1483. 

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

  1485.         return;

  1486.     }

  1487. 

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

  1489. }

  1490. 

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

  1492. 

  1493. void carla_set_custom_data(unsigned int pluginId, const char* type, const char* key, const char* value)

  1494. {

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

  1496.     CARLA_ASSERT(standalone.engine != nullptr);

  1497. 

  1498.     if (standalone.engine == nullptr)

  1499.         return;

  1500. 

  1501.     if (CarlaPlugin* const plugin = standalone.engine->getPlugin(pluginId))

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

  1503. 

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

  1505. }

  1506. 

  1507. void carla_set_chunk_data(unsigned int pluginId, const char* chunkData)

  1508. {

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

  1510.     CARLA_ASSERT(standalone.engine != nullptr);

  1511. 

  1512.     if (standalone.engine == nullptr)

  1513.         return;

  1514. 

  1515.     if (CarlaPlugin* const plugin = standalone.engine->getPlugin(pluginId))

  1516.     {

  1517.         if (plugin->options() & CarlaBackend::PLUGIN_OPTION_USE_CHUNKS)

  1518.             return plugin->setChunkData(chunkData);

  1519. 

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

  1521.         return;

  1522.     }

  1523. 

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

  1525. }

  1526. 

  1527. // -------------------------------------------------------------------------------------------------------------------

  1528. 

  1529. void carla_prepare_for_save(unsigned int pluginId)

  1530. {

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

  1532.     CARLA_ASSERT(standalone.engine != nullptr);

  1533. 

  1534.     if (standalone.engine == nullptr)

  1535.         return;

  1536. 

  1537.     if (CarlaPlugin* const plugin = standalone.engine->getPlugin(pluginId))

  1538.         return plugin->prepareForSave();

  1539. 

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

  1541. }

  1542. 

  1543. void carla_send_midi_note(unsigned int pluginId, uint8_t channel, uint8_t note, uint8_t velocity)

  1544. {

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

  1546.     CARLA_ASSERT(standalone.engine != nullptr);

  1547. 

  1548.     if (standalone.engine == nullptr || ! standalone.engine->isRunning())

  1549.         return;

  1550. 

  1551.     if (CarlaPlugin* const plugin = standalone.engine->getPlugin(pluginId))

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

  1553. 

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

  1555. }

  1556. 

  1557. void carla_show_gui(unsigned int pluginId, bool yesno)

  1558. {

  1559.     carla_debug("carla_show_gui(%i, %s)", pluginId, bool2str(yesno));

  1560.     CARLA_ASSERT(standalone.engine != nullptr);

  1561. 

  1562.     if (standalone.engine == nullptr)

  1563.         return;

  1564. 

  1565.     if (CarlaPlugin* const plugin = standalone.engine->getPlugin(pluginId))

  1566.         return plugin->showGui(yesno);

  1567. 

  1568.     carla_stderr2("carla_show_gui(%i, %s) - could not find plugin", pluginId, bool2str(yesno));

  1569. }

  1570. 

  1571. // -------------------------------------------------------------------------------------------------------------------

  1572. 

  1573. uint32_t carla_get_buffer_size()

  1574. {

  1575.     carla_debug("carla_get_buffer_size()");

  1576.     CARLA_ASSERT(standalone.engine != nullptr);

  1577. 

  1578.     if (standalone.engine == nullptr)

  1579.         return 0;

  1580. 

  1581.     return standalone.engine->getBufferSize();

  1582. }

  1583. 

  1584. double carla_get_sample_rate()

  1585. {

  1586.     carla_debug("carla_get_sample_rate()");

  1587.     CARLA_ASSERT(standalone.engine != nullptr);

  1588. 

  1589.     if (standalone.engine == nullptr)

  1590.         return 0.0;

  1591. 

  1592.     return standalone.engine->getSampleRate();

  1593. }

  1594. 

  1595. // -------------------------------------------------------------------------------------------------------------------

  1596. 

  1597. const char* carla_get_last_error()

  1598. {

  1599.     carla_debug("carla_get_last_error()");

  1600. 

  1601.     if (standalone.engine != nullptr)

  1602.         return standalone.engine->getLastError();

  1603. 

  1604.     return standalone.lastError;

  1605. }

  1606. 

  1607. const char* carla_get_host_osc_url()

  1608. {

  1609.     carla_debug("carla_get_host_osc_url()");

  1610.     CARLA_ASSERT(standalone.engine != nullptr);

  1611. 

  1612.     if (standalone.engine == nullptr)

  1613.         return nullptr;

  1614. 

  1615.     return standalone.engine->getOscServerPathTCP();

  1616. }

  1617. 

  1618. #if 0

  1619. // -------------------------------------------------------------------------------------------------------------------

  1620. 

  1621. #define NSM_API_VERSION_MAJOR 1

  1622. #define NSM_API_VERSION_MINOR 0

  1623. 

  1624. class CarlaNSM

  1625. {

  1626. public:

  1627.     CarlaNSM()

  1628.     {

  1629.         m_controlAddr = nullptr;

  1630.         m_serverThread = nullptr;

  1631.         m_isOpened = false;

  1632.         m_isSaved  = false;

  1633.     }

  1634. 

  1635.     ~CarlaNSM()

  1636.     {

  1637.         if (m_controlAddr)

  1638.             lo_address_free(m_controlAddr);

  1639. 

  1640.         if (m_serverThread)

  1641.         {

  1642.             lo_server_thread_stop(m_serverThread);

  1643.             lo_server_thread_del_method(m_serverThread, "/reply", "ssss");

  1644.             lo_server_thread_del_method(m_serverThread, "/nsm/client/open", "sss");

  1645.             lo_server_thread_del_method(m_serverThread, "/nsm/client/save", "");

  1646.             lo_server_thread_free(m_serverThread);

  1647.         }

  1648.     }

  1649. 

  1650.     void announce(const char* const url, const int pid)

  1651.     {

  1652.         lo_address addr = lo_address_new_from_url(url);

  1653.         int proto = lo_address_get_protocol(addr);

  1654. 

  1655.         if (! m_serverThread)

  1656.         {

  1657.             // create new OSC thread

  1658.             m_serverThread = lo_server_thread_new_with_proto(nullptr, proto, error_handler);

  1659. 

  1660.             // register message handlers and start OSC thread

  1661.             lo_server_thread_add_method(m_serverThread, "/reply", "ssss", _reply_handler, this);

  1662.             lo_server_thread_add_method(m_serverThread, "/nsm/client/open", "sss", _nsm_open_handler, this);

  1663.             lo_server_thread_add_method(m_serverThread, "/nsm/client/save", "", _nsm_save_handler, this);

  1664.             lo_server_thread_start(m_serverThread);

  1665.         }

  1666. 

  1667.         lo_send_from(addr, lo_server_thread_get_server(m_serverThread), LO_TT_IMMEDIATE, "/nsm/server/announce", "sssiii",

  1668.                      "Carla", ":switch:", "carla", NSM_API_VERSION_MAJOR, NSM_API_VERSION_MINOR, pid);

  1669. 

  1670.         lo_address_free(addr);

  1671.     }

  1672. 

  1673.     void replyOpen()

  1674.     {

  1675.         m_isOpened = true;

  1676.     }

  1677. 

  1678.     void replySave()

  1679.     {

  1680.         m_isSaved = true;

  1681.     }

  1682. 

  1683. protected:

  1684.     int reply_handler(const char* const path, const char* const types, lo_arg** const argv, const int argc, const lo_message msg)

  1685.     {

  1686.         carla_debug("CarlaNSM::reply_handler(%s, %i, %p, %s, %p)", path, argc, argv, types, msg);

  1687. 

  1688.         m_controlAddr = lo_address_new_from_url(lo_address_get_url(lo_message_get_source(msg)));

  1689. 

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

  1691. 

  1692.         if (std::strcmp(method, "/nsm/server/announce") == 0 && standalone.callback)

  1693.             standalone.callback(nullptr, CarlaBackend::CALLBACK_NSM_ANNOUNCE, 0, 0, 0, 0.0, nullptr); // FIXME?

  1694. 

  1695.         return 0;

  1696.     }

  1697. 

  1698.     int nsm_open_handler(const char* const path, const char* const types, lo_arg** const argv, const int argc, const lo_message msg)

  1699.     {

  1700.         carla_debug("CarlaNSM::nsm_open_handler(\"%s\", \"%s\", %p, %i, %p)", path, types, argv, argc, msg);

  1701. 

  1702.         if (! standalone.callback)

  1703.             return 1;

  1704. 

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

  1706.         const char* const clientId    = &argv[2]->s;

  1707. 

  1708.         standalone.callback(nullptr, CarlaBackend::CALLBACK_NSM_OPEN1, 0, 0, 0, 0.0, clientId);

  1709.         standalone.callback(nullptr, CarlaBackend::CALLBACK_NSM_OPEN2, 0, 0, 0, 0.0, projectPath);

  1710. 

  1711.         for (int i=0; i < 30 && ! m_isOpened; i++)

  1712.             carla_msleep(100);

  1713. 

  1714.         if (m_controlAddr)

  1715.             lo_send_from(m_controlAddr, lo_server_thread_get_server(m_serverThread), LO_TT_IMMEDIATE, "/reply", "ss", "/nsm/client/open", "OK");

  1716. 

  1717.         return 0;

  1718.     }

  1719. 

  1720.     int nsm_save_handler(const char* const path, const char* const types, lo_arg** const argv, const int argc, const lo_message msg)

  1721.     {

  1722.         carla_debug("CarlaNSM::nsm_save_handler(\"%s\", \"%s\", %p, %i, %p)", path, types, argv, argc, msg);

  1723. 

  1724.         if (! standalone.callback)

  1725.             return 1;

  1726. 

  1727.         standalone.callback(nullptr, CarlaBackend::CALLBACK_NSM_SAVE, 0, 0, 0, 0.0, nullptr);

  1728. 

  1729.         for (int i=0; i < 30 && ! m_isSaved; i++)

  1730.             carla_msleep(100);

  1731. 

  1732.         if (m_controlAddr)

  1733.             lo_send_from(m_controlAddr, lo_server_thread_get_server(m_serverThread), LO_TT_IMMEDIATE, "/reply", "ss", "/nsm/client/save", "OK");

  1734. 

  1735.         return 0;

  1736.     }

  1737. 

  1738. private:

  1739.     lo_address m_controlAddr;

  1740.     lo_server_thread m_serverThread;

  1741.     bool m_isOpened, m_isSaved;

  1742. 

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

  1744.     {

  1745.         CARLA_ASSERT(data);

  1746.         CarlaNSM* const _this_ = (CarlaNSM*)data;

  1747.         return _this_->reply_handler(path, types, argv, argc, msg);

  1748.     }

  1749. 

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

  1751.     {

  1752.         CARLA_ASSERT(data);

  1753.         CarlaNSM* const _this_ = (CarlaNSM*)data;

  1754.         return _this_->nsm_open_handler(path, types, argv, argc, msg);

  1755.     }

  1756. 

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

  1758.     {

  1759.         CARLA_ASSERT(data);

  1760.         CarlaNSM* const _this_ = (CarlaNSM*)data;

  1761.         return _this_->nsm_save_handler(path, types, argv, argc, msg);

  1762.     }

  1763. 

  1764.     static void error_handler(const int num, const char* const msg, const char* const path)

  1765.     {

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

  1767.     }

  1768. };

  1769. 

  1770. static CarlaNSM carlaNSM;

  1771. 

  1772. void carla_nsm_announce(const char* url, int pid)

  1773. {

  1774.     carlaNSM.announce(url, pid);

  1775. }

  1776. 

  1777. void carla_nsm_reply_open()

  1778. {

  1779.     carlaNSM.replyOpen();

  1780. }

  1781. 

  1782. void carla_nsm_reply_save()

  1783. {

  1784.     carlaNSM.replySave();

  1785. }

  1786. 

  1787. #endif

  1788. 

  1789. // -------------------------------------------------------------------------------------------------------------------

  1790. 

  1791. #if 0

  1792. //def QTCREATOR_TEST

  1793. 

  1794. #include <QtGui/QApplication>

  1795. #include <QtGui/QDialog>

  1796. 

  1797. QDialog* vstGui = nullptr;

  1798. 

  1799. void main_callback(void* ptr, CarlaBackend::CallbackType action, unsigned int pluginId, int value1, int value2, double value3)

  1800. {

  1801.     switch (action)

  1802.     {

  1803.     case CarlaBackend::CALLBACK_SHOW_GUI:

  1804.         if (vstGui && ! value1)

  1805.             vstGui->close();

  1806.         break;

  1807.     case CarlaBackend::CALLBACK_RESIZE_GUI:

  1808.         vstGui->setFixedSize(value1, value2);

  1809.         break;

  1810.     default:

  1811.         break;

  1812.     }

  1813. 

  1814.     Q_UNUSED(ptr);

  1815.     Q_UNUSED(pluginId);

  1816.     Q_UNUSED(value3);

  1817. }

  1818. 

  1819. void run_tests_standalone(short idMax)

  1820. {

  1821.     for (short id = 0; id <= idMax; id++)

  1822.     {

  1823.         carla_debug("------------------- TEST @%i: non-parameter calls --------------------", id);

  1824.         get_plugin_info(id);

  1825.         get_audio_port_count_info(id);

  1826.         get_midi_port_count_info(id);

  1827.         get_parameter_count_info(id);

  1828.         get_gui_info(id);

  1829.         get_chunk_data(id);

  1830.         get_parameter_count(id);

  1831.         get_program_count(id);

  1832.         get_midi_program_count(id);

  1833.         get_custom_data_count(id);

  1834.         get_real_plugin_name(id);

  1835.         get_current_program_index(id);

  1836.         get_current_midi_program_index(id);

  1837. 

  1838.         carla_debug("------------------- TEST @%i: parameter calls [-1] --------------------", id);

  1839.         get_parameter_info(id, -1);

  1840.         get_parameter_scalepoint_info(id, -1, -1);

  1841.         get_parameter_data(id, -1);

  1842.         get_parameter_ranges(id, -1);

  1843.         get_midi_program_data(id, -1);

  1844.         get_custom_data(id, -1);

  1845.         get_parameter_text(id, -1);

  1846.         get_program_name(id, -1);

  1847.         get_midi_program_name(id, -1);

  1848.         get_default_parameter_value(id, -1);

  1849.         get_current_parameter_value(id, -1);

  1850.         get_input_peak_value(id, -1);

  1851.         get_output_peak_value(id, -1);

  1852. 

  1853.         carla_debug("------------------- TEST @%i: parameter calls [0] --------------------", id);

  1854.         get_parameter_info(id, 0);

  1855.         get_parameter_scalepoint_info(id, 0, -1);

  1856.         get_parameter_scalepoint_info(id, 0, 0);

  1857.         get_parameter_data(id, 0);

  1858.         get_parameter_ranges(id, 0);

  1859.         get_midi_program_data(id, 0);

  1860.         get_custom_data(id, 0);

  1861.         get_parameter_text(id, 0);

  1862.         get_program_name(id, 0);

  1863.         get_midi_program_name(id, 0);

  1864.         get_default_parameter_value(id, 0);

  1865.         get_current_parameter_value(id, 0);

  1866.         get_input_peak_value(id, 0);

  1867.         get_input_peak_value(id, 1);

  1868.         get_input_peak_value(id, 2);

  1869.         get_output_peak_value(id, 0);

  1870.         get_output_peak_value(id, 1);

  1871.         get_output_peak_value(id, 2);

  1872. 

  1873.         carla_debug("------------------- TEST @%i: set extra data --------------------", id);

  1874.         set_custom_data(id, CarlaBackend::CUSTOM_DATA_STRING, "", "");

  1875.         set_chunk_data(id, nullptr);

  1876.         set_gui_container(id, (uintptr_t)1);

  1877. 

  1878.         carla_debug("------------------- TEST @%i: gui stuff --------------------", id);

  1879.         show_gui(id, false);

  1880.         show_gui(id, true);

  1881.         show_gui(id, true);

  1882. 

  1883.         idle_guis();

  1884.         idle_guis();

  1885.         idle_guis();

  1886. 

  1887.         carla_debug("------------------- TEST @%i: other --------------------", id);

  1888.         send_midi_note(id, 15,  127,  127);

  1889.         send_midi_note(id,  0,  0,  0);

  1890. 

  1891.         prepare_for_save(id);

  1892.         prepare_for_save(id);

  1893.         prepare_for_save(id);

  1894.     }

  1895. }

  1896. 

  1897. int main(int argc, char* argv[])

  1898. {

  1899.     using namespace CarlaBackend;

  1900. 

  1901.     // Qt app

  1902.     QApplication app(argc, argv);

  1903. 

  1904.     // Qt gui (for vst)

  1905.     vstGui = new QDialog(nullptr);

  1906. 

  1907.     // set callback and options

  1908.     set_callback_function(main_callback);

  1909.     set_option(OPTION_PREFER_UI_BRIDGES, 0, nullptr);

  1910.     //set_option(OPTION_PROCESS_MODE, PROCESS_MODE_CONTINUOUS_RACK, nullptr);

  1911. 

  1912.     // start engine

  1913.     if (! engine_init("JACK", "carla_demo"))

  1914.     {

  1915.         carla_stderr2("failed to start backend engine, reason:\n%s", get_last_error());

  1916.         delete vstGui;

  1917.         return 1;

  1918.     }

  1919. 

  1920.     short id_ladspa = add_plugin(BINARY_NATIVE, PLUGIN_LADSPA, "/usr/lib/ladspa/LEET_eqbw2x2.so", "LADSPA plug name, test long name - "

  1921.                                  "------- name ------------ name2 ----------- name3 ------------ name4 ------------ name5 ---------- name6", "leet_equalizer_bw2x2", nullptr);

  1922. 

  1923.     short id_dssi   = add_plugin(BINARY_NATIVE, PLUGIN_DSSI, "/usr/lib/dssi/fluidsynth-dssi.so", "DSSI pname, short-utf8 _ \xAE", "FluidSynth-DSSI", (void*)"/usr/lib/dssi/fluidsynth-dssi/FluidSynth-DSSI_gtk");

  1924.     short id_native = add_plugin(BINARY_NATIVE, PLUGIN_INTERNAL, "", "ZynHere", "zynaddsubfx", nullptr);

  1925. 

  1926.     //short id_lv2 = add_plugin(BINARY_NATIVE, PLUGIN_LV2, "FILENAME", "HAHA name!!!", "http://studionumbersix.com/foo/lv2/yc20", nullptr);

  1927. 

  1928.     //short id_vst = add_plugin(BINARY_NATIVE, PLUGIN_LV2, "FILENAME", "HAHA name!!!", "http://studionumbersix.com/foo/lv2/yc20", nullptr);

  1929. 

  1930.     if (id_ladspa < 0 || id_dssi < 0 || id_native < 0)

  1931.     {

  1932.         carla_stderr2("failed to start load plugins, reason:\n%s", get_last_error());

  1933.         delete vstGui;

  1934.         return 1;

  1935.     }

  1936. 

  1937.     //const GuiInfo* const guiInfo = get_gui_info(id);

  1938.     //if (guiInfo->type == CarlaBackend::GUI_INTERNAL_QT4 || guiInfo->type == CarlaBackend::GUI_INTERNAL_X11)

  1939.     //{

  1940.     //    set_gui_data(id, 0, (uintptr_t)gui);

  1941.     //gui->show();

  1942.     //}

  1943. 

  1944.     // activate

  1945.     set_active(id_ladspa, true);

  1946.     set_active(id_dssi, true);

  1947.     set_active(id_native, true);

  1948. 

  1949.     // start guis

  1950.     show_gui(id_dssi, true);

  1951.     carla_sleep(1);

  1952. 

  1953.     // do tests

  1954.     run_tests_standalone(id_dssi+1);

  1955. 

  1956.     // lock

  1957.     app.exec();

  1958. 

  1959.     delete vstGui;

  1960.     vstGui = nullptr;

  1961. 

  1962.     remove_plugin(id_ladspa);

  1963.     remove_plugin(id_dssi);

  1964.     remove_plugin(id_native);

  1965.     engine_close();

  1966. 

  1967.     return 0;

  1968. }

  1969. 

  1970. #endif