falkTX
/
Cadence
mirror of https://github.com/falkTX/Cadence
1
0
Fork 0
Code Releases 3 Activity
Collection of tools useful for audio production
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.
838 Commits
2 Branches
42MB
Tree: b0e2ea16dd
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'b0e2ea16dd'
${ noResults }
Cadence/c++/carla-backend/carla_backend_standalone.cpp

1949 lines
62KB
Raw Blame History 

  1. /*

  2.  * Carla Backend

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

  4.  *

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

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

  7.  * the Free Software Foundation; either version 2 of the License, or

  8.  * 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 COPYING file

  16.  */

  17. 

  18. #include "carla_backend_standalone.hpp"

  19. #include "carla_plugin.hpp"

  20. #include "carla_native.h"

  21. 

  22. // -------------------------------------------------------------------------------------------------------------------

  23. 

  24. // Single, standalone engine

  25. struct CarlaBackendStandalone {

  26.     CarlaBackend::CarlaEngineOptions options;

  27.     CarlaBackend::CarlaEngine* engine;

  28.     CarlaBackend::CallbackFunc callback;

  29.     CarlaString lastError;

  30.     CarlaString procName;

  31.     bool started;

  32. 

  33.     CarlaBackendStandalone()

  34.         : engine(nullptr),

  35.           callback(nullptr),

  36.           started(false) {}

  37. 

  38. } standalone;

  39. 

  40. // -------------------------------------------------------------------------------------------------------------------

  41. 

  42. const char* get_extended_license_text()

  43. {

  44.     qDebug("CarlaBackendStandalone::get_extended_license_text()");

  45. 

  46.     static CarlaString extendedLicenseText;

  47. 

  48.     if (extendedLicenseText.isEmpty())

  49.     {

  50.         QString text("<p>This current Carla build is using the following features and 3rd-party code:</p>");

  51.         text += "<ul>";

  52. #ifdef WANT_LADSPA

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

  54. #endif

  55. #ifdef WANT_DSSI

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

  57. #endif

  58. #ifdef WANT_LV2

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

  60. #endif

  61. #ifdef WANT_VST

  62. # ifdef VESTIGE_HEADER

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

  64. # else

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

  66. # endif

  67. #endif

  68. #ifdef WANT_ZYNADDSUBFX

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

  70. #endif

  71. #ifdef WANT_FLUIDSYNTH

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

  73. #endif

  74. #ifdef WANT_LINUXSAMPLER

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

  76. #endif

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

  78. #ifdef WANT_LV2

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

  80. #endif

  81. #ifdef CARLA_ENGINE_RTAUDIO

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

  83. #endif

  84.         text += "</ul>";

  85. 

  86. #ifdef WANT_LINUXSAMPLER

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

  88. #endif

  89. 

  90.         extendedLicenseText = text.toUtf8().constData();

  91.     }

  92. 

  93.     return extendedLicenseText;

  94. }

  95. 

  96. unsigned int get_engine_driver_count()

  97. {

  98.     qDebug("CarlaBackendStandalone::get_engine_driver_count()");

  99. 

  100.     return CarlaBackend::CarlaEngine::getDriverCount();

  101. }

  102. 

  103. const char* get_engine_driver_name(unsigned int index)

  104. {

  105.     qDebug("CarlaBackendStandalone::get_engine_driver_name(%i)", index);

  106. 

  107.     return CarlaBackend::CarlaEngine::getDriverName(index);

  108. }

  109. 

  110. // -------------------------------------------------------------------------------------------------------------------

  111. 

  112. unsigned int get_internal_plugin_count()

  113. {

  114.     qDebug("CarlaBackendStandalone::get_internal_plugin_count()");

  115. 

  116.     return CarlaBackend::CarlaPlugin::getNativePluginCount();

  117. }

  118. 

  119. const PluginInfo* get_internal_plugin_info(unsigned int pluginId)

  120. {

  121.     qDebug("CarlaBackendStandalone::get_internal_plugin_info(%i)", pluginId);

  122. 

  123.     static PluginInfo info;

  124. 

  125.     const PluginDescriptor* const nativePlugin = CarlaBackend::CarlaPlugin::getNativePluginDescriptor(pluginId);

  126. 

  127.     CARLA_ASSERT(nativePlugin);

  128. 

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

  130.     if (! nativePlugin)

  131.         return nullptr;

  132. 

  133.      info.type      = CarlaBackend::PLUGIN_INTERNAL;

  134.      info.category  = static_cast<CarlaBackend::PluginCategory>(nativePlugin->category);

  135.      info.hints     = 0x0;

  136.      info.name      = nativePlugin->name;

  137.      info.label     = nativePlugin->label;

  138.      info.maker     = nativePlugin->maker;

  139.      info.copyright = nativePlugin->copyright;

  140. 

  141.      if (nativePlugin->hints & PLUGIN_IS_SYNTH)

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

  143.      if (nativePlugin->hints & PLUGIN_HAS_GUI)

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

  145.      if (nativePlugin->hints & PLUGIN_USES_SINGLE_THREAD)

  146.          info.hints |= CarlaBackend::PLUGIN_USES_SINGLE_THREAD;

  147. 

  148.     return &info;

  149. }

  150. 

  151. // -------------------------------------------------------------------------------------------------------------------

  152. 

  153. bool engine_init(const char* driverName, const char* clientName)

  154. {

  155.     qDebug("CarlaBackendStandalone::engine_init(\"%s\", \"%s\")", driverName, clientName);

  156.     CARLA_ASSERT(! standalone.engine);

  157. 

  158.     standalone.engine = CarlaBackend::CarlaEngine::newDriverByName(driverName);

  159. 

  160.     if (! standalone.engine)

  161.     {

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

  163.         return false;

  164.     }

  165. 

  166. #ifndef Q_OS_WIN

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

  168.     if (! getenv("WINE_RT"))

  169.     {

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

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

  172.     }

  173. #endif

  174. 

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

  176. 

  177.     standalone.engine->setOption(CarlaBackend::OPTION_PROCESS_MODE,            standalone.options.processMode,          nullptr);

  178.     standalone.engine->setOption(CarlaBackend::OPTION_PROCESS_HIGH_PRECISION,  standalone.options.processHighPrecision, nullptr);

  179.     standalone.engine->setOption(CarlaBackend::OPTION_MAX_PARAMETERS,          standalone.options.maxParameters,        nullptr);

  180.     standalone.engine->setOption(CarlaBackend::OPTION_PREFERRED_BUFFER_SIZE,   standalone.options.preferredBufferSize,  nullptr);

  181.     standalone.engine->setOption(CarlaBackend::OPTION_PREFERRED_SAMPLE_RATE,   standalone.options.preferredSampleRate,  nullptr);

  182.     standalone.engine->setOption(CarlaBackend::OPTION_FORCE_STEREO,            standalone.options.forceStereo,          nullptr);

  183.     standalone.engine->setOption(CarlaBackend::OPTION_USE_DSSI_VST_CHUNKS,     standalone.options.useDssiVstChunks,     nullptr);

  184.     standalone.engine->setOption(CarlaBackend::OPTION_PREFER_PLUGIN_BRIDGES,   standalone.options.preferPluginBridges,  nullptr);

  185.     standalone.engine->setOption(CarlaBackend::OPTION_PREFER_UI_BRIDGES,       standalone.options.preferUiBridges,      nullptr);

  186.     standalone.engine->setOption(CarlaBackend::OPTION_OSC_UI_TIMEOUT,          standalone.options.oscUiTimeout,         nullptr);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  201. 

  202.     if (standalone.procName.isNotEmpty())

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

  204. 

  205.     standalone.started = standalone.engine->init(clientName);

  206. 

  207.     if (standalone.started)

  208.     {

  209.         standalone.lastError = "no error";

  210.     }

  211.     else if (standalone.engine)

  212.     {

  213.         delete standalone.engine;

  214.         standalone.engine = nullptr;

  215.     }

  216. 

  217.     return standalone.started;

  218. }

  219. 

  220. bool engine_close()

  221. {

  222.     qDebug("CarlaBackendStandalone::engine_close()");

  223.     CARLA_ASSERT(standalone.engine);

  224. 

  225.     if (! standalone.engine)

  226.     {

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

  228.         return false;

  229.     }

  230. 

  231.     standalone.engine->aboutToClose();

  232.     standalone.engine->removeAllPlugins();

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

  234. 

  235.     standalone.started = false;

  236. 

  237.     // cleanup static data

  238.     get_plugin_info(0);

  239.     get_parameter_info(0, 0);

  240.     get_parameter_scalepoint_info(0, 0, 0);

  241.     get_chunk_data(0);

  242.     get_program_name(0, 0);

  243.     get_midi_program_name(0, 0);

  244.     get_real_plugin_name(0);

  245. 

  246.     delete standalone.engine;

  247.     standalone.engine = nullptr;

  248. 

  249.     return closed;

  250. }

  251. 

  252. bool is_engine_running()

  253. {

  254.     qDebug("CarlaBackendStandalone::is_engine_running()");

  255. 

  256.     return standalone.engine && standalone.engine->isRunning();

  257. }

  258. 

  259. // -------------------------------------------------------------------------------------------------------------------

  260. 

  261. short add_plugin(CarlaBackend::BinaryType btype, CarlaBackend::PluginType ptype, const char* filename, const char* const name, const char* label, void* extraStuff)

  262. {

  263.     qDebug("CarlaBackendStandalone::add_plugin(%s, %s, \"%s\", \"%s\", \"%s\", %p)", CarlaBackend::BinaryType2Str(btype), CarlaBackend::PluginType2Str(ptype), filename, name, label, extraStuff);

  264.     CARLA_ASSERT(standalone.engine);

  265. 

  266.     if (btype != CarlaBackend::BINARY_NATIVE && ! extraStuff)

  267.     {

  268.         switch (btype)

  269.         {

  270.         case CarlaBackend::BINARY_NONE:

  271.         case CarlaBackend::BINARY_OTHER:

  272.             break;

  273.         case CarlaBackend::BINARY_POSIX32:

  274.             extraStuff = (void*)(const char*)standalone.options.bridge_posix32;

  275.             break;

  276.         case CarlaBackend::BINARY_POSIX64:

  277.             extraStuff = (void*)(const char*)standalone.options.bridge_posix64;

  278.             break;

  279.         case CarlaBackend::BINARY_WIN32:

  280.             extraStuff = (void*)(const char*)standalone.options.bridge_win32;

  281.             break;

  282.         case CarlaBackend::BINARY_WIN64:

  283.             extraStuff = (void*)(const char*)standalone.options.bridge_win64;

  284.             break;

  285.         }

  286.     }

  287. 

  288.     if (standalone.engine && standalone.engine->isRunning())

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

  290. 

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

  292.     return -1;

  293. }

  294. 

  295. bool remove_plugin(unsigned short pluginId)

  296. {

  297.     qDebug("CarlaBackendStandalone::remove_plugin(%i)", pluginId);

  298.     CARLA_ASSERT(standalone.engine);

  299. 

  300.     if (standalone.engine)

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

  302. 

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

  304.     return false;

  305. }

  306. 

  307. // -------------------------------------------------------------------------------------------------------------------

  308. 

  309. const PluginInfo* get_plugin_info(unsigned short pluginId)

  310. {

  311.     qDebug("CarlaBackendStandalone::get_plugin_info(%i)", pluginId);

  312.     CARLA_ASSERT(standalone.engine);

  313. 

  314.     static PluginInfo info;

  315. 

  316.     // reset

  317.     info.type     = CarlaBackend::PLUGIN_NONE;

  318.     info.category = CarlaBackend::PLUGIN_CATEGORY_NONE;

  319.     info.hints    = 0x0;

  320.     info.binary   = nullptr;

  321.     info.name     = nullptr;

  322.     info.uniqueId = 0;

  323. 

  324.     // cleanup

  325.     if (info.label)

  326.     {

  327.         free((void*)info.label);

  328.         info.label = nullptr;

  329.     }

  330. 

  331.     if (info.maker)

  332.     {

  333.         free((void*)info.maker);

  334.         info.maker = nullptr;

  335.     }

  336. 

  337.     if (info.copyright)

  338.     {

  339.         free((void*)info.copyright);

  340.         info.copyright = nullptr;

  341.     }

  342. 

  343.     if (! standalone.engine)

  344.         return &info;

  345. 

  346.     if (! standalone.started)

  347.         return nullptr;

  348. 

  349.     CarlaBackend::CarlaPlugin* const plugin = standalone.engine->getPlugin(pluginId);

  350. 

  351.     if (plugin)

  352.     {

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

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

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

  356. 

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

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

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

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

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

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

  363. 

  364.         plugin->getLabel(strBufLabel);

  365.         info.label = strdup(strBufLabel);

  366. 

  367.         plugin->getMaker(strBufMaker);

  368.         info.maker = strdup(strBufMaker);

  369. 

  370.         plugin->getCopyright(strBufCopyright);

  371.         info.copyright = strdup(strBufCopyright);

  372. 

  373.         return &info;

  374.     }

  375. 

  376.     qCritical("CarlaBackendStandalone::get_plugin_info(%i) - could not find plugin", pluginId);

  377.     return &info;

  378. }

  379. 

  380. const PortCountInfo* get_audio_port_count_info(unsigned short pluginId)

  381. {

  382.     qDebug("CarlaBackendStandalone::get_audio_port_count_info(%i)", pluginId);

  383.     CARLA_ASSERT(standalone.engine);

  384. 

  385.     static PortCountInfo info;

  386. 

  387.     // reset

  388.     info.ins   = 0;

  389.     info.outs  = 0;

  390.     info.total = 0;

  391. 

  392.     if (! standalone.engine)

  393.         return &info;

  394. 

  395.     CarlaBackend::CarlaPlugin* const plugin = standalone.engine->getPlugin(pluginId);

  396. 

  397.     if (plugin)

  398.     {

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

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

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

  402.         return &info;

  403.     }

  404. 

  405.     qCritical("CarlaBackendStandalone::get_audio_port_count_info(%i) - could not find plugin", pluginId);

  406.     return &info;

  407. }

  408. 

  409. const PortCountInfo* get_midi_port_count_info(unsigned short pluginId)

  410. {

  411.     qDebug("CarlaBackendStandalone::get_midi_port_count_info(%i)", pluginId);

  412.     CARLA_ASSERT(standalone.engine);

  413. 

  414.     static PortCountInfo info;

  415. 

  416.     // reset

  417.     info.ins   = 0;

  418.     info.outs  = 0;

  419.     info.total = 0;

  420. 

  421.     if (! standalone.engine)

  422.         return &info;

  423. 

  424.     CarlaBackend::CarlaPlugin* const plugin = standalone.engine->getPlugin(pluginId);

  425. 

  426.     if (plugin)

  427.     {

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

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

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

  431.         return &info;

  432.     }

  433. 

  434.     qCritical("CarlaBackendStandalone::get_midi_port_count_info(%i) - could not find plugin", pluginId);

  435.     return &info;

  436. }

  437. 

  438. const PortCountInfo* get_parameter_count_info(unsigned short pluginId)

  439. {

  440.     qDebug("CarlaBackendStandalone::get_parameter_count_info(%i)", pluginId);

  441.     CARLA_ASSERT(standalone.engine);

  442. 

  443.     static PortCountInfo info;

  444. 

  445.     // reset

  446.     info.ins   = 0;

  447.     info.outs  = 0;

  448.     info.total = 0;

  449. 

  450.     if (! standalone.engine)

  451.         return &info;

  452. 

  453.     CarlaBackend::CarlaPlugin* const plugin = standalone.engine->getPlugin(pluginId);

  454. 

  455.     if (plugin)

  456.     {

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

  458.         return &info;

  459.     }

  460. 

  461.     qCritical("CarlaBackendStandalone::get_parameter_count_info(%i) - could not find plugin", pluginId);

  462.     return &info;

  463. }

  464. 

  465. const ParameterInfo* get_parameter_info(unsigned short pluginId, uint32_t parameter_id)

  466. {

  467.     qDebug("CarlaBackendStandalone::get_parameter_info(%i, %i)", pluginId, parameter_id);

  468.     CARLA_ASSERT(standalone.engine);

  469. 

  470.     static ParameterInfo info;

  471. 

  472.     // reset

  473.     info.scalePointCount = 0;

  474. 

  475.     // cleanup

  476.     if (info.name)

  477.     {

  478.         free((void*)info.name);

  479.         info.name = nullptr;

  480.     }

  481. 

  482.     if (info.symbol)

  483.     {

  484.         free((void*)info.symbol);

  485.         info.symbol = nullptr;

  486.     }

  487. 

  488.     if (info.unit)

  489.     {

  490.         free((void*)info.unit);

  491.         info.unit = nullptr;

  492.     }

  493. 

  494.     if (! standalone.engine)

  495.         return &info;

  496. 

  497.     if (! standalone.started)

  498.         return nullptr;

  499. 

  500.     CarlaBackend::CarlaPlugin* const plugin = standalone.engine->getPlugin(pluginId);

  501. 

  502.     if (plugin)

  503.     {

  504.         if (parameter_id < plugin->parameterCount())

  505.         {

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

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

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

  509. 

  510.             info.scalePointCount = plugin->parameterScalePointCount(parameter_id);

  511. 

  512.             plugin->getParameterName(parameter_id, strBufName);

  513.             info.name = strdup(strBufName);

  514. 

  515.             plugin->getParameterSymbol(parameter_id, strBufSymbol);

  516.             info.symbol = strdup(strBufSymbol);

  517. 

  518.             plugin->getParameterUnit(parameter_id, strBufUnit);

  519.             info.unit = strdup(strBufUnit);

  520.         }

  521.         else

  522.             qCritical("CarlaBackendStandalone::get_parameter_info(%i, %i) - parameter_id out of bounds", pluginId, parameter_id);

  523. 

  524.         return &info;

  525.     }

  526. 

  527.     qCritical("CarlaBackendStandalone::get_parameter_info(%i, %i) - could not find plugin", pluginId, parameter_id);

  528.     return &info;

  529. }

  530. 

  531. const ScalePointInfo* get_parameter_scalepoint_info(unsigned short pluginId, uint32_t parameter_id, uint32_t scalepoint_id)

  532. {

  533.     qDebug("CarlaBackendStandalone::get_parameter_scalepoint_info(%i, %i, %i)", pluginId, parameter_id, scalepoint_id);

  534.     CARLA_ASSERT(standalone.engine);

  535. 

  536.     static ScalePointInfo info;

  537. 

  538.     // reset

  539.     info.value = 0.0;

  540. 

  541.     // cleanup

  542.     if (info.label)

  543.     {

  544.         free((void*)info.label);

  545.         info.label = nullptr;

  546.     }

  547. 

  548.     if (! standalone.engine)

  549.         return &info;

  550. 

  551.     if (! standalone.started)

  552.         return nullptr;

  553. 

  554.     CarlaBackend::CarlaPlugin* const plugin = standalone.engine->getPlugin(pluginId);

  555. 

  556.     if (plugin)

  557.     {

  558.         if (parameter_id < plugin->parameterCount())

  559.         {

  560.             if (scalepoint_id < plugin->parameterScalePointCount(parameter_id))

  561.             {

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

  563. 

  564.                 info.value = plugin->getParameterScalePointValue(parameter_id, scalepoint_id);

  565. 

  566.                 plugin->getParameterScalePointLabel(parameter_id, scalepoint_id, strBufLabel);

  567.                 info.label = strdup(strBufLabel);

  568.             }

  569.             else

  570.                 qCritical("CarlaBackendStandalone::get_parameter_scalepoint_info(%i, %i, %i) - scalepoint_id out of bounds", pluginId, parameter_id, scalepoint_id);

  571.         }

  572.         else

  573.             qCritical("CarlaBackendStandalone::get_parameter_scalepoint_info(%i, %i, %i) - parameter_id out of bounds", pluginId, parameter_id, parameter_id);

  574. 

  575.         return &info;

  576.     }

  577. 

  578.     qCritical("CarlaBackendStandalone::get_parameter_scalepoint_info(%i, %i, %i) - could not find plugin", pluginId, parameter_id, scalepoint_id);

  579.     return &info;

  580. }

  581. 

  582. const GuiInfo* get_gui_info(unsigned short pluginId)

  583. {

  584.     qDebug("CarlaBackendStandalone::get_gui_info(%i)", pluginId);

  585.     CARLA_ASSERT(standalone.engine);

  586. 

  587.     static GuiInfo info;

  588. 

  589.     // reset

  590.     info.type      = CarlaBackend::GUI_NONE;

  591.     info.resizable = false;

  592. 

  593.     if (! standalone.engine)

  594.         return &info;

  595. 

  596.     CarlaBackend::CarlaPlugin* const plugin = standalone.engine->getPlugin(pluginId);

  597. 

  598.     if (plugin)

  599.     {

  600.         plugin->getGuiInfo(&info.type, &info.resizable);

  601.         return &info;

  602.     }

  603. 

  604.     qCritical("CarlaBackendStandalone::get_gui_info(%i) - could not find plugin", pluginId);

  605.     return &info;

  606. }

  607. 

  608. // -------------------------------------------------------------------------------------------------------------------

  609. 

  610. const CarlaBackend::ParameterData* get_parameter_data(unsigned short pluginId, uint32_t parameter_id)

  611. {

  612.     qDebug("CarlaBackendStandalone::get_parameter_data(%i, %i)", pluginId, parameter_id);

  613.     CARLA_ASSERT(standalone.engine);

  614. 

  615.     static CarlaBackend::ParameterData data;

  616. 

  617.     if (! standalone.engine)

  618.         return &data;

  619. 

  620.     CarlaBackend::CarlaPlugin* const plugin = standalone.engine->getPlugin(pluginId);

  621. 

  622.     if (plugin)

  623.     {

  624.         if (parameter_id < plugin->parameterCount())

  625.             return plugin->parameterData(parameter_id);

  626. 

  627.         qCritical("CarlaBackendStandalone::get_parameter_data(%i, %i) - parameter_id out of bounds", pluginId, parameter_id);

  628.         return &data;

  629.     }

  630. 

  631.     qCritical("CarlaBackendStandalone::get_parameter_data(%i, %i) - could not find plugin", pluginId, parameter_id);

  632.     return &data;

  633. }

  634. 

  635. const CarlaBackend::ParameterRanges* get_parameter_ranges(unsigned short pluginId, uint32_t parameter_id)

  636. {

  637.     qDebug("CarlaBackendStandalone::get_parameter_ranges(%i, %i)", pluginId, parameter_id);

  638.     CARLA_ASSERT(standalone.engine);

  639. 

  640.     static CarlaBackend::ParameterRanges ranges;

  641. 

  642.     if (! standalone.engine)

  643.         return &ranges;

  644. 

  645.     CarlaBackend::CarlaPlugin* const plugin = standalone.engine->getPlugin(pluginId);

  646. 

  647.     if (plugin)

  648.     {

  649.         if (parameter_id < plugin->parameterCount())

  650.             return plugin->parameterRanges(parameter_id);

  651. 

  652.         qCritical("CarlaBackendStandalone::get_parameter_ranges(%i, %i) - parameter_id out of bounds", pluginId, parameter_id);

  653.         return &ranges;

  654.     }

  655. 

  656.     qCritical("CarlaBackendStandalone::get_parameter_ranges(%i, %i) - could not find plugin", pluginId, parameter_id);

  657.     return &ranges;

  658. }

  659. 

  660. const CarlaBackend::MidiProgramData* get_midi_program_data(unsigned short pluginId, uint32_t midi_program_id)

  661. {

  662.     qDebug("CarlaBackendStandalone::get_midi_program_data(%i, %i)", pluginId, midi_program_id);

  663.     CARLA_ASSERT(standalone.engine);

  664. 

  665.     static CarlaBackend::MidiProgramData data;

  666. 

  667.     if (! standalone.engine)

  668.         return &data;

  669. 

  670.     CarlaBackend::CarlaPlugin* const plugin = standalone.engine->getPlugin(pluginId);

  671. 

  672.     if (plugin)

  673.     {

  674.         if (midi_program_id < plugin->midiProgramCount())

  675.             return plugin->midiProgramData(midi_program_id);

  676. 

  677.         qCritical("CarlaBackendStandalone::get_midi_program_data(%i, %i) - midi_program_id out of bounds", pluginId, midi_program_id);

  678.         return &data;

  679.     }

  680. 

  681.     qCritical("CarlaBackendStandalone::get_midi_program_data(%i, %i) - could not find plugin", pluginId, midi_program_id);

  682.     return &data;

  683. }

  684. 

  685. const CarlaBackend::CustomData* get_custom_data(unsigned short pluginId, uint32_t custom_data_id)

  686. {

  687.     qDebug("CarlaBackendStandalone::get_custom_data(%i, %i)", pluginId, custom_data_id);

  688.     CARLA_ASSERT(standalone.engine);

  689. 

  690.     static CarlaBackend::CustomData data;

  691. 

  692.     if (! standalone.engine)

  693.         return &data;

  694. 

  695.     CarlaBackend::CarlaPlugin* const plugin = standalone.engine->getPlugin(pluginId);

  696. 

  697.     if (plugin)

  698.     {

  699.         if (custom_data_id < plugin->customDataCount())

  700.             return plugin->customData(custom_data_id);

  701. 

  702.         qCritical("CarlaBackendStandalone::get_custom_data(%i, %i) - custom_data_id out of bounds", pluginId, custom_data_id);

  703.         return &data;

  704.     }

  705. 

  706.     qCritical("CarlaBackendStandalone::get_custom_data(%i, %i) - could not find plugin", pluginId, custom_data_id);

  707.     return &data;

  708. }

  709. 

  710. const char* get_chunk_data(unsigned short pluginId)

  711. {

  712.     qDebug("CarlaBackendStandalone::get_chunk_data(%i)", pluginId);

  713.     CARLA_ASSERT(standalone.engine);

  714. 

  715.     static const char* chunk_data = nullptr;

  716. 

  717.     // cleanup

  718.     if (chunk_data)

  719.     {

  720.         free((void*)chunk_data);

  721.         chunk_data = nullptr;

  722.     }

  723. 

  724.     if (! standalone.engine)

  725.         return nullptr;

  726. 

  727.     if (! standalone.started)

  728.         return nullptr;

  729. 

  730.     CarlaBackend::CarlaPlugin* const plugin = standalone.engine->getPlugin(pluginId);

  731. 

  732.     if (plugin)

  733.     {

  734.         if (plugin->hints() & CarlaBackend::PLUGIN_USES_CHUNKS)

  735.         {

  736.             void* data = nullptr;

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

  738. 

  739.             if (data && dataSize >= 4)

  740.             {

  741.                 const QByteArray chunk((const char*)data, dataSize);

  742.                 chunk_data = strdup(chunk.toBase64().constData());

  743.             }

  744.             else

  745.                 qCritical("CarlaBackendStandalone::get_chunk_data(%i) - got invalid chunk data", pluginId);

  746.         }

  747.         else

  748.             qCritical("CarlaBackendStandalone::get_chunk_data(%i) - plugin does not support chunks", pluginId);

  749. 

  750.         return chunk_data;

  751.     }

  752. 

  753.     qCritical("CarlaBackendStandalone::get_chunk_data(%i) - could not find plugin", pluginId);

  754.     return nullptr;

  755. }

  756. 

  757. // -------------------------------------------------------------------------------------------------------------------

  758. 

  759. uint32_t get_parameter_count(unsigned short pluginId)

  760. {

  761.     qDebug("CarlaBackendStandalone::get_parameter_count(%i)", pluginId);

  762.     CARLA_ASSERT(standalone.engine);

  763. 

  764.     if (! standalone.engine)

  765.         return 0;

  766. 

  767.     CarlaBackend::CarlaPlugin* const plugin = standalone.engine->getPlugin(pluginId);

  768. 

  769.     if (plugin)

  770.         return plugin->parameterCount();

  771. 

  772.     qCritical("CarlaBackendStandalone::get_parameter_count(%i) - could not find plugin", pluginId);

  773.     return 0;

  774. }

  775. 

  776. uint32_t get_program_count(unsigned short pluginId)

  777. {

  778.     qDebug("CarlaBackendStandalone::get_program_count(%i)", pluginId);

  779.     CARLA_ASSERT(standalone.engine);

  780. 

  781.     if (! standalone.engine)

  782.         return 0;

  783. 

  784.     CarlaBackend::CarlaPlugin* const plugin = standalone.engine->getPlugin(pluginId);

  785. 

  786.     if (plugin)

  787.         return plugin->programCount();

  788. 

  789.     qCritical("CarlaBackendStandalone::get_program_count(%i) - could not find plugin", pluginId);

  790.     return 0;

  791. }

  792. 

  793. uint32_t get_midi_program_count(unsigned short pluginId)

  794. {

  795.     qDebug("CarlaBackendStandalone::get_midi_program_count(%i)", pluginId);

  796.     CARLA_ASSERT(standalone.engine);

  797. 

  798.     if (! standalone.engine)

  799.         return 0;

  800. 

  801.     CarlaBackend::CarlaPlugin* const plugin = standalone.engine->getPlugin(pluginId);

  802. 

  803.     if (plugin)

  804.         return plugin->midiProgramCount();

  805. 

  806.     qCritical("CarlaBackendStandalone::get_midi_program_count(%i) - could not find plugin", pluginId);

  807.     return 0;

  808. }

  809. 

  810. uint32_t get_custom_data_count(unsigned short pluginId)

  811. {

  812.     qDebug("CarlaBackendStandalone::get_custom_data_count(%i)", pluginId);

  813.     CARLA_ASSERT(standalone.engine);

  814. 

  815.     if (! standalone.engine)

  816.         return 0;

  817. 

  818.     CarlaBackend::CarlaPlugin* const plugin = standalone.engine->getPlugin(pluginId);

  819. 

  820.     if (plugin)

  821.         return plugin->customDataCount();

  822. 

  823.     qCritical("CarlaBackendStandalone::get_custom_data_count(%i) - could not find plugin", pluginId);

  824.     return 0;

  825. }

  826. 

  827. // -------------------------------------------------------------------------------------------------------------------

  828. 

  829. const char* get_parameter_text(unsigned short pluginId, uint32_t parameter_id)

  830. {

  831.     qDebug("CarlaBackendStandalone::get_parameter_text(%i, %i)", pluginId, parameter_id);

  832.     CARLA_ASSERT(standalone.engine);

  833. 

  834.     static char textBuf[STR_MAX];

  835.     memset(textBuf, 0, sizeof(char)*STR_MAX);

  836. 

  837.     if (! standalone.engine)

  838.         return nullptr;

  839. 

  840.     CarlaBackend::CarlaPlugin* const plugin = standalone.engine->getPlugin(pluginId);

  841. 

  842.     if (plugin)

  843.     {

  844.         if (parameter_id < plugin->parameterCount())

  845.         {

  846.             plugin->getParameterText(parameter_id, textBuf);

  847.             return textBuf;

  848.         }

  849. 

  850.         qCritical("CarlaBackendStandalone::get_parameter_text(%i, %i) - parameter_id out of bounds", pluginId, parameter_id);

  851.         return nullptr;

  852.     }

  853. 

  854.     qCritical("CarlaBackendStandalone::get_parameter_text(%i, %i) - could not find plugin", pluginId, parameter_id);

  855.     return nullptr;

  856. }

  857. 

  858. const char* get_program_name(unsigned short pluginId, uint32_t program_id)

  859. {

  860.     qDebug("CarlaBackendStandalone::get_program_name(%i, %i)", pluginId, program_id);

  861.     CARLA_ASSERT(standalone.engine);

  862. 

  863.     static const char* program_name = nullptr;

  864. 

  865.     // cleanup

  866.     if (program_name)

  867.     {

  868.         free((void*)program_name);

  869.         program_name = nullptr;

  870.     }

  871. 

  872.     if (! standalone.engine)

  873.         return nullptr;

  874. 

  875.     if (! standalone.started)

  876.         return nullptr;

  877. 

  878.     CarlaBackend::CarlaPlugin* const plugin = standalone.engine->getPlugin(pluginId);

  879. 

  880.     if (plugin)

  881.     {

  882.         if (program_id < plugin->programCount())

  883.         {

  884.             char strBuf[STR_MAX] = { 0 };

  885. 

  886.             plugin->getProgramName(program_id, strBuf);

  887.             program_name = strdup(strBuf);

  888. 

  889.             return program_name;

  890.         }

  891. 

  892.         qCritical("CarlaBackendStandalone::get_program_name(%i, %i) - program_id out of bounds", pluginId, program_id);

  893.         return nullptr;

  894.     }

  895. 

  896.     qCritical("CarlaBackendStandalone::get_program_name(%i, %i) - could not find plugin", pluginId, program_id);

  897.     return nullptr;

  898. }

  899. 

  900. const char* get_midi_program_name(unsigned short pluginId, uint32_t midi_program_id)

  901. {

  902.     qDebug("CarlaBackendStandalone::get_midi_program_name(%i, %i)", pluginId, midi_program_id);

  903.     CARLA_ASSERT(standalone.engine);

  904. 

  905.     static const char* midi_program_name = nullptr;

  906. 

  907.     // cleanup

  908.     if (midi_program_name)

  909.     {

  910.         free((void*)midi_program_name);

  911.         midi_program_name = nullptr;

  912.     }

  913. 

  914.     if (! standalone.engine)

  915.         return nullptr;

  916. 

  917.     if (! standalone.started)

  918.         return nullptr;

  919. 

  920.     CarlaBackend::CarlaPlugin* const plugin = standalone.engine->getPlugin(pluginId);

  921. 

  922.     if (plugin)

  923.     {

  924.         if (midi_program_id < plugin->midiProgramCount())

  925.         {

  926.             char strBuf[STR_MAX] = { 0 };

  927. 

  928.             plugin->getMidiProgramName(midi_program_id, strBuf);

  929.             midi_program_name = strdup(strBuf);

  930. 

  931.             return midi_program_name;

  932.         }

  933. 

  934.         qCritical("CarlaBackendStandalone::get_midi_program_name(%i, %i) - program_id out of bounds", pluginId, midi_program_id);

  935.         return nullptr;

  936.     }

  937. 

  938.     qCritical("CarlaBackendStandalone::get_midi_program_name(%i, %i) - could not find plugin", pluginId, midi_program_id);

  939.     return nullptr;

  940. }

  941. 

  942. const char* get_real_plugin_name(unsigned short pluginId)

  943. {

  944.     qDebug("CarlaBackendStandalone::get_real_plugin_name(%i)", pluginId);

  945.     CARLA_ASSERT(standalone.engine);

  946. 

  947.     static const char* real_plugin_name = nullptr;

  948. 

  949.     // cleanup

  950.     if (real_plugin_name)

  951.     {

  952.         free((void*)real_plugin_name);

  953.         real_plugin_name = nullptr;

  954.     }

  955. 

  956.     if (! standalone.engine)

  957.         return nullptr;

  958. 

  959.     if (! standalone.started)

  960.         return nullptr;

  961. 

  962.     CarlaBackend::CarlaPlugin* const plugin = standalone.engine->getPlugin(pluginId);

  963. 

  964.     if (plugin)

  965.     {

  966.         char strBuf[STR_MAX] = { 0 };

  967. 

  968.         plugin->getRealName(strBuf);

  969.         real_plugin_name = strdup(strBuf);

  970. 

  971.         return real_plugin_name;

  972.     }

  973. 

  974.     qCritical("CarlaBackendStandalone::get_real_plugin_name(%i) - could not find plugin", pluginId);

  975.     return nullptr;

  976. }

  977. 

  978. // -------------------------------------------------------------------------------------------------------------------

  979. 

  980. int32_t get_current_program_index(unsigned short pluginId)

  981. {

  982.     qDebug("CarlaBackendStandalone::get_current_program_index(%i)", pluginId);

  983.     CARLA_ASSERT(standalone.engine);

  984. 

  985.     if (! standalone.engine)

  986.         return -1;

  987. 

  988.     CarlaBackend::CarlaPlugin* const plugin = standalone.engine->getPlugin(pluginId);

  989. 

  990.     if (plugin)

  991.         return plugin->currentProgram();

  992. 

  993.     qCritical("CarlaBackendStandalone::get_current_program_index(%i) - could not find plugin", pluginId);

  994.     return -1;

  995. }

  996. 

  997. int32_t get_current_midi_program_index(unsigned short pluginId)

  998. {

  999.     qDebug("CarlaBackendStandalone::get_current_midi_program_index(%i)", pluginId);

  1000.     CARLA_ASSERT(standalone.engine);

  1001. 

  1002.     if (! standalone.engine)

  1003.         return -1;

  1004. 

  1005.     CarlaBackend::CarlaPlugin* const plugin = standalone.engine->getPlugin(pluginId);

  1006. 

  1007.     if (plugin)

  1008.         return plugin->currentMidiProgram();

  1009. 

  1010.     qCritical("CarlaBackendStandalone::get_current_midi_program_index(%i) - could not find plugin", pluginId);

  1011.     return -1;

  1012. }

  1013. 

  1014. // -------------------------------------------------------------------------------------------------------------------

  1015. 

  1016. double get_default_parameter_value(unsigned short pluginId, uint32_t parameter_id)

  1017. {

  1018.     qDebug("CarlaBackendStandalone::get_default_parameter_value(%i, %i)", pluginId, parameter_id);

  1019.     CARLA_ASSERT(standalone.engine);

  1020. 

  1021.     if (! standalone.engine)

  1022.         return 0.0;

  1023. 

  1024.     CarlaBackend::CarlaPlugin* const plugin = standalone.engine->getPlugin(pluginId);

  1025. 

  1026.     if (plugin)

  1027.     {

  1028.         if (parameter_id < plugin->parameterCount())

  1029.             return plugin->parameterRanges(parameter_id)->def;

  1030. 

  1031.         qCritical("CarlaBackendStandalone::get_default_parameter_value(%i, %i) - parameter_id out of bounds", pluginId, parameter_id);

  1032.         return 0.0;

  1033.     }

  1034. 

  1035.     qCritical("CarlaBackendStandalone::get_default_parameter_value(%i, %i) - could not find plugin", pluginId, parameter_id);

  1036.     return 0.0;

  1037. }

  1038. 

  1039. double get_current_parameter_value(unsigned short pluginId, uint32_t parameter_id)

  1040. {

  1041.     qDebug("CarlaBackendStandalone::get_current_parameter_value(%i, %i)", pluginId, parameter_id);

  1042.     CARLA_ASSERT(standalone.engine);

  1043. 

  1044.     if (! standalone.engine)

  1045.         return 0.0;

  1046. 

  1047.     CarlaBackend::CarlaPlugin* const plugin = standalone.engine->getPlugin(pluginId);

  1048. 

  1049.     if (plugin)

  1050.     {

  1051.         if (parameter_id < plugin->parameterCount())

  1052.             return plugin->getParameterValue(parameter_id);

  1053. 

  1054.         qCritical("CarlaBackendStandalone::get_current_parameter_value(%i, %i) - parameter_id out of bounds", pluginId, parameter_id);

  1055.         return 0.0;

  1056.     }

  1057. 

  1058.     qCritical("CarlaBackendStandalone::get_current_parameter_value(%i, %i) - could not find plugin", pluginId, parameter_id);

  1059.     return 0.0;

  1060. }

  1061. 

  1062. // -------------------------------------------------------------------------------------------------------------------

  1063. 

  1064. double get_input_peak_value(unsigned short pluginId, unsigned short port_id)

  1065. {

  1066.     CARLA_ASSERT(standalone.engine);

  1067.     CARLA_ASSERT(port_id == 1 || port_id == 2);

  1068. 

  1069.     if (! standalone.engine)

  1070.         return 0.0;

  1071. 

  1072. #if 0

  1073.     if (pluginId >= standalone.engine->maxPluginNumber())

  1074.     {

  1075.         qCritical("CarlaBackendStandalone::get_input_peak_value(%i, %i) - invalid plugin value", pluginId, port_id);

  1076.         return 0.0;

  1077.     }

  1078. #endif

  1079. 

  1080.     if (port_id == 1 || port_id == 2)

  1081.         return standalone.engine->getInputPeak(pluginId, port_id-1);

  1082. 

  1083.     qCritical("CarlaBackendStandalone::get_input_peak_value(%i, %i) - invalid port value", pluginId, port_id);

  1084.     return 0.0;

  1085. }

  1086. 

  1087. double get_output_peak_value(unsigned short pluginId, unsigned short port_id)

  1088. {

  1089.     CARLA_ASSERT(standalone.engine);

  1090.     CARLA_ASSERT(port_id == 1 || port_id == 2);

  1091. 

  1092.     if (! standalone.engine)

  1093.         return 0.0;

  1094. 

  1095. #if 0

  1096.     if (pluginId >= standalone.engine->maxPluginNumber())

  1097.     {

  1098.         qCritical("CarlaBackendStandalone::get_input_peak_value(%i, %i) - invalid plugin value", pluginId, port_id);

  1099.         return 0.0;

  1100.     }

  1101. #endif

  1102. 

  1103.     if (port_id == 1 || port_id == 2)

  1104.         return standalone.engine->getOutputPeak(pluginId, port_id-1);

  1105. 

  1106.     qCritical("CarlaBackendStandalone::get_output_peak_value(%i, %i) - invalid port value", pluginId, port_id);

  1107.     return 0.0;

  1108. }

  1109. 

  1110. // -------------------------------------------------------------------------------------------------------------------

  1111. 

  1112. void set_active(unsigned short pluginId, bool onOff)

  1113. {

  1114.     qDebug("CarlaBackendStandalone::set_active(%i, %s)", pluginId, bool2str(onOff));

  1115.     CARLA_ASSERT(standalone.engine);

  1116. 

  1117.     if (! standalone.engine)

  1118.         return;

  1119. 

  1120.     CarlaBackend::CarlaPlugin* const plugin = standalone.engine->getPlugin(pluginId);

  1121. 

  1122.     if (plugin)

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

  1124. 

  1125.     qCritical("CarlaBackendStandalone::set_active(%i, %s) - could not find plugin", pluginId, bool2str(onOff));

  1126. }

  1127. 

  1128. void set_drywet(unsigned short pluginId, double value)

  1129. {

  1130.     qDebug("CarlaBackendStandalone::set_drywet(%i, %g)", pluginId, value);

  1131.     CARLA_ASSERT(standalone.engine);

  1132. 

  1133.     if (! standalone.engine)

  1134.         return;

  1135. 

  1136.     CarlaBackend::CarlaPlugin* const plugin = standalone.engine->getPlugin(pluginId);

  1137. 

  1138.     if (plugin)

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

  1140. 

  1141.     qCritical("CarlaBackendStandalone::set_drywet(%i, %g) - could not find plugin", pluginId, value);

  1142. }

  1143. 

  1144. void set_volume(unsigned short pluginId, double value)

  1145. {

  1146.     qDebug("CarlaBackendStandalone::set_volume(%i, %g)", pluginId, value);

  1147.     CARLA_ASSERT(standalone.engine);

  1148. 

  1149.     if (! standalone.engine)

  1150.         return;

  1151. 

  1152.     CarlaBackend::CarlaPlugin* const plugin = standalone.engine->getPlugin(pluginId);

  1153. 

  1154.     if (plugin)

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

  1156. 

  1157.     qCritical("CarlaBackendStandalone::set_volume(%i, %g) - could not find plugin", pluginId, value);

  1158. }

  1159. 

  1160. void set_balance_left(unsigned short pluginId, double value)

  1161. {

  1162.     qDebug("CarlaBackendStandalone::set_balance_left(%i, %g)", pluginId, value);

  1163.     CARLA_ASSERT(standalone.engine);

  1164. 

  1165.     if (! standalone.engine)

  1166.         return;

  1167. 

  1168.     CarlaBackend::CarlaPlugin* const plugin = standalone.engine->getPlugin(pluginId);

  1169. 

  1170.     if (plugin)

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

  1172. 

  1173.     qCritical("CarlaBackendStandalone::set_balance_left(%i, %g) - could not find plugin", pluginId, value);

  1174. }

  1175. 

  1176. void set_balance_right(unsigned short pluginId, double value)

  1177. {

  1178.     qDebug("CarlaBackendStandalone::set_balance_right(%i, %g)", pluginId, value);

  1179.     CARLA_ASSERT(standalone.engine);

  1180. 

  1181.     if (! standalone.engine)

  1182.         return;

  1183. 

  1184.     CarlaBackend::CarlaPlugin* const plugin = standalone.engine->getPlugin(pluginId);

  1185. 

  1186.     if (plugin)

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

  1188. 

  1189.     qCritical("CarlaBackendStandalone::set_balance_right(%i, %g) - could not find plugin", pluginId, value);

  1190. }

  1191. 

  1192. // -------------------------------------------------------------------------------------------------------------------

  1193. 

  1194. void set_parameter_value(unsigned short pluginId, uint32_t parameter_id, double value)

  1195. {

  1196.     qDebug("CarlaBackendStandalone::set_parameter_value(%i, %i, %g)", pluginId, parameter_id, value);

  1197.     CARLA_ASSERT(standalone.engine);

  1198. 

  1199.     if (! standalone.engine)

  1200.         return;

  1201. 

  1202.     CarlaBackend::CarlaPlugin* const plugin = standalone.engine->getPlugin(pluginId);

  1203. 

  1204.     if (plugin)

  1205.     {

  1206.         if (parameter_id < plugin->parameterCount())

  1207.             return plugin->setParameterValue(parameter_id, value, true, true, false);

  1208. 

  1209.         qCritical("CarlaBackendStandalone::set_parameter_value(%i, %i, %g) - parameter_id out of bounds", pluginId, parameter_id, value);

  1210.         return;

  1211.     }

  1212. 

  1213.     qCritical("CarlaBackendStandalone::set_parameter_value(%i, %i, %g) - could not find plugin", pluginId, parameter_id, value);

  1214. }

  1215. 

  1216. void set_parameter_midi_channel(unsigned short pluginId, uint32_t parameter_id, uint8_t channel)

  1217. {

  1218.     qDebug("CarlaBackendStandalone::set_parameter_midi_channel(%i, %i, %i)", pluginId, parameter_id, channel);

  1219.     CARLA_ASSERT(standalone.engine);

  1220.     CARLA_ASSERT(channel < MAX_MIDI_CHANNELS);

  1221. 

  1222.     if (channel >= MAX_MIDI_CHANNELS)

  1223.     {

  1224.         qCritical("CarlaBackendStandalone::set_parameter_midi_channel(%i, %i, %i) - invalid channel number", pluginId, parameter_id, channel);

  1225.         return;

  1226.     }

  1227. 

  1228.     if (! standalone.engine)

  1229.         return;

  1230. 

  1231.     CarlaBackend::CarlaPlugin* const plugin = standalone.engine->getPlugin(pluginId);

  1232. 

  1233.     if (plugin)

  1234.     {

  1235.         if (parameter_id < plugin->parameterCount())

  1236.             return plugin->setParameterMidiChannel(parameter_id, channel, true, false);

  1237. 

  1238.         qCritical("CarlaBackendStandalone::set_parameter_midi_channel(%i, %i, %i) - parameter_id out of bounds", pluginId, parameter_id, channel);

  1239.         return;

  1240.     }

  1241. 

  1242.     qCritical("CarlaBackendStandalone::set_parameter_midi_channel(%i, %i, %i) - could not find plugin", pluginId, parameter_id, channel);

  1243. }

  1244. 

  1245. void set_parameter_midi_cc(unsigned short pluginId, uint32_t parameter_id, int16_t cc)

  1246. {

  1247.     qDebug("CarlaBackendStandalone::set_parameter_midi_cc(%i, %i, %i)", pluginId, parameter_id, cc);

  1248.     CARLA_ASSERT(standalone.engine);

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

  1250. 

  1251.     if (cc < -1)

  1252.     {

  1253.         cc = -1;

  1254.     }

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

  1256.     {

  1257.         qCritical("CarlaBackendStandalone::set_parameter_midi_cc(%i, %i, %i) - invalid cc number", pluginId, parameter_id, cc);

  1258.         return;

  1259.     }

  1260. 

  1261.     if (! standalone.engine)

  1262.         return;

  1263. 

  1264.     CarlaBackend::CarlaPlugin* const plugin = standalone.engine->getPlugin(pluginId);

  1265. 

  1266.     if (plugin)

  1267.     {

  1268.         if (parameter_id < plugin->parameterCount())

  1269.             return plugin->setParameterMidiCC(parameter_id, cc, true, false);

  1270. 

  1271.         qCritical("CarlaBackendStandalone::set_parameter_midi_cc(%i, %i, %i) - parameter_id out of bounds", pluginId, parameter_id, cc);

  1272.         return;

  1273.     }

  1274. 

  1275.     qCritical("CarlaBackendStandalone::set_parameter_midi_cc(%i, %i, %i) - could not find plugin", pluginId, parameter_id, cc);

  1276. }

  1277. 

  1278. void set_program(unsigned short pluginId, uint32_t program_id)

  1279. {

  1280.     qDebug("CarlaBackendStandalone::set_program(%i, %i)", pluginId, program_id);

  1281.     CARLA_ASSERT(standalone.engine);

  1282. 

  1283.     if (! standalone.engine)

  1284.         return;

  1285. 

  1286.     CarlaBackend::CarlaPlugin* const plugin = standalone.engine->getPlugin(pluginId);

  1287. 

  1288.     if (plugin)

  1289.     {

  1290.         if (program_id < plugin->programCount())

  1291.             return plugin->setProgram(program_id, true, true, false, true);

  1292. 

  1293.         qCritical("CarlaBackendStandalone::set_program(%i, %i) - program_id out of bounds", pluginId, program_id);

  1294.         return;

  1295.     }

  1296. 

  1297.     qCritical("CarlaBackendStandalone::set_program(%i, %i) - could not find plugin", pluginId, program_id);

  1298. }

  1299. 

  1300. void set_midi_program(unsigned short pluginId, uint32_t midi_program_id)

  1301. {

  1302.     qDebug("CarlaBackendStandalone::set_midi_program(%i, %i)", pluginId, midi_program_id);

  1303.     CARLA_ASSERT(standalone.engine);

  1304. 

  1305.     if (! standalone.engine)

  1306.         return;

  1307. 

  1308.     CarlaBackend::CarlaPlugin* const plugin = standalone.engine->getPlugin(pluginId);

  1309. 

  1310.     if (plugin)

  1311.     {

  1312.         if (midi_program_id < plugin->midiProgramCount())

  1313.             return plugin->setMidiProgram(midi_program_id, true, true, false, true);

  1314. 

  1315.         qCritical("CarlaBackendStandalone::set_midi_program(%i, %i) - midi_program_id out of bounds", pluginId, midi_program_id);

  1316.         return;

  1317.     }

  1318. 

  1319.     qCritical("CarlaBackendStandalone::set_midi_program(%i, %i) - could not find plugin", pluginId, midi_program_id);

  1320. }

  1321. 

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

  1323. 

  1324. void set_custom_data(unsigned short pluginId, const char* type, const char* key, const char* value)

  1325. {

  1326.     qDebug("CarlaBackendStandalone::set_custom_data(%i, \"%s\", \"%s\", \"%s\")", pluginId, type, key, value);

  1327.     CARLA_ASSERT(standalone.engine);

  1328. 

  1329.     if (! standalone.engine)

  1330.         return;

  1331. 

  1332.     CarlaBackend::CarlaPlugin* const plugin = standalone.engine->getPlugin(pluginId);

  1333. 

  1334.     if (plugin)

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

  1336. 

  1337.     qCritical("CarlaBackendStandalone::set_custom_data(%i, \"%s\", \"%s\", \"%s\") - could not find plugin", pluginId, type, key, value);

  1338. }

  1339. 

  1340. void set_chunk_data(unsigned short pluginId, const char* chunk_data)

  1341. {

  1342.     qDebug("CarlaBackendStandalone::set_chunk_data(%i, \"%s\")", pluginId, chunk_data);

  1343.     CARLA_ASSERT(standalone.engine);

  1344. 

  1345.     if (! standalone.engine)

  1346.         return;

  1347. 

  1348.     CarlaBackend::CarlaPlugin* const plugin = standalone.engine->getPlugin(pluginId);

  1349. 

  1350.     if (plugin)

  1351.     {

  1352.         if (plugin->hints() & CarlaBackend::PLUGIN_USES_CHUNKS)

  1353.             return plugin->setChunkData(chunk_data);

  1354. 

  1355.         qCritical("CarlaBackendStandalone::set_chunk_data(%i, \"%s\") - plugin does not support chunks", pluginId, chunk_data);

  1356.         return;

  1357.     }

  1358. 

  1359.     qCritical("CarlaBackendStandalone::set_chunk_data(%i, \"%s\") - could not find plugin", pluginId, chunk_data);

  1360. }

  1361. 

  1362. void set_gui_container(unsigned short pluginId, uintptr_t gui_addr)

  1363. {

  1364.     qDebug("CarlaBackendStandalone::set_gui_container(%i, " P_UINTPTR ")", pluginId, gui_addr);

  1365.     CARLA_ASSERT(standalone.engine);

  1366. 

  1367.     if (! standalone.engine)

  1368.         return;

  1369. 

  1370.     CarlaBackend::CarlaPlugin* const plugin = standalone.engine->getPlugin(pluginId);

  1371. 

  1372.     if (plugin)

  1373.         return plugin->setGuiContainer((GuiContainer*)CarlaBackend::getPointerFromAddress(gui_addr));

  1374. 

  1375.     qCritical("CarlaBackendStandalone::set_gui_container(%i, " P_UINTPTR ") - could not find plugin", pluginId, gui_addr);

  1376. }

  1377. 

  1378. // -------------------------------------------------------------------------------------------------------------------

  1379. 

  1380. void show_gui(unsigned short pluginId, bool yesno)

  1381. {

  1382.     qDebug("CarlaBackendStandalone::show_gui(%i, %s)", pluginId, bool2str(yesno));

  1383.     CARLA_ASSERT(standalone.engine);

  1384. 

  1385.     if (! standalone.engine)

  1386.         return;

  1387. 

  1388.     CarlaBackend::CarlaPlugin* const plugin = standalone.engine->getPlugin(pluginId);

  1389. 

  1390.     if (plugin)

  1391.         return plugin->showGui(yesno);

  1392. 

  1393.     qCritical("CarlaBackendStandalone::show_gui(%i, %s) - could not find plugin", pluginId, bool2str(yesno));

  1394. }

  1395. 

  1396. void idle_guis()

  1397. {

  1398.     CARLA_ASSERT(standalone.engine);

  1399. 

  1400.     if (standalone.engine)

  1401.         standalone.engine->idlePluginGuis();

  1402. }

  1403. 

  1404. // -------------------------------------------------------------------------------------------------------------------

  1405. 

  1406. void send_midi_note(unsigned short pluginId, uint8_t channel, uint8_t note, uint8_t velocity)

  1407. {

  1408.     qDebug("CarlaBackendStandalone::send_midi_note(%i, %i, %i, %i)", pluginId, channel, note, velocity);

  1409.     CARLA_ASSERT(standalone.engine);

  1410. 

  1411.     if (! (standalone.engine && standalone.engine->isRunning()))

  1412.         return;

  1413. 

  1414.     CarlaBackend::CarlaPlugin* const plugin = standalone.engine->getPlugin(pluginId);

  1415. 

  1416.     if (plugin)

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

  1418. 

  1419.     qCritical("CarlaBackendStandalone::send_midi_note(%i, %i, %i, %i) - could not find plugin", pluginId, channel, note, velocity);

  1420. }

  1421. 

  1422. void prepare_for_save(unsigned short pluginId)

  1423. {

  1424.     qDebug("CarlaBackendStandalone::prepare_for_save(%i)", pluginId);

  1425.     CARLA_ASSERT(standalone.engine);

  1426. 

  1427.     if (! standalone.engine)

  1428.         return;

  1429. 

  1430.     CarlaBackend::CarlaPlugin* const plugin = standalone.engine->getPlugin(pluginId);

  1431. 

  1432.     if (plugin)

  1433.         return plugin->prepareForSave();

  1434. 

  1435.     qCritical("CarlaBackendStandalone::prepare_for_save(%i) - could not find plugin", pluginId);

  1436. }

  1437. 

  1438. // -------------------------------------------------------------------------------------------------------------------

  1439. 

  1440. uint32_t get_buffer_size()

  1441. {

  1442.     qDebug("CarlaBackendStandalone::get_buffer_size()");

  1443.     CARLA_ASSERT(standalone.engine);

  1444. 

  1445.     if (! standalone.engine)

  1446.         return 0;

  1447. 

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

  1449. }

  1450. 

  1451. double get_sample_rate()

  1452. {

  1453.     qDebug("CarlaBackendStandalone::get_sample_rate()");

  1454.     CARLA_ASSERT(standalone.engine);

  1455. 

  1456.     if (! standalone.engine)

  1457.         return 0.0;

  1458. 

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

  1460. }

  1461. 

  1462. // -------------------------------------------------------------------------------------------------------------------

  1463. 

  1464. const char* get_last_error()

  1465. {

  1466.     qDebug("CarlaBackendStandalone::get_last_error()");

  1467. 

  1468.     if (standalone.engine)

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

  1470. 

  1471.     return standalone.lastError;

  1472. }

  1473. 

  1474. const char* get_host_osc_url()

  1475. {

  1476.     qDebug("CarlaBackendStandalone::get_host_osc_url()");

  1477.     CARLA_ASSERT(standalone.engine);

  1478. 

  1479.     if (! standalone.engine)

  1480.         return nullptr;

  1481. 

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

  1483. }

  1484. 

  1485. // -------------------------------------------------------------------------------------------------------------------

  1486. 

  1487. void set_callback_function(CarlaBackend::CallbackFunc func)

  1488. {

  1489.     qDebug("CarlaBackendStandalone::set_callback_function(%p)", func);

  1490. 

  1491.     standalone.callback = func;

  1492. 

  1493.     if (standalone.engine)

  1494.         standalone.engine->setCallback(func, nullptr);

  1495. }

  1496. 

  1497. void set_option(CarlaBackend::OptionsType option, int value, const char* value_str)

  1498. {

  1499.     qDebug("CarlaBackendStandalone::set_option(%s, %i, \"%s\")", CarlaBackend::OptionsType2Str(option), value, value_str);

  1500. 

  1501.     if (standalone.engine)

  1502.         standalone.engine->setOption(option, value, value_str);

  1503. 

  1504.     switch (option)

  1505.     {

  1506.     case CarlaBackend::OPTION_PROCESS_NAME:

  1507.         standalone.procName = value_str;

  1508.         break;

  1509. 

  1510.     case CarlaBackend::OPTION_PROCESS_MODE:

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

  1512.             return qCritical("CarlaBackendStandalone::set_option(%s, %i, \"%s\") - invalid value", OptionsType2Str(option), value, value_str);

  1513. 

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

  1515.         break;

  1516. 

  1517.     case CarlaBackend::OPTION_PROCESS_HIGH_PRECISION:

  1518.         standalone.options.processHighPrecision = value;

  1519.         break;

  1520. 

  1521.     case CarlaBackend::OPTION_MAX_PARAMETERS:

  1522.         standalone.options.maxParameters = (value > 0) ? value : CarlaBackend::MAX_PARAMETERS;

  1523.         break;

  1524. 

  1525.     case CarlaBackend::OPTION_PREFERRED_BUFFER_SIZE:

  1526.         standalone.options.preferredBufferSize = value;

  1527.         break;

  1528. 

  1529.     case CarlaBackend::OPTION_PREFERRED_SAMPLE_RATE:

  1530.         standalone.options.preferredSampleRate = value;

  1531.         break;

  1532. 

  1533.     case CarlaBackend::OPTION_FORCE_STEREO:

  1534.         standalone.options.forceStereo = value;

  1535.         break;

  1536. 

  1537.     case CarlaBackend::OPTION_USE_DSSI_VST_CHUNKS:

  1538.         standalone.options.useDssiVstChunks = value;

  1539.         break;

  1540. 

  1541.     case CarlaBackend::OPTION_PREFER_PLUGIN_BRIDGES:

  1542.         standalone.options.preferPluginBridges = value;

  1543.         break;

  1544. 

  1545.     case CarlaBackend::OPTION_PREFER_UI_BRIDGES:

  1546.         standalone.options.preferUiBridges = value;

  1547.         break;

  1548. 

  1549.     case CarlaBackend::OPTION_OSC_UI_TIMEOUT:

  1550.         standalone.options.oscUiTimeout = value;

  1551.         break;

  1552. 

  1553.     case CarlaBackend::OPTION_PATH_BRIDGE_POSIX32:

  1554.         standalone.options.bridge_posix32 = value_str;

  1555.         break;

  1556.     case CarlaBackend::OPTION_PATH_BRIDGE_POSIX64:

  1557.         standalone.options.bridge_posix64 = value_str;

  1558.         break;

  1559.     case CarlaBackend::OPTION_PATH_BRIDGE_WIN32:

  1560.         standalone.options.bridge_win32 = value_str;

  1561.         break;

  1562.     case CarlaBackend::OPTION_PATH_BRIDGE_WIN64:

  1563.         standalone.options.bridge_win64 = value_str;

  1564.         break;

  1565. 

  1566.     case CarlaBackend::OPTION_PATH_BRIDGE_LV2_GTK2:

  1567.         standalone.options.bridge_lv2gtk2 = value_str;

  1568.         break;

  1569.     case CarlaBackend::OPTION_PATH_BRIDGE_LV2_GTK3:

  1570.         standalone.options.bridge_lv2gtk3 = value_str;

  1571.         break;

  1572.     case CarlaBackend::OPTION_PATH_BRIDGE_LV2_QT4:

  1573.         standalone.options.bridge_lv2qt4 = value_str;

  1574.         break;

  1575.     case CarlaBackend::OPTION_PATH_BRIDGE_LV2_QT5:

  1576.         standalone.options.bridge_lv2qt5 = value_str;

  1577.         break;

  1578.     case CarlaBackend::OPTION_PATH_BRIDGE_LV2_COCOA:

  1579.         standalone.options.bridge_lv2cocoa = value_str;

  1580.         break;

  1581.     case CarlaBackend::OPTION_PATH_BRIDGE_LV2_WINDOWS:

  1582.         standalone.options.bridge_lv2win = value_str;

  1583.         break;

  1584.     case CarlaBackend::OPTION_PATH_BRIDGE_LV2_X11:

  1585.         standalone.options.bridge_lv2x11 = value_str;

  1586.         break;

  1587. 

  1588.     case CarlaBackend::OPTION_PATH_BRIDGE_VST_COCOA:

  1589.         standalone.options.bridge_vstcocoa = value_str;

  1590.         break;

  1591.     case CarlaBackend::OPTION_PATH_BRIDGE_VST_HWND:

  1592.         standalone.options.bridge_vsthwnd = value_str;

  1593.         break;

  1594.     case CarlaBackend::OPTION_PATH_BRIDGE_VST_X11:

  1595.         standalone.options.bridge_vstx11 = value_str;

  1596.         break;

  1597.     }

  1598. }

  1599. 

  1600. // -------------------------------------------------------------------------------------------------------------------

  1601. 

  1602. #define NSM_API_VERSION_MAJOR 1

  1603. #define NSM_API_VERSION_MINOR 0

  1604. 

  1605. class CarlaNSM

  1606. {

  1607. public:

  1608.     CarlaNSM()

  1609.     {

  1610.         m_controlAddr = nullptr;

  1611.         m_serverThread = nullptr;

  1612.         m_isOpened = false;

  1613.         m_isSaved  = false;

  1614.     }

  1615. 

  1616.     ~CarlaNSM()

  1617.     {

  1618.         if (m_controlAddr)

  1619.             lo_address_free(m_controlAddr);

  1620. 

  1621.         if (m_serverThread)

  1622.         {

  1623.             lo_server_thread_stop(m_serverThread);

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

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

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

  1627.             lo_server_thread_free(m_serverThread);

  1628.         }

  1629.     }

  1630. 

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

  1632.     {

  1633.         lo_address addr = lo_address_new_from_url(url);

  1634.         int proto = lo_address_get_protocol(addr);

  1635. 

  1636.         if (! m_serverThread)

  1637.         {

  1638.             // create new OSC thread

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

  1640. 

  1641.             // register message handlers and start OSC thread

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

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

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

  1645.             lo_server_thread_start(m_serverThread);

  1646.         }

  1647. 

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

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

  1650. 

  1651.         lo_address_free(addr);

  1652.     }

  1653. 

  1654.     void replyOpen()

  1655.     {

  1656.         m_isOpened = true;

  1657.     }

  1658. 

  1659.     void replySave()

  1660.     {

  1661.         m_isSaved = true;

  1662.     }

  1663. 

  1664. protected:

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

  1666.     {

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

  1668. 

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

  1670. 

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

  1672. 

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

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

  1675. 

  1676.         return 0;

  1677.     }

  1678. 

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

  1680.     {

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

  1682. 

  1683.         if (! standalone.callback)

  1684.             return 1;

  1685. 

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

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

  1688. 

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

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

  1691. 

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

  1693.             carla_msleep(100);

  1694. 

  1695.         if (m_controlAddr)

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

  1697. 

  1698.         return 0;

  1699.     }

  1700. 

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

  1702.     {

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

  1704. 

  1705.         if (! standalone.callback)

  1706.             return 1;

  1707. 

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

  1709. 

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

  1711.             carla_msleep(100);

  1712. 

  1713.         if (m_controlAddr)

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

  1715. 

  1716.         return 0;

  1717.     }

  1718. 

  1719. private:

  1720.     lo_address m_controlAddr;

  1721.     lo_server_thread m_serverThread;

  1722.     bool m_isOpened, m_isSaved;

  1723. 

  1724.     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)

  1725.     {

  1726.         CARLA_ASSERT(data);

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

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

  1729.     }

  1730. 

  1731.     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)

  1732.     {

  1733.         CARLA_ASSERT(data);

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

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

  1736.     }

  1737. 

  1738.     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)

  1739.     {

  1740.         CARLA_ASSERT(data);

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

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

  1743.     }

  1744. 

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

  1746.     {

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

  1748.     }

  1749. };

  1750. 

  1751. static CarlaNSM carlaNSM;

  1752. 

  1753. void nsm_announce(const char* url, int pid)

  1754. {

  1755.     carlaNSM.announce(url, pid);

  1756. }

  1757. 

  1758. void nsm_reply_open()

  1759. {

  1760.     carlaNSM.replyOpen();

  1761. }

  1762. 

  1763. void nsm_reply_save()

  1764. {

  1765.     carlaNSM.replySave();

  1766. }

  1767. 

  1768. // -------------------------------------------------------------------------------------------------------------------

  1769. 

  1770. #if 0 //def QTCREATOR_TEST

  1771. 

  1772. #include <QtGui/QApplication>

  1773. #include <QtGui/QDialog>

  1774. 

  1775. QDialog* vstGui = nullptr;

  1776. 

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

  1778. {

  1779.     switch (action)

  1780.     {

  1781.     case CarlaBackend::CALLBACK_SHOW_GUI:

  1782.         if (vstGui && ! value1)

  1783.             vstGui->close();

  1784.         break;

  1785.     case CarlaBackend::CALLBACK_RESIZE_GUI:

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

  1787.         break;

  1788.     default:

  1789.         break;

  1790.     }

  1791. 

  1792.     Q_UNUSED(ptr);

  1793.     Q_UNUSED(pluginId);

  1794.     Q_UNUSED(value3);

  1795. }

  1796. 

  1797. void run_tests_standalone(short idMax)

  1798. {

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

  1800.     {

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

  1802.         get_plugin_info(id);

  1803.         get_audio_port_count_info(id);

  1804.         get_midi_port_count_info(id);

  1805.         get_parameter_count_info(id);

  1806.         get_gui_info(id);

  1807.         get_chunk_data(id);

  1808.         get_parameter_count(id);

  1809.         get_program_count(id);

  1810.         get_midi_program_count(id);

  1811.         get_custom_data_count(id);

  1812.         get_real_plugin_name(id);

  1813.         get_current_program_index(id);

  1814.         get_current_midi_program_index(id);

  1815. 

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

  1817.         get_parameter_info(id, -1);

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

  1819.         get_parameter_data(id, -1);

  1820.         get_parameter_ranges(id, -1);

  1821.         get_midi_program_data(id, -1);

  1822.         get_custom_data(id, -1);

  1823.         get_parameter_text(id, -1);

  1824.         get_program_name(id, -1);

  1825.         get_midi_program_name(id, -1);

  1826.         get_default_parameter_value(id, -1);

  1827.         get_current_parameter_value(id, -1);

  1828.         get_input_peak_value(id, -1);

  1829.         get_output_peak_value(id, -1);

  1830. 

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

  1832.         get_parameter_info(id, 0);

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

  1834.         get_parameter_scalepoint_info(id, 0, 0);

  1835.         get_parameter_data(id, 0);

  1836.         get_parameter_ranges(id, 0);

  1837.         get_midi_program_data(id, 0);

  1838.         get_custom_data(id, 0);

  1839.         get_parameter_text(id, 0);

  1840.         get_program_name(id, 0);

  1841.         get_midi_program_name(id, 0);

  1842.         get_default_parameter_value(id, 0);

  1843.         get_current_parameter_value(id, 0);

  1844.         get_input_peak_value(id, 0);

  1845.         get_input_peak_value(id, 1);

  1846.         get_input_peak_value(id, 2);

  1847.         get_output_peak_value(id, 0);

  1848.         get_output_peak_value(id, 1);

  1849.         get_output_peak_value(id, 2);

  1850. 

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

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

  1853.         set_chunk_data(id, nullptr);

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

  1855. 

  1856.         qDebug("------------------- TEST @%i: gui stuff --------------------", id);

  1857.         show_gui(id, false);

  1858.         show_gui(id, true);

  1859.         show_gui(id, true);

  1860. 

  1861.         idle_guis();

  1862.         idle_guis();

  1863.         idle_guis();

  1864. 

  1865.         qDebug("------------------- TEST @%i: other --------------------", id);

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

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

  1868. 

  1869.         prepare_for_save(id);

  1870.         prepare_for_save(id);

  1871.         prepare_for_save(id);

  1872.     }

  1873. }

  1874. 

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

  1876. {

  1877.     using namespace CarlaBackend;

  1878. 

  1879.     // Qt app

  1880.     QApplication app(argc, argv);

  1881. 

  1882.     // Qt gui (for vst)

  1883.     vstGui = new QDialog(nullptr);

  1884. 

  1885.     // set callback and options

  1886.     set_callback_function(main_callback);

  1887.     set_option(OPTION_PREFER_UI_BRIDGES, 0, nullptr);

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

  1889. 

  1890.     // start engine

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

  1892.     {

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

  1894.         delete vstGui;

  1895.         return 1;

  1896.     }

  1897. 

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

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

  1900. 

  1901.     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");

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

  1903. 

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

  1905. 

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

  1907. 

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

  1909.     {

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

  1911.         delete vstGui;

  1912.         return 1;

  1913.     }

  1914. 

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

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

  1917.     //{

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

  1919.     //gui->show();

  1920.     //}

  1921. 

  1922.     // activate

  1923.     set_active(id_ladspa, true);

  1924.     set_active(id_dssi, true);

  1925.     set_active(id_native, true);

  1926. 

  1927.     // start guis

  1928.     show_gui(id_dssi, true);

  1929.     carla_sleep(1);

  1930. 

  1931.     // do tests

  1932.     run_tests_standalone(id_dssi+1);

  1933. 

  1934.     // lock

  1935.     app.exec();

  1936. 

  1937.     delete vstGui;

  1938.     vstGui = nullptr;

  1939. 

  1940.     remove_plugin(id_ladspa);

  1941.     remove_plugin(id_dssi);

  1942.     remove_plugin(id_native);

  1943.     engine_close();

  1944. 

  1945.     return 0;

  1946. }

  1947. 

  1948. #endif