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

2327 lines
73KB
Raw Blame History 

  1. /*

  2.  * Carla Engine

  3.  * Copyright (C) 2012-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 "CarlaEngineInternal.hpp"

  19. #include "CarlaBackendUtils.hpp"

  20. #include "CarlaStateUtils.hpp"

  21. #include "CarlaMIDI.h"

  22. 

  23. #include <QtCore/QDir>

  24. #include <QtCore/QFile>

  25. #include <QtCore/QFileInfo>

  26. #include <QtCore/QTextStream>

  27. 

  28. CARLA_BACKEND_START_NAMESPACE

  29. 

  30. // -------------------------------------------------------------------------------------------------------------------

  31. // Fallback data

  32. 

  33. static const EngineEvent kFallbackEngineEvent;

  34. 

  35. #ifndef BUILD_BRIDGE

  36. // -------------------------------------------------------------------------------------------------------------------

  37. // Bridge Helper, defined in CarlaPlugin.cpp

  38. 

  39. extern BinaryType CarlaPluginGetBridgeBinaryType(CarlaPlugin* const plugin);

  40. 

  41. // -------------------------------------------------------------------------------------------------------------------

  42. // Engine Helpers

  43. 

  44. void registerEnginePlugin(CarlaEngine* const engine, const unsigned int id, CarlaPlugin* const plugin)

  45. {

  46.     CarlaEngineProtectedData::registerEnginePlugin(engine, id, plugin);

  47. }

  48. #endif

  49. 

  50. // -------------------------------------------------------------------------------------------------------------------

  51. // Carla Engine port (Abstract)

  52. 

  53. CarlaEnginePort::CarlaEnginePort(const bool isInput, const ProcessMode processMode)

  54.     : kIsInput(isInput),

  55.       kProcessMode(processMode)

  56. {

  57.     carla_debug("CarlaEnginePort::CarlaEnginePort(%s, %s)", bool2str(isInput), ProcessMode2Str(processMode));

  58. }

  59. 

  60. CarlaEnginePort::~CarlaEnginePort()

  61. {

  62.     carla_debug("CarlaEnginePort::~CarlaEnginePort()");

  63. }

  64. 

  65. // -------------------------------------------------------------------------------------------------------------------

  66. // Carla Engine Audio port

  67. 

  68. CarlaEngineAudioPort::CarlaEngineAudioPort(const bool isInput, const ProcessMode processMode)

  69.     : CarlaEnginePort(isInput, processMode),

  70.       fBuffer(nullptr)

  71. {

  72.     carla_debug("CarlaEngineAudioPort::CarlaEngineAudioPort(%s, %s)", bool2str(isInput), ProcessMode2Str(processMode));

  73. 

  74.     if (kProcessMode == PROCESS_MODE_PATCHBAY)

  75.         fBuffer = new float[PATCHBAY_BUFFER_SIZE];

  76. }

  77. 

  78. CarlaEngineAudioPort::~CarlaEngineAudioPort()

  79. {

  80.     carla_debug("CarlaEngineAudioPort::~CarlaEngineAudioPort()");

  81. 

  82.     if (kProcessMode == PROCESS_MODE_PATCHBAY)

  83.     {

  84.         CARLA_ASSERT(fBuffer != nullptr);

  85. 

  86.         if (fBuffer != nullptr)

  87.             delete[] fBuffer;

  88.     }

  89. }

  90. 

  91. void CarlaEngineAudioPort::initBuffer(CarlaEngine* const)

  92. {

  93.     if (kProcessMode == PROCESS_MODE_PATCHBAY && ! kIsInput)

  94.         carla_zeroFloat(fBuffer, PATCHBAY_BUFFER_SIZE);

  95. }

  96. 

  97. // -------------------------------------------------------------------------------------------------------------------

  98. // Carla Engine Event port

  99. 

  100. CarlaEngineEventPort::CarlaEngineEventPort(const bool isInput, const ProcessMode processMode)

  101.     : CarlaEnginePort(isInput, processMode),

  102.       kMaxEventCount(processMode == PROCESS_MODE_CONTINUOUS_RACK ? RACK_EVENT_COUNT : PATCHBAY_EVENT_COUNT),

  103.       fBuffer(nullptr)

  104. {

  105.     carla_debug("CarlaEngineEventPort::CarlaEngineEventPort(%s, %s)", bool2str(isInput), ProcessMode2Str(processMode));

  106. 

  107.     if (kProcessMode == PROCESS_MODE_PATCHBAY || kProcessMode == PROCESS_MODE_BRIDGE)

  108.         fBuffer = new EngineEvent[kMaxEventCount];

  109. }

  110. 

  111. CarlaEngineEventPort::~CarlaEngineEventPort()

  112. {

  113.     carla_debug("CarlaEngineEventPort::~CarlaEngineEventPort()");

  114. 

  115.     if (kProcessMode == PROCESS_MODE_PATCHBAY || kProcessMode == PROCESS_MODE_BRIDGE)

  116.     {

  117.         CARLA_ASSERT(fBuffer != nullptr);

  118. 

  119.         if (fBuffer != nullptr)

  120.             delete[] fBuffer;

  121.     }

  122. }

  123. 

  124. void CarlaEngineEventPort::initBuffer(CarlaEngine* const engine)

  125. {

  126.     CARLA_ASSERT(engine != nullptr);

  127. 

  128.     if (engine == nullptr)

  129.         return;

  130. 

  131. #ifndef BUILD_BRIDGE

  132.     if (kProcessMode == PROCESS_MODE_CONTINUOUS_RACK)

  133.         fBuffer = engine->getRackEventBuffer(kIsInput);

  134.     else

  135. #endif

  136.         if ((kProcessMode == PROCESS_MODE_PATCHBAY || kProcessMode == PROCESS_MODE_BRIDGE) && ! kIsInput)

  137.             carla_zeroStruct<EngineEvent>(fBuffer, kMaxEventCount);

  138. }

  139. 

  140. uint32_t CarlaEngineEventPort::getEventCount()

  141. {

  142.     CARLA_ASSERT(kIsInput);

  143.     CARLA_ASSERT(fBuffer != nullptr);

  144.     CARLA_ASSERT(kProcessMode == PROCESS_MODE_CONTINUOUS_RACK || kProcessMode == PROCESS_MODE_PATCHBAY || kProcessMode == PROCESS_MODE_BRIDGE);

  145. 

  146.     if (! kIsInput)

  147.         return 0;

  148.     if (fBuffer == nullptr)

  149.         return 0;

  150.     if (kProcessMode != PROCESS_MODE_CONTINUOUS_RACK && kProcessMode != PROCESS_MODE_PATCHBAY && kProcessMode != PROCESS_MODE_BRIDGE)

  151.         return 0;

  152. 

  153.     uint32_t count = 0;

  154.     const EngineEvent* const events = fBuffer;

  155. 

  156.     for (uint32_t i=0; i < kMaxEventCount; ++i, ++count)

  157.     {

  158.         if (events[i].type == kEngineEventTypeNull)

  159.             break;

  160.     }

  161. 

  162.     return count;

  163. }

  164. 

  165. const EngineEvent& CarlaEngineEventPort::getEvent(const uint32_t index)

  166. {

  167.     CARLA_ASSERT(kIsInput);

  168.     CARLA_ASSERT(fBuffer != nullptr);

  169.     CARLA_ASSERT(kProcessMode == PROCESS_MODE_CONTINUOUS_RACK || kProcessMode == PROCESS_MODE_PATCHBAY || kProcessMode == PROCESS_MODE_BRIDGE);

  170.     CARLA_ASSERT(index < kMaxEventCount);

  171. 

  172.     if (! kIsInput)

  173.         return kFallbackEngineEvent;

  174.     if (fBuffer == nullptr)

  175.         return kFallbackEngineEvent;

  176.     if (kProcessMode != PROCESS_MODE_CONTINUOUS_RACK && kProcessMode != PROCESS_MODE_PATCHBAY && kProcessMode != PROCESS_MODE_BRIDGE)

  177.         return kFallbackEngineEvent;

  178.     if (index >= kMaxEventCount)

  179.         return kFallbackEngineEvent;

  180. 

  181.     return fBuffer[index];

  182. }

  183. 

  184. void CarlaEngineEventPort::writeControlEvent(const uint32_t time, const uint8_t channel, const EngineControlEventType type, const uint16_t param, const float value)

  185. {

  186.     CARLA_ASSERT(! kIsInput);

  187.     CARLA_ASSERT(fBuffer != nullptr);

  188.     CARLA_ASSERT(kProcessMode == PROCESS_MODE_CONTINUOUS_RACK || kProcessMode == PROCESS_MODE_PATCHBAY || kProcessMode == PROCESS_MODE_BRIDGE);

  189.     CARLA_ASSERT(type != kEngineControlEventTypeNull);

  190.     CARLA_ASSERT(channel < MAX_MIDI_CHANNELS);

  191.     CARLA_SAFE_ASSERT(value >= 0.0f && value <= 1.0f);

  192. 

  193.     if (kIsInput)

  194.         return;

  195.     if (fBuffer == nullptr)

  196.         return;

  197.     if (kProcessMode != PROCESS_MODE_CONTINUOUS_RACK && kProcessMode != PROCESS_MODE_PATCHBAY && kProcessMode != PROCESS_MODE_BRIDGE)

  198.         return;

  199.     if (type == kEngineControlEventTypeNull)

  200.         return;

  201.     if (channel >= MAX_MIDI_CHANNELS)

  202.         return;

  203.     if (type == kEngineControlEventTypeParameter)

  204.     {

  205.         CARLA_ASSERT(! MIDI_IS_CONTROL_BANK_SELECT(param));

  206.     }

  207. 

  208.     for (uint32_t i=0; i < kMaxEventCount; ++i)

  209.     {

  210.         if (fBuffer[i].type != kEngineEventTypeNull)

  211.             continue;

  212. 

  213.         fBuffer[i].type    = kEngineEventTypeControl;

  214.         fBuffer[i].time    = time;

  215.         fBuffer[i].channel = channel;

  216. 

  217.         fBuffer[i].ctrl.type  = type;

  218.         fBuffer[i].ctrl.param = param;

  219.         fBuffer[i].ctrl.value = carla_fixValue<float>(0.0f, 1.0f, value);

  220. 

  221.         return;

  222.     }

  223. 

  224.     carla_stderr2("CarlaEngineEventPort::writeControlEvent() - buffer full");

  225. }

  226. 

  227. void CarlaEngineEventPort::writeMidiEvent(const uint32_t time, const uint8_t channel, const uint8_t port, const uint8_t* const data, const uint8_t size)

  228. {

  229.     CARLA_ASSERT(! kIsInput);

  230.     CARLA_ASSERT(fBuffer != nullptr);

  231.     CARLA_ASSERT(kProcessMode == PROCESS_MODE_CONTINUOUS_RACK || kProcessMode == PROCESS_MODE_PATCHBAY || kProcessMode == PROCESS_MODE_BRIDGE);

  232.     CARLA_ASSERT(channel < MAX_MIDI_CHANNELS);

  233.     CARLA_ASSERT(data != nullptr);

  234.     CARLA_ASSERT(size > 0);

  235. 

  236.     if (kIsInput)

  237.         return;

  238.     if (fBuffer == nullptr)

  239.         return;

  240.     if (kProcessMode != PROCESS_MODE_CONTINUOUS_RACK && kProcessMode != PROCESS_MODE_PATCHBAY && kProcessMode != PROCESS_MODE_BRIDGE)

  241.         return;

  242.     if (channel >= MAX_MIDI_CHANNELS)

  243.         return;

  244.     if (data == nullptr)

  245.         return;

  246.     if (size == 0)

  247.         return;

  248.     if (size > 4)

  249.         return;

  250. 

  251.     for (uint32_t i=0; i < kMaxEventCount; ++i)

  252.     {

  253.         if (fBuffer[i].type != kEngineEventTypeNull)

  254.             continue;

  255. 

  256.         fBuffer[i].type    = kEngineEventTypeMidi;

  257.         fBuffer[i].time    = time;

  258.         fBuffer[i].channel = channel;

  259. 

  260.         fBuffer[i].midi.port = port;

  261.         fBuffer[i].midi.size = size;

  262. 

  263.         carla_copy<uint8_t>(fBuffer[i].midi.data, data, size);

  264. 

  265.         return;

  266.     }

  267. 

  268.     carla_stderr2("CarlaEngineEventPort::writeMidiEvent() - buffer full");

  269. }

  270. 

  271. // -------------------------------------------------------------------------------------------------------------------

  272. // Carla Engine client (Abstract)

  273. 

  274. CarlaEngineClient::CarlaEngineClient(const EngineType engineType, const ProcessMode processMode)

  275.     : kEngineType(engineType),

  276.       kProcessMode(processMode),

  277.       fActive(false),

  278.       fLatency(0)

  279. {

  280.     CARLA_ASSERT(engineType != kEngineTypeNull);

  281.     carla_debug("CarlaEngineClient::CarlaEngineClient(%s, %s)", EngineType2Str(engineType), ProcessMode2Str(processMode));

  282. }

  283. 

  284. CarlaEngineClient::~CarlaEngineClient()

  285. {

  286.     CARLA_ASSERT(! fActive);

  287.     carla_debug("CarlaEngineClient::~CarlaEngineClient()");

  288. }

  289. 

  290. void CarlaEngineClient::activate()

  291. {

  292.     CARLA_ASSERT(! fActive);

  293.     carla_debug("CarlaEngineClient::activate()");

  294. 

  295.     fActive = true;

  296. }

  297. 

  298. void CarlaEngineClient::deactivate()

  299. {

  300.     CARLA_ASSERT(fActive);

  301.     carla_debug("CarlaEngineClient::deactivate()");

  302. 

  303.     fActive = false;

  304. }

  305. 

  306. bool CarlaEngineClient::isActive() const

  307. {

  308.     carla_debug("CarlaEngineClient::isActive()");

  309. 

  310.     return fActive;

  311. }

  312. 

  313. bool CarlaEngineClient::isOk() const

  314. {

  315.     carla_debug("CarlaEngineClient::isOk()");

  316. 

  317.     return true;

  318. }

  319. 

  320. uint32_t CarlaEngineClient::getLatency() const

  321. {

  322.     return fLatency;

  323. }

  324. 

  325. void CarlaEngineClient::setLatency(const uint32_t samples)

  326. {

  327.     fLatency = samples;

  328. }

  329. 

  330. CarlaEnginePort* CarlaEngineClient::addPort(const EnginePortType portType, const char* const name, const bool isInput)

  331. {

  332.     carla_debug("CarlaEngineClient::addPort(%s, \"%s\", %s)", EnginePortType2Str(portType), name, bool2str(isInput));

  333. 

  334.     switch (portType)

  335.     {

  336.     case kEnginePortTypeNull:

  337.         break;

  338.     case kEnginePortTypeAudio:

  339.         return new CarlaEngineAudioPort(isInput, kProcessMode);

  340.     case kEnginePortTypeEvent:

  341.         return new CarlaEngineEventPort(isInput, kProcessMode);

  342.     }

  343. 

  344.     carla_stderr("CarlaEngineClient::addPort(%i, \"%s\", %s) - invalid type", portType, name, bool2str(isInput));

  345.     return nullptr;

  346. }

  347. 

  348. // -------------------------------------------------------------------------------------------------------------------

  349. // Carla Engine

  350. 

  351. CarlaEngine::CarlaEngine()

  352.     : fBufferSize(0),

  353.       fSampleRate(0.0),

  354.       kData(new CarlaEngineProtectedData(this))

  355. {

  356.     carla_debug("CarlaEngine::CarlaEngine()");

  357. }

  358. 

  359. CarlaEngine::~CarlaEngine()

  360. {

  361.     carla_debug("CarlaEngine::~CarlaEngine()");

  362. 

  363.     delete kData;

  364. }

  365. 

  366. // -----------------------------------------------------------------------

  367. // Helpers

  368. 

  369. void doPluginRemove(CarlaEngineProtectedData* const kData, const bool unlock)

  370. {

  371.     CARLA_ASSERT(kData->curPluginCount > 0);

  372.     kData->curPluginCount--;

  373. 

  374.     const unsigned int id = kData->nextAction.pluginId;

  375. 

  376.     // reset current plugin

  377.     kData->plugins[id].plugin = nullptr;

  378. 

  379.     CarlaPlugin* plugin;

  380. 

  381.     // move all plugins 1 spot backwards

  382.     for (unsigned int i=id; i < kData->curPluginCount; ++i)

  383.     {

  384.         plugin = kData->plugins[i+1].plugin;

  385. 

  386.         CARLA_ASSERT(plugin);

  387. 

  388.         if (plugin == nullptr)

  389.             break;

  390. 

  391.         plugin->setId(i);

  392. 

  393.         kData->plugins[i].plugin      = plugin;

  394.         kData->plugins[i].insPeak[0]  = 0.0f;

  395.         kData->plugins[i].insPeak[1]  = 0.0f;

  396.         kData->plugins[i].outsPeak[0] = 0.0f;

  397.         kData->plugins[i].outsPeak[1] = 0.0f;

  398.     }

  399. 

  400.     kData->nextAction.opcode = EnginePostActionNull;

  401. 

  402.     if (unlock)

  403.         kData->nextAction.mutex.unlock();

  404. }

  405. 

  406. void doPluginsSwitch(CarlaEngineProtectedData* const kData, const bool unlock)

  407. {

  408.     CARLA_ASSERT(kData->curPluginCount >= 2);

  409. 

  410.     const unsigned int idA = kData->nextAction.pluginId;

  411.     const unsigned int idB = kData->nextAction.value;

  412. 

  413.     CarlaPlugin* const tmp = kData->plugins[idA].plugin;

  414.     kData->plugins[idA].plugin = kData->plugins[idB].plugin;

  415.     kData->plugins[idB].plugin = tmp;

  416. 

  417.     kData->nextAction.opcode = EnginePostActionNull;

  418. 

  419.     if (unlock)

  420.         kData->nextAction.mutex.unlock();

  421. }

  422. 

  423. const char* findDSSIGUI(const char* const filename, const char* const label)

  424. {

  425.     QString guiFilename;

  426.     guiFilename.clear();

  427. 

  428.     QString pluginDir(filename);

  429.     pluginDir.resize(pluginDir.lastIndexOf("."));

  430. 

  431.     QString shortName = QFileInfo(pluginDir).baseName();

  432. 

  433.     QString checkLabel = QString(label);

  434.     QString checkSName = shortName;

  435. 

  436.     if (! checkLabel.endsWith("_")) checkLabel += "_";

  437.     if (! checkSName.endsWith("_")) checkSName += "_";

  438. 

  439.     QStringList guiFiles = QDir(pluginDir).entryList();

  440. 

  441.     foreach (const QString& gui, guiFiles)

  442.     {

  443.         if (gui.startsWith(checkLabel) || gui.startsWith(checkSName))

  444.         {

  445.             QFileInfo finalname(pluginDir + QDir::separator() + gui);

  446.             guiFilename = finalname.absoluteFilePath();

  447.             break;

  448.         }

  449.     }

  450. 

  451.     if (guiFilename.isEmpty())

  452.         return nullptr;

  453. 

  454.     return carla_strdup(guiFilename.toUtf8().constData());

  455. }

  456. 

  457. // -----------------------------------------------------------------------

  458. // Static values and calls

  459. 

  460. unsigned int CarlaEngine::getDriverCount()

  461. {

  462.     carla_debug("CarlaEngine::getDriverCount()");

  463. 

  464.     unsigned int count = 1;

  465. 

  466. #ifdef WANT_RTAUDIO

  467.     count += getRtAudioApiCount();

  468. #endif

  469. 

  470.     return count;

  471. }

  472. 

  473. const char* CarlaEngine::getDriverName(unsigned int index)

  474. {

  475.     carla_debug("CarlaEngine::getDriverName(%i)", index);

  476. 

  477.     if (index == 0)

  478.         return "JACK";

  479.     else

  480.         index -= 1;

  481. 

  482. #ifdef WANT_RTAUDIO

  483.     if (index < getRtAudioApiCount())

  484.         return getRtAudioApiName(index);

  485. #endif

  486. 

  487.     carla_stderr("CarlaEngine::getDriverName(%i) - invalid index", index);

  488.     return nullptr;

  489. }

  490. 

  491. CarlaEngine* CarlaEngine::newDriverByName(const char* const driverName)

  492. {

  493.     carla_debug("CarlaEngine::newDriverByName(\"%s\")", driverName);

  494. 

  495.     if (std::strcmp(driverName, "JACK") == 0)

  496.         return newJack();

  497. 

  498. #ifdef WANT_RTAUDIO

  499. # ifdef __LINUX_ALSA__

  500.     if (std::strcmp(driverName, "ALSA") == 0)

  501.         return newRtAudio(RTAUDIO_LINUX_ALSA);

  502. # endif

  503. # ifdef __LINUX_PULSE__

  504.     if (std::strcmp(driverName, "PulseAudio") == 0)

  505.         return newRtAudio(RTAUDIO_LINUX_PULSE);

  506. # endif

  507. # ifdef __LINUX_OSS__

  508.     if (std::strcmp(driverName, "OSS") == 0)

  509.         return newRtAudio(RTAUDIO_LINUX_OSS);

  510. # endif

  511. # ifdef __UNIX_JACK__

  512.     if (std::strncmp(driverName, "JACK ", 5) == 0)

  513.         return newRtAudio(RTAUDIO_UNIX_JACK);

  514. # endif

  515. # ifdef __MACOSX_CORE__

  516.     if (std::strcmp(driverName, "CoreAudio") == 0)

  517.         return newRtAudio(RTAUDIO_MACOSX_CORE);

  518. # endif

  519. # ifdef __WINDOWS_ASIO__

  520.     if (std::strcmp(driverName, "ASIO") == 0)

  521.         return newRtAudio(RTAUDIO_WINDOWS_ASIO);

  522. # endif

  523. # ifdef __WINDOWS_DS__

  524.     if (std::strcmp(driverName, "DirectSound") == 0)

  525.         return newRtAudio(RTAUDIO_WINDOWS_DS);

  526. # endif

  527. #endif

  528. 

  529.     return nullptr;

  530. }

  531. 

  532. // -----------------------------------------------------------------------

  533. // Maximum values

  534. 

  535. unsigned int CarlaEngine::maxClientNameSize() const

  536. {

  537.     return STR_MAX/2;

  538. }

  539. 

  540. unsigned int CarlaEngine::maxPortNameSize() const

  541. {

  542.     return STR_MAX;

  543. }

  544. 

  545. unsigned int CarlaEngine::currentPluginCount() const

  546. {

  547.     return kData->curPluginCount;

  548. }

  549. 

  550. unsigned int CarlaEngine::maxPluginNumber() const

  551. {

  552.     return kData->maxPluginNumber;

  553. }

  554. 

  555. // -----------------------------------------------------------------------

  556. // Virtual, per-engine type calls

  557. 

  558. bool CarlaEngine::init(const char* const clientName)

  559. {

  560.     CARLA_ASSERT(kData->plugins == nullptr);

  561.     carla_debug("CarlaEngine::init(\"%s\")", clientName);

  562. 

  563. #ifndef BUILD_BRIDGE

  564.     CARLA_ASSERT(kData->rack.in  == nullptr);

  565.     CARLA_ASSERT(kData->rack.out == nullptr);

  566. #endif

  567. 

  568.     fName = clientName;

  569.     fName.toBasic();

  570. 

  571.     fTimeInfo.clear();

  572. 

  573.     kData->aboutToClose = false;

  574.     kData->curPluginCount = 0;

  575. 

  576. #ifdef BUILD_BRIDGE

  577.     kData->maxPluginNumber = 1;

  578. #else

  579.     switch (fOptions.processMode)

  580.     {

  581.     case PROCESS_MODE_CONTINUOUS_RACK:

  582.         kData->maxPluginNumber = MAX_RACK_PLUGINS;

  583.         kData->rack.in  = new EngineEvent[RACK_EVENT_COUNT];

  584.         kData->rack.out = new EngineEvent[RACK_EVENT_COUNT];

  585.         break;

  586.     case PROCESS_MODE_PATCHBAY:

  587.         kData->maxPluginNumber = MAX_PATCHBAY_PLUGINS;

  588.         break;

  589.     default:

  590.         kData->maxPluginNumber = MAX_DEFAULT_PLUGINS;

  591.         break;

  592.     }

  593. #endif

  594. 

  595.     kData->plugins = new EnginePluginData[kData->maxPluginNumber];

  596. 

  597.     kData->osc.init(clientName);

  598. 

  599. #ifndef BUILD_BRIDGE

  600.     kData->oscData = kData->osc.getControlData();

  601. #else

  602.     kData->oscData = nullptr; // set later in setOscBridgeData()

  603. #endif

  604. 

  605. #ifndef BUILD_BRIDGE

  606.     if (type() != kEngineTypePlugin)

  607.         carla_setprocname(clientName);

  608. #endif

  609. 

  610.     kData->nextAction.ready();

  611.     kData->thread.startNow();

  612. 

  613.     return true;

  614. }

  615. 

  616. bool CarlaEngine::close()

  617. {

  618.     CARLA_ASSERT(kData->plugins != nullptr);

  619.     carla_debug("CarlaEngine::close()");

  620. 

  621.     kData->thread.stopNow();

  622.     kData->nextAction.ready();

  623. 

  624. #ifndef BUILD_BRIDGE

  625.     osc_send_control_exit();

  626. #endif

  627.     kData->osc.close();

  628. 

  629.     kData->oscData = nullptr;

  630. 

  631.     kData->aboutToClose = true;

  632.     kData->curPluginCount = 0;

  633.     kData->maxPluginNumber = 0;

  634. 

  635.     if (kData->plugins != nullptr)

  636.     {

  637.         delete[] kData->plugins;

  638.         kData->plugins = nullptr;

  639.     }

  640. 

  641. #ifndef BUILD_BRIDGE

  642.     if (kData->rack.in != nullptr)

  643.     {

  644.         delete[] kData->rack.in;

  645.         kData->rack.in = nullptr;

  646.     }

  647. 

  648.     if (kData->rack.out != nullptr)

  649.     {

  650.         delete[] kData->rack.out;

  651.         kData->rack.out = nullptr;

  652.     }

  653. #endif

  654. 

  655.     fName.clear();

  656. 

  657.     return true;

  658. }

  659. 

  660. void CarlaEngine::idle()

  661. {

  662.     CARLA_ASSERT(kData->plugins != nullptr);

  663. 

  664.     for (unsigned int i=0; i < kData->curPluginCount; ++i)

  665.     {

  666.         CarlaPlugin* const plugin = kData->plugins[i].plugin;

  667. 

  668.         if (plugin != nullptr && plugin->enabled())

  669.             plugin->idleGui();

  670.     }

  671. }

  672. 

  673. CarlaEngineClient* CarlaEngine::addClient(CarlaPlugin* const)

  674. {

  675.     return new CarlaEngineClient(type(), fOptions.processMode);

  676. }

  677. 

  678. // -----------------------------------------------------------------------

  679. // Plugin management

  680. 

  681. bool CarlaEngine::addPlugin(const BinaryType btype, const PluginType ptype, const char* const filename, const char* const name, const char* const label, const void* const extra)

  682. {

  683.     CARLA_ASSERT(btype != BINARY_NONE);

  684.     CARLA_ASSERT(ptype != PLUGIN_NONE);

  685.     carla_debug("CarlaEngine::addPlugin(%s, %s, \"%s\", \"%s\", \"%s\", %p)", BinaryType2Str(btype), PluginType2Str(ptype), filename, name, label, extra);

  686. 

  687.     if (kData->curPluginCount == kData->maxPluginNumber)

  688.     {

  689.         setLastError("Maximum number of plugins reached");

  690.         return false;

  691.     }

  692. 

  693.     const unsigned int id = kData->curPluginCount;

  694. 

  695.     CarlaPlugin::Initializer init = {

  696.         this,

  697.         id,

  698.         filename,

  699.         name,

  700.         label

  701.     };

  702. 

  703.     CarlaPlugin* plugin = nullptr;

  704. 

  705. #ifndef BUILD_BRIDGE

  706.     const char* bridgeBinary;

  707. 

  708.     switch (btype)

  709.     {

  710.     case BINARY_POSIX32:

  711.         bridgeBinary = fOptions.bridge_posix32.isNotEmpty() ? (const char*)fOptions.bridge_posix32 : nullptr;

  712.         break;

  713.     case BINARY_POSIX64:

  714.         bridgeBinary = fOptions.bridge_posix64.isNotEmpty() ? (const char*)fOptions.bridge_posix64 : nullptr;

  715.         break;

  716.     case BINARY_WIN32:

  717.         bridgeBinary = fOptions.bridge_win32.isNotEmpty() ? (const char*)fOptions.bridge_win32 : nullptr;

  718.         break;

  719.     case BINARY_WIN64:

  720.         bridgeBinary = fOptions.bridge_win64.isNotEmpty() ? (const char*)fOptions.bridge_win64 : nullptr;

  721.         break;

  722.     default:

  723.         bridgeBinary = nullptr;

  724.         break;

  725.     }

  726. 

  727. #ifndef Q_OS_WIN

  728.     if (btype == BINARY_NATIVE && fOptions.bridge_native.isNotEmpty())

  729.         bridgeBinary = (const char*)fOptions.bridge_native;

  730. #endif

  731. 

  732.     if (bridgeBinary != nullptr && (btype != BINARY_NATIVE || fOptions.preferPluginBridges))

  733.     {

  734.         plugin = CarlaPlugin::newBridge(init, btype, ptype, bridgeBinary);

  735.     }

  736.     else

  737. #endif // BUILD_BRIDGE

  738.     {

  739.         switch (ptype)

  740.         {

  741.         case PLUGIN_NONE:

  742.             break;

  743. 

  744.         case PLUGIN_INTERNAL:

  745.             plugin = CarlaPlugin::newNative(init);

  746.             break;

  747. 

  748.         case PLUGIN_LADSPA:

  749.             plugin = CarlaPlugin::newLADSPA(init, (const LADSPA_RDF_Descriptor*)extra);

  750.             break;

  751. 

  752.         case PLUGIN_DSSI:

  753.             plugin = CarlaPlugin::newDSSI(init, (const char*)extra);

  754.             break;

  755. 

  756.         case PLUGIN_LV2:

  757.             plugin = CarlaPlugin::newLV2(init);

  758.             break;

  759. 

  760.         case PLUGIN_VST:

  761.             plugin = CarlaPlugin::newVST(init);

  762.             break;

  763. 

  764.         case PLUGIN_VST3:

  765.             plugin = CarlaPlugin::newVST3(init);

  766.             break;

  767. 

  768.         case PLUGIN_GIG:

  769.             plugin = CarlaPlugin::newGIG(init, (extra != nullptr));

  770.             break;

  771. 

  772.         case PLUGIN_SF2:

  773.             plugin = CarlaPlugin::newSF2(init, (extra != nullptr));

  774.             break;

  775. 

  776.         case PLUGIN_SFZ:

  777.             plugin = CarlaPlugin::newSFZ(init, (extra != nullptr));

  778.             break;

  779.         }

  780.     }

  781. 

  782.     if (plugin == nullptr)

  783.         return false;

  784. 

  785.     plugin->registerToOscClient();

  786. 

  787.     kData->plugins[id].plugin      = plugin;

  788.     kData->plugins[id].insPeak[0]  = 0.0f;

  789.     kData->plugins[id].insPeak[1]  = 0.0f;

  790.     kData->plugins[id].outsPeak[0] = 0.0f;

  791.     kData->plugins[id].outsPeak[1] = 0.0f;

  792. 

  793.     kData->curPluginCount += 1;

  794. 

  795.     callback(CALLBACK_PLUGIN_ADDED, id, 0, 0, 0.0f, plugin->name());

  796.     return true;

  797. }

  798. 

  799. bool CarlaEngine::removePlugin(const unsigned int id)

  800. {

  801.     CARLA_ASSERT(kData->curPluginCount > 0);

  802.     CARLA_ASSERT(id < kData->curPluginCount);

  803.     CARLA_ASSERT(kData->plugins != nullptr);

  804.     carla_debug("CarlaEngine::removePlugin(%i)", id);

  805. 

  806.     if (kData->plugins == nullptr)

  807.     {

  808.         setLastError("Critical error: no plugins are currently loaded!");

  809.         return false;

  810.     }

  811. 

  812.     CarlaPlugin* const plugin = kData->plugins[id].plugin;

  813. 

  814.     if (plugin == nullptr)

  815.     {

  816.         setLastError("Could not find plugin to remove");

  817.         return false;

  818.     }

  819. 

  820.     CARLA_ASSERT(plugin->id() == id);

  821. 

  822.     kData->thread.stopNow();

  823. 

  824.     kData->nextAction.pluginId = id;

  825.     kData->nextAction.opcode   = EnginePostActionRemovePlugin;

  826. 

  827.     kData->nextAction.mutex.lock();

  828. 

  829.     if (isRunning())

  830.     {

  831.         carla_stderr("CarlaEngine::removePlugin(%i) - remove blocking START", id);

  832.         // block wait for unlock on proccessing side

  833.         kData->nextAction.mutex.lock();

  834.         carla_stderr("CarlaEngine::removePlugin(%i) - remove blocking DONE", id);

  835.     }

  836.     else

  837.     {

  838.         doPluginRemove(kData, false);

  839.     }

  840. 

  841. #ifndef BUILD_BRIDGE

  842.     if (isOscControlRegistered())

  843.         osc_send_control_remove_plugin(id);

  844. #endif

  845. 

  846.     delete plugin;

  847. 

  848.     kData->nextAction.mutex.unlock();

  849. 

  850.     if (isRunning() && ! kData->aboutToClose)

  851.         kData->thread.startNow();

  852. 

  853.     callback(CALLBACK_PLUGIN_REMOVED, id, 0, 0, 0.0f, nullptr);

  854.     return true;

  855. }

  856. 

  857. void CarlaEngine::removeAllPlugins()

  858. {

  859.     carla_debug("CarlaEngine::removeAllPlugins() - START");

  860. 

  861.     kData->thread.stopNow();

  862. 

  863.     if (kData->curPluginCount > 0)

  864.     {

  865.         const unsigned int oldCount = kData->curPluginCount;

  866. 

  867.         kData->curPluginCount = 0;

  868. 

  869.         for (unsigned int i=0; i < oldCount; ++i)

  870.         {

  871.             CarlaPlugin* const plugin = kData->plugins[i].plugin;

  872. 

  873.             CARLA_ASSERT(plugin != nullptr);

  874. 

  875.             kData->plugins[i].plugin = nullptr;

  876. 

  877.             if (plugin != nullptr)

  878.                 delete plugin;

  879. 

  880.             // clear this plugin

  881.             kData->plugins[i].insPeak[0]  = 0.0f;

  882.             kData->plugins[i].insPeak[1]  = 0.0f;

  883.             kData->plugins[i].outsPeak[0] = 0.0f;

  884.             kData->plugins[i].outsPeak[1] = 0.0f;

  885.         }

  886.     }

  887. 

  888.     if (isRunning() && ! kData->aboutToClose)

  889.         kData->thread.startNow();

  890. 

  891.     carla_debug("CarlaEngine::removeAllPlugins() - END");

  892. }

  893. 

  894. const char* CarlaEngine::renamePlugin(const unsigned int id, const char* const newName)

  895. {

  896.     CARLA_ASSERT(kData->curPluginCount > 0);

  897.     CARLA_ASSERT(id < kData->curPluginCount);

  898.     CARLA_ASSERT(kData->plugins != nullptr);

  899.     CARLA_ASSERT(newName != nullptr);

  900.     carla_debug("CarlaEngine::renamePlugin(%i, \"%s\")", id, newName);

  901. 

  902.     if (kData->plugins == nullptr)

  903.     {

  904.         setLastError("Critical error: no plugins are currently loaded!");

  905.         return nullptr;

  906.     }

  907. 

  908.     CarlaPlugin* const plugin = kData->plugins[id].plugin;

  909. 

  910.     if (plugin == nullptr)

  911.     {

  912.         carla_stderr("CarlaEngine::clonePlugin(%i) - could not find plugin", id);

  913.         return nullptr;

  914.     }

  915. 

  916.     CARLA_ASSERT(plugin->id() == id);

  917. 

  918.     if (const char* const name = getUniquePluginName(newName))

  919.     {

  920.         plugin->setName(name);

  921. 

  922.         return name;

  923.     }

  924. 

  925.     return nullptr;

  926. }

  927. 

  928. bool CarlaEngine::clonePlugin(const unsigned int id)

  929. {

  930.     CARLA_ASSERT(kData->curPluginCount > 0);

  931.     CARLA_ASSERT(id < kData->curPluginCount);

  932.     CARLA_ASSERT(kData->plugins != nullptr);

  933.     carla_debug("CarlaEngine::clonePlugin(%i)", id);

  934. 

  935.     if (kData->plugins == nullptr)

  936.     {

  937.         setLastError("Critical error: no plugins are currently loaded!");

  938.         return false;

  939.     }

  940. 

  941.     CarlaPlugin* const plugin = kData->plugins[id].plugin;

  942. 

  943.     if (plugin == nullptr)

  944.     {

  945.         carla_stderr("CarlaEngine::clonePlugin(%i) - could not find plugin", id);

  946.         return false;

  947.     }

  948. 

  949.     CARLA_ASSERT(plugin->id() == id);

  950. 

  951.     const SaveState& saveState(plugin->getSaveState());

  952. 

  953.     char label[STR_MAX+1] = { '\0' };

  954.     plugin->getLabel(label);

  955. 

  956.     BinaryType binaryType = BINARY_NATIVE;

  957. 

  958. #ifndef BUILD_BRIDGE

  959.     if (plugin->hints() & PLUGIN_IS_BRIDGE)

  960.         binaryType = CarlaPluginGetBridgeBinaryType(plugin);

  961. #endif

  962. 

  963.     const unsigned int pluginsBefore(kData->curPluginCount);

  964. 

  965.     if (! addPlugin(binaryType, plugin->type(), plugin->filename(), plugin->name(), label, plugin->getExtraStuff()))

  966.         return false;

  967. 

  968.     CARLA_ASSERT(pluginsBefore+1 == kData->curPluginCount);

  969. 

  970.     CarlaPlugin* const newPlugin = kData->plugins[kData->curPluginCount-1].plugin;

  971. 

  972.     CARLA_ASSERT(newPlugin != nullptr);

  973. 

  974.     newPlugin->loadSaveState(saveState);

  975. 

  976.     return true;

  977. }

  978. 

  979. bool CarlaEngine::replacePlugin(const unsigned int id)

  980. {

  981.     CARLA_ASSERT(kData->curPluginCount > 0);

  982.     CARLA_ASSERT(id < kData->curPluginCount);

  983.     CARLA_ASSERT(kData->plugins != nullptr);

  984.     carla_debug("CarlaEngine::replacePlugin(%i)", id);

  985. 

  986.     setLastError("Not implemented yet");

  987.     return false;

  988. }

  989. 

  990. bool CarlaEngine::switchPlugins(const unsigned int idA, const unsigned int idB)

  991. {

  992.     CARLA_ASSERT(kData->curPluginCount > 0);

  993.     CARLA_ASSERT(idA < kData->curPluginCount);

  994.     CARLA_ASSERT(idB < kData->curPluginCount);

  995.     CARLA_ASSERT(kData->plugins != nullptr);

  996.     carla_debug("CarlaEngine::switchPlugins(%i)", idA, idB);

  997. 

  998.     if (kData->plugins == nullptr)

  999.     {

  1000.         setLastError("Critical error: no plugins are currently loaded!");

  1001.         return false;

  1002.     }

  1003. 

  1004.     kData->thread.stopNow();

  1005. 

  1006.     kData->nextAction.pluginId = idA;

  1007.     kData->nextAction.value    = idB;

  1008.     kData->nextAction.opcode   = EnginePostActionSwitchPlugins;

  1009. 

  1010.     kData->nextAction.mutex.lock();

  1011. 

  1012.     if (isRunning())

  1013.     {

  1014.         carla_stderr("CarlaEngine::switchPlugins(%i, %i) - switch blocking START", idA, idB);

  1015.         // block wait for unlock on proccessing side

  1016.         kData->nextAction.mutex.lock();

  1017.         carla_stderr("CarlaEngine::switchPlugins(%i, %i) - switch blocking DONE", idA, idB);

  1018.     }

  1019.     else

  1020.     {

  1021.         doPluginsSwitch(kData, false);

  1022.     }

  1023. 

  1024. #ifndef BUILD_BRIDGE // TODO

  1025.     //if (isOscControlRegistered())

  1026.     //    osc_send_control_remove_plugin(id);

  1027. #endif

  1028. 

  1029.     kData->nextAction.mutex.unlock();

  1030. 

  1031.     if (isRunning() && ! kData->aboutToClose)

  1032.         kData->thread.startNow();

  1033. 

  1034.     return true;

  1035. }

  1036. 

  1037. CarlaPlugin* CarlaEngine::getPlugin(const unsigned int id) const

  1038. {

  1039.     CARLA_ASSERT(kData->curPluginCount > 0);

  1040.     CARLA_ASSERT(id < kData->curPluginCount);

  1041.     CARLA_ASSERT(kData->plugins != nullptr);

  1042.     carla_debug("CarlaEngine::getPlugin(%i) [count:%i]", id, kData->curPluginCount);

  1043. 

  1044.     if (id < kData->curPluginCount && kData->plugins != nullptr)

  1045.         return kData->plugins[id].plugin;

  1046. 

  1047.     return nullptr;

  1048. }

  1049. 

  1050. CarlaPlugin* CarlaEngine::getPluginUnchecked(const unsigned int id) const

  1051. {

  1052.     return kData->plugins[id].plugin;

  1053. }

  1054. 

  1055. const char* CarlaEngine::getUniquePluginName(const char* const name)

  1056. {

  1057.     CARLA_ASSERT(kData->maxPluginNumber > 0);

  1058.     CARLA_ASSERT(kData->plugins != nullptr);

  1059.     CARLA_ASSERT(name != nullptr);

  1060.     carla_debug("CarlaEngine::getUniquePluginName(\"%s\")", name);

  1061. 

  1062.     static CarlaString sname;

  1063.     sname = name;

  1064. 

  1065.     if (sname.isEmpty() || kData->plugins == nullptr)

  1066.     {

  1067.         sname = "(No name)";

  1068.         return (const char*)sname;

  1069.     }

  1070. 

  1071.     sname.truncate(maxClientNameSize()-5-1); // 5 = strlen(" (10)")

  1072.     sname.replace(':', '.'); // ':' is used in JACK1 to split client/port names

  1073. 

  1074.     for (unsigned short i=0; i < kData->curPluginCount; ++i)

  1075.     {

  1076.         CARLA_ASSERT(kData->plugins[i].plugin);

  1077. 

  1078.         if (kData->plugins[i].plugin == nullptr)

  1079.             continue;

  1080. 

  1081.         // Check if unique name doesn't exist

  1082.         if (const char* const pluginName = kData->plugins[i].plugin->name())

  1083.         {

  1084.             if (sname != pluginName)

  1085.                 continue;

  1086.         }

  1087. 

  1088.         // Check if string has already been modified

  1089.         {

  1090.             const size_t len = sname.length();

  1091. 

  1092.             // 1 digit, ex: " (2)"

  1093.             if (sname[len-4] == ' ' && sname[len-3] == '(' && sname.isDigit(len-2) && sname[len-1] == ')')

  1094.             {

  1095.                 int number = sname[len-2] - '0';

  1096. 

  1097.                 if (number == 9)

  1098.                 {

  1099.                     // next number is 10, 2 digits

  1100.                     sname.truncate(len-4);

  1101.                     sname += " (10)";

  1102.                     //sname.replace(" (9)", " (10)");

  1103.                 }

  1104.                 else

  1105.                     sname[len-2] = char('0' + number + 1);

  1106. 

  1107.                 continue;

  1108.             }

  1109. 

  1110.             // 2 digits, ex: " (11)"

  1111.             if (sname[len-5] == ' ' && sname[len-4] == '(' && sname.isDigit(len-3) && sname.isDigit(len-2) && sname[len-1] == ')')

  1112.             {

  1113.                 char n2 = sname[len-2];

  1114.                 char n3 = sname[len-3];

  1115. 

  1116.                 if (n2 == '9')

  1117.                 {

  1118.                     n2  = '0';

  1119.                     n3 += 1;

  1120.                 }

  1121.                 else

  1122.                     n2 += 1;

  1123. 

  1124.                 sname[len-2] = n2;

  1125.                 sname[len-3] = n3;

  1126. 

  1127.                 continue;

  1128.             }

  1129.         }

  1130. 

  1131.         // Modify string if not

  1132.         sname += " (2)";

  1133.     }

  1134. 

  1135.     return (const char*)sname;

  1136. }

  1137. 

  1138. // -----------------------------------------------------------------------

  1139. // Project management

  1140. 

  1141. bool CarlaEngine::loadFilename(const char* const filename)

  1142. {

  1143.     CARLA_ASSERT(filename != nullptr);

  1144.     carla_debug("CarlaEngine::loadFilename(\"%s\")", filename);

  1145. 

  1146.     // TODO

  1147.     setLastError("Not implemented yet");

  1148.     return false;

  1149. }

  1150. 

  1151. bool CarlaEngine::loadProject(const char* const filename)

  1152. {

  1153.     CARLA_ASSERT(filename != nullptr);

  1154.     carla_debug("CarlaEngine::loadProject(\"%s\")", filename);

  1155. 

  1156.     QFile file(filename);

  1157. 

  1158.     if (! file.open(QIODevice::ReadOnly | QIODevice::Text))

  1159.         return false;

  1160. 

  1161.     QDomDocument xml;

  1162.     xml.setContent(file.readAll());

  1163.     file.close();

  1164. 

  1165.     QDomNode xmlNode(xml.documentElement());

  1166. 

  1167.     if (xmlNode.toElement().tagName() != "CARLA-PROJECT" && xmlNode.toElement().tagName() != "CARLA-PRESET")

  1168.     {

  1169.         setLastError("Not a valid Carla project or preset file");

  1170.         return false;

  1171.     }

  1172. 

  1173.     const bool isPreset(xmlNode.toElement().tagName() == "CARLA-PRESET");

  1174. 

  1175.     QDomNode node(xmlNode.firstChild());

  1176. 

  1177.     while (! node.isNull())

  1178.     {

  1179.         if (isPreset || node.toElement().tagName() == "Plugin")

  1180.         {

  1181.             const SaveState& saveState(getSaveStateDictFromXML(isPreset ? xmlNode : node));

  1182.             CARLA_ASSERT(saveState.type != nullptr);

  1183. 

  1184.             if (saveState.type == nullptr)

  1185.                 continue;

  1186. 

  1187.             const void* extraStuff = nullptr;

  1188. 

  1189.             if (std::strcmp(saveState.type, "DSSI") == 0)

  1190.                 extraStuff = findDSSIGUI(saveState.binary, saveState.label);

  1191. 

  1192.             // TODO - proper find&load plugins

  1193.             if (addPlugin(getPluginTypeFromString(saveState.type), saveState.binary, saveState.name, saveState.label, extraStuff))

  1194.             {

  1195.                 if (CarlaPlugin* plugin = getPlugin(kData->curPluginCount-1))

  1196.                     plugin->loadSaveState(saveState);

  1197.             }

  1198.         }

  1199. 

  1200.         if (isPreset)

  1201.             break;

  1202. 

  1203.         node = node.nextSibling();

  1204.     }

  1205. 

  1206.     // prevent wrong leak detection on close

  1207.     getSaveStateDictFromXML(QDomNode());

  1208. 

  1209.     return true;

  1210. }

  1211. 

  1212. bool CarlaEngine::saveProject(const char* const filename)

  1213. {

  1214.     CARLA_ASSERT(filename != nullptr);

  1215.     carla_debug("CarlaEngine::saveProject(\"%s\")", filename);

  1216. 

  1217.     QFile file(filename);

  1218. 

  1219.     if (! file.open(QIODevice::WriteOnly | QIODevice::Text))

  1220.         return false;

  1221. 

  1222.     QTextStream out(&file);

  1223.     out << "<?xml version='1.0' encoding='UTF-8'?>\n";

  1224.     out << "<!DOCTYPE CARLA-PROJECT>\n";

  1225.     out << "<CARLA-PROJECT VERSION='1.0'>\n";

  1226. 

  1227.     bool firstPlugin = true;

  1228.     char strBuf[STR_MAX+1];

  1229. 

  1230.     for (unsigned int i=0; i < kData->curPluginCount; ++i)

  1231.     {

  1232.         CarlaPlugin* const plugin = kData->plugins[i].plugin;

  1233. 

  1234.         if (plugin != nullptr && plugin->enabled())

  1235.         {

  1236.             if (! firstPlugin)

  1237.                 out << "\n";

  1238. 

  1239.             plugin->getRealName(strBuf);

  1240. 

  1241.             if (*strBuf != 0)

  1242.                 out << QString(" <!-- %1 -->\n").arg(xmlSafeString(strBuf, true));

  1243. 

  1244.             out << " <Plugin>\n";

  1245.             out << getXMLFromSaveState(plugin->getSaveState());

  1246.             out << " </Plugin>\n";

  1247. 

  1248.             firstPlugin = false;

  1249.         }

  1250.     }

  1251. 

  1252.     out << "</CARLA-PROJECT>\n";

  1253. 

  1254.     file.close();

  1255.     return true;

  1256. }

  1257. 

  1258. // -----------------------------------------------------------------------

  1259. // Information (peaks)

  1260. 

  1261. float CarlaEngine::getInputPeak(const unsigned int pluginId, const unsigned short id) const

  1262. {

  1263.     CARLA_ASSERT(pluginId < kData->curPluginCount);

  1264.     CARLA_ASSERT(id-1 < MAX_PEAKS);

  1265. 

  1266.     if (id == 0 || id > MAX_PEAKS)

  1267.         return 0.0f;

  1268. 

  1269.     return kData->plugins[pluginId].insPeak[id-1];

  1270. }

  1271. 

  1272. float CarlaEngine::getOutputPeak(const unsigned int pluginId, const unsigned short id) const

  1273. {

  1274.     CARLA_ASSERT(pluginId < kData->curPluginCount);

  1275.     CARLA_ASSERT(id-1 < MAX_PEAKS);

  1276. 

  1277.     if (id == 0 || id > MAX_PEAKS)

  1278.         return 0.0f;

  1279. 

  1280.     return kData->plugins[pluginId].outsPeak[id-1];

  1281. }

  1282. 

  1283. // -----------------------------------------------------------------------

  1284. // Callback

  1285. 

  1286. void CarlaEngine::callback(const CallbackType action, const unsigned int pluginId, const int value1, const int value2, const float value3, const char* const valueStr)

  1287. {

  1288.     carla_debug("CarlaEngine::callback(%s, %i, %i, %i, %f, \"%s\")", CallbackType2Str(action), pluginId, value1, value2, value3, valueStr);

  1289. 

  1290.     if (kData->callback)

  1291.         kData->callback(kData->callbackPtr, action, pluginId, value1, value2, value3, valueStr);

  1292. }

  1293. 

  1294. void CarlaEngine::setCallback(const CallbackFunc func, void* const ptr)

  1295. {

  1296.     CARLA_ASSERT(func != nullptr);

  1297.     carla_debug("CarlaEngine::setCallback(%p, %p)", func, ptr);

  1298. 

  1299.     kData->callback    = func;

  1300.     kData->callbackPtr = ptr;

  1301. }

  1302. 

  1303. // -----------------------------------------------------------------------

  1304. // Patchbay

  1305. 

  1306. bool CarlaEngine::patchbayConnect(int, int)

  1307. {

  1308.     setLastError("Unsupported operation");

  1309.     return false;

  1310. }

  1311. 

  1312. bool CarlaEngine::patchbayDisconnect(int)

  1313. {

  1314.     setLastError("Unsupported operation");

  1315.     return false;

  1316. }

  1317. 

  1318. void CarlaEngine::patchbayRefresh()

  1319. {

  1320.     // nothing

  1321. }

  1322. 

  1323. // -----------------------------------------------------------------------

  1324. // Transport

  1325. 

  1326. void CarlaEngine::transportPlay()

  1327. {

  1328.     kData->time.playing = true;

  1329. }

  1330. 

  1331. void CarlaEngine::transportPause()

  1332. {

  1333.     kData->time.playing = false;

  1334. }

  1335. 

  1336. void CarlaEngine::transportRelocate(const uint32_t frame)

  1337. {

  1338.     kData->time.frame = frame;

  1339. }

  1340. 

  1341. // -----------------------------------------------------------------------

  1342. // Error handling

  1343. 

  1344. const char* CarlaEngine::getLastError() const

  1345. {

  1346.     return (const char*)kData->lastError;

  1347. }

  1348. 

  1349. void CarlaEngine::setLastError(const char* const error)

  1350. {

  1351.     kData->lastError = error;

  1352. }

  1353. 

  1354. void CarlaEngine::setAboutToClose()

  1355. {

  1356.     carla_debug("CarlaEngine::setAboutToClose()");

  1357.     kData->aboutToClose = true;

  1358. }

  1359. 

  1360. // -----------------------------------------------------------------------

  1361. // Global options

  1362. 

  1363. #define CARLA_ENGINE_SET_OPTION_RUNNING_CHECK \

  1364.     if (isRunning()) \

  1365.         return carla_stderr("CarlaEngine::setOption(%s, %i, \"%s\") - Cannot set this option while engine is running!", OptionsType2Str(option), value, valueStr);

  1366. 

  1367. void CarlaEngine::setOption(const OptionsType option, const int value, const char* const valueStr)

  1368. {

  1369.     carla_debug("CarlaEngine::setOption(%s, %i, \"%s\")", OptionsType2Str(option), value, valueStr);

  1370. 

  1371.     switch (option)

  1372.     {

  1373.     case OPTION_PROCESS_NAME:

  1374.         carla_setprocname(valueStr);

  1375.         break;

  1376. 

  1377.     case OPTION_PROCESS_MODE:

  1378.         CARLA_ENGINE_SET_OPTION_RUNNING_CHECK

  1379. 

  1380.         if (value < PROCESS_MODE_SINGLE_CLIENT || value > PROCESS_MODE_BRIDGE)

  1381.             return carla_stderr("CarlaEngine::setOption(%s, %i, \"%s\") - invalid value", OptionsType2Str(option), value, valueStr);

  1382. 

  1383.         fOptions.processMode = static_cast<ProcessMode>(value);

  1384.         break;

  1385. 

  1386.     case OPTION_TRANSPORT_MODE:

  1387.         // FIXME: Always enable JACK transport for now

  1388. #if 0

  1389.         if (value < CarlaBackend::TRANSPORT_MODE_INTERNAL || value > CarlaBackend::TRANSPORT_MODE_BRIDGE)

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

  1391. 

  1392.         fOptions.transportMode = static_cast<CarlaBackend::TransportMode>(value);

  1393. #endif

  1394.         break;

  1395. 

  1396.     case OPTION_MAX_PARAMETERS:

  1397.         CARLA_ENGINE_SET_OPTION_RUNNING_CHECK

  1398. 

  1399.         if (value < 0)

  1400.             return; // TODO error here

  1401. 

  1402.         fOptions.maxParameters = static_cast<uint>(value);

  1403.         break;

  1404. 

  1405.     case OPTION_PREFERRED_BUFFER_SIZE:

  1406.         CARLA_ENGINE_SET_OPTION_RUNNING_CHECK

  1407.         fOptions.preferredBufferSize = static_cast<uint>(value);

  1408.         break;

  1409. 

  1410.     case OPTION_PREFERRED_SAMPLE_RATE:

  1411.         CARLA_ENGINE_SET_OPTION_RUNNING_CHECK

  1412.         fOptions.preferredSampleRate = static_cast<uint>(value);

  1413.         break;

  1414. 

  1415.     case OPTION_FORCE_STEREO:

  1416.         CARLA_ENGINE_SET_OPTION_RUNNING_CHECK

  1417.         fOptions.forceStereo = (value != 0);

  1418.         break;

  1419. 

  1420. #ifdef WANT_DSSI

  1421.     case OPTION_USE_DSSI_VST_CHUNKS:

  1422.         CARLA_ENGINE_SET_OPTION_RUNNING_CHECK

  1423.         fOptions.useDssiVstChunks = (value != 0);

  1424.         break;

  1425. #endif

  1426. 

  1427.     case OPTION_PREFER_PLUGIN_BRIDGES:

  1428.         CARLA_ENGINE_SET_OPTION_RUNNING_CHECK

  1429.         fOptions.preferPluginBridges = (value != 0);

  1430.         break;

  1431. 

  1432.     case OPTION_PREFER_UI_BRIDGES:

  1433.         CARLA_ENGINE_SET_OPTION_RUNNING_CHECK

  1434.         fOptions.preferUiBridges = (value != 0);

  1435.         break;

  1436. 

  1437.     case OPTION_OSC_UI_TIMEOUT:

  1438.         CARLA_ENGINE_SET_OPTION_RUNNING_CHECK

  1439.         fOptions.oscUiTimeout = static_cast<uint>(value);

  1440.         break;

  1441. 

  1442. #ifndef BUILD_BRIDGE

  1443.     case OPTION_PATH_BRIDGE_NATIVE:

  1444.         fOptions.bridge_native = valueStr;

  1445.         break;

  1446.     case OPTION_PATH_BRIDGE_POSIX32:

  1447.         fOptions.bridge_posix32 = valueStr;

  1448.         break;

  1449.     case OPTION_PATH_BRIDGE_POSIX64:

  1450.         fOptions.bridge_posix64 = valueStr;

  1451.         break;

  1452.     case OPTION_PATH_BRIDGE_WIN32:

  1453.         fOptions.bridge_win32 = valueStr;

  1454.         break;

  1455.     case OPTION_PATH_BRIDGE_WIN64:

  1456.         fOptions.bridge_win64 = valueStr;

  1457.         break;

  1458. #endif

  1459. 

  1460. #ifdef WANT_LV2

  1461.     case OPTION_PATH_BRIDGE_LV2_GTK2:

  1462.         fOptions.bridge_lv2Gtk2 = valueStr;

  1463.         break;

  1464.     case OPTION_PATH_BRIDGE_LV2_GTK3:

  1465.         fOptions.bridge_lv2Gtk3 = valueStr;

  1466.         break;

  1467.     case OPTION_PATH_BRIDGE_LV2_QT4:

  1468.         fOptions.bridge_lv2Qt4 = valueStr;

  1469.         break;

  1470.     case OPTION_PATH_BRIDGE_LV2_QT5:

  1471.         fOptions.bridge_lv2Qt5 = valueStr;

  1472.         break;

  1473.     case OPTION_PATH_BRIDGE_LV2_COCOA:

  1474.         fOptions.bridge_lv2Cocoa = valueStr;

  1475.         break;

  1476.     case OPTION_PATH_BRIDGE_LV2_WINDOWS:

  1477.         fOptions.bridge_lv2Win = valueStr;

  1478.         break;

  1479.     case OPTION_PATH_BRIDGE_LV2_X11:

  1480.         fOptions.bridge_lv2X11 = valueStr;

  1481.         break;

  1482. #endif

  1483. 

  1484. #ifdef WANT_VST

  1485.     case OPTION_PATH_BRIDGE_VST_COCOA:

  1486.         fOptions.bridge_vstCocoa = valueStr;

  1487.         break;

  1488.     case OPTION_PATH_BRIDGE_VST_HWND:

  1489.         fOptions.bridge_vstHWND = valueStr;

  1490.         break;

  1491.     case OPTION_PATH_BRIDGE_VST_X11:

  1492.         fOptions.bridge_vstX11 = valueStr;

  1493.         break;

  1494. #endif

  1495.     }

  1496. }

  1497. 

  1498. // -----------------------------------------------------------------------

  1499. // OSC Stuff

  1500. 

  1501. #ifdef BUILD_BRIDGE

  1502. bool CarlaEngine::isOscBridgeRegistered() const

  1503. {

  1504.     return (kData->oscData != nullptr);

  1505. }

  1506. #else

  1507. bool CarlaEngine::isOscControlRegistered() const

  1508. {

  1509.     return kData->osc.isControlRegistered();

  1510. }

  1511. #endif

  1512. 

  1513. void CarlaEngine::idleOsc()

  1514. {

  1515.     kData->osc.idle();

  1516. }

  1517. 

  1518. const char* CarlaEngine::getOscServerPathTCP() const

  1519. {

  1520.     return kData->osc.getServerPathTCP();

  1521. }

  1522. 

  1523. const char* CarlaEngine::getOscServerPathUDP() const

  1524. {

  1525.     return kData->osc.getServerPathUDP();

  1526. }

  1527. 

  1528. #ifdef BUILD_BRIDGE

  1529. void CarlaEngine::setOscBridgeData(const CarlaOscData* const oscData)

  1530. {

  1531.     kData->oscData = oscData;

  1532. }

  1533. #endif

  1534. 

  1535. // -----------------------------------------------------------------------

  1536. // protected calls

  1537. 

  1538. void CarlaEngine::bufferSizeChanged(const uint32_t newBufferSize)

  1539. {

  1540.     carla_debug("CarlaEngine::bufferSizeChanged(%i)", newBufferSize);

  1541. 

  1542.     for (unsigned int i=0; i < kData->curPluginCount; ++i)

  1543.     {

  1544.         CarlaPlugin* const plugin = kData->plugins[i].plugin;

  1545. 

  1546.         if (plugin != nullptr && plugin->enabled())

  1547.             plugin->bufferSizeChanged(newBufferSize);

  1548.     }

  1549. 

  1550.     callback(CALLBACK_BUFFER_SIZE_CHANGED, 0, newBufferSize, 0, 0.0f, nullptr);

  1551. }

  1552. 

  1553. void CarlaEngine::sampleRateChanged(const double newSampleRate)

  1554. {

  1555.     carla_debug("CarlaEngine::sampleRateChanged(%g)", newSampleRate);

  1556. 

  1557.     for (unsigned int i=0; i < kData->curPluginCount; ++i)

  1558.     {

  1559.         CarlaPlugin* const plugin = kData->plugins[i].plugin;

  1560. 

  1561.         if (plugin != nullptr && plugin->enabled())

  1562.             plugin->sampleRateChanged(newSampleRate);

  1563.     }

  1564. 

  1565.     callback(CALLBACK_SAMPLE_RATE_CHANGED, 0, 0, 0, newSampleRate, nullptr);

  1566. }

  1567. 

  1568. void CarlaEngine::proccessPendingEvents()

  1569. {

  1570.     //carla_stderr("proccessPendingEvents(%i)", kData->nextAction.opcode);

  1571. 

  1572.     switch (kData->nextAction.opcode)

  1573.     {

  1574.     case EnginePostActionNull:

  1575.         break;

  1576.     case EnginePostActionRemovePlugin:

  1577.         doPluginRemove(kData, true);

  1578.         break;

  1579.     case EnginePostActionSwitchPlugins:

  1580.         doPluginsSwitch(kData, true);

  1581.         break;

  1582.     }

  1583. 

  1584.     if (kData->time.playing)

  1585.         kData->time.frame += fBufferSize;

  1586. 

  1587.     if (fOptions.transportMode == CarlaBackend::TRANSPORT_MODE_INTERNAL)

  1588.     {

  1589.         fTimeInfo.playing = kData->time.playing;

  1590.         fTimeInfo.frame   = kData->time.frame;

  1591.     }

  1592. 

  1593.     for (unsigned int i=0; i < kData->curPluginCount; ++i)

  1594.     {

  1595.         // TODO - peak values?

  1596.     }

  1597. }

  1598. 

  1599. void CarlaEngine::setPeaks(const unsigned int pluginId, float const inPeaks[MAX_PEAKS], float const outPeaks[MAX_PEAKS])

  1600. {

  1601.     kData->plugins[pluginId].insPeak[0]  = inPeaks[0];

  1602.     kData->plugins[pluginId].insPeak[1]  = inPeaks[1];

  1603.     kData->plugins[pluginId].outsPeak[0] = outPeaks[0];

  1604.     kData->plugins[pluginId].outsPeak[1] = outPeaks[1];

  1605. }

  1606. 

  1607. #ifndef BUILD_BRIDGE

  1608. EngineEvent* CarlaEngine::getRackEventBuffer(const bool isInput)

  1609. {

  1610.     return isInput ? kData->rack.in : kData->rack.out;

  1611. }

  1612. 

  1613. void setValueIfHigher(float& value, const float& compare)

  1614. {

  1615.     if (value < compare)

  1616.         value = compare;

  1617. }

  1618. 

  1619. void CarlaEngine::processRack(float* inBuf[2], float* outBuf[2], const uint32_t frames)

  1620. {

  1621.     // initialize outputs (zero)

  1622.     carla_zeroFloat(outBuf[0], frames);

  1623.     carla_zeroFloat(outBuf[1], frames);

  1624.     carla_zeroMem(kData->rack.out, sizeof(EngineEvent)*RACK_EVENT_COUNT);

  1625. 

  1626.     bool processed = false;

  1627. 

  1628.     // process plugins

  1629.     for (unsigned int i=0; i < kData->curPluginCount; ++i)

  1630.     {

  1631.         CarlaPlugin* const plugin = kData->plugins[i].plugin;

  1632. 

  1633.         if (plugin == nullptr || ! plugin->enabled() || ! plugin->tryLock())

  1634.             continue;

  1635. 

  1636.         if (processed)

  1637.         {

  1638.             // initialize inputs (from previous outputs)

  1639.             carla_copyFloat(inBuf[0], outBuf[0], frames);

  1640.             carla_copyFloat(inBuf[1], outBuf[1], frames);

  1641.             std::memcpy(kData->rack.in, kData->rack.out, sizeof(EngineEvent)*RACK_EVENT_COUNT);

  1642. 

  1643.             // initialize outputs (zero)

  1644.             carla_zeroFloat(outBuf[0], frames);

  1645.             carla_zeroFloat(outBuf[1], frames);

  1646.             carla_zeroMem(kData->rack.out, sizeof(EngineEvent)*RACK_EVENT_COUNT);

  1647.         }

  1648. 

  1649.         // process

  1650.         plugin->initBuffers();

  1651.         plugin->process(inBuf, outBuf, frames);

  1652.         plugin->unlock();

  1653. 

  1654. #if 0

  1655.         // if plugin has no audio inputs, add previous buffers

  1656.         if (plugin->audioInCount() == 0)

  1657.         {

  1658.             for (uint32_t j=0; j < frames; ++j)

  1659.             {

  1660.                 outBuf[0][j] += inBuf[0][j];

  1661.                 outBuf[1][j] += inBuf[1][j];

  1662.             }

  1663.         }

  1664.         // if plugin has no midi output, add previous events

  1665.         if (plugin->midiOutCount() == 0)

  1666.         {

  1667.             for (uint32_t j=0, k=0; j < frames; ++j)

  1668.             {

  1669. 

  1670.             }

  1671.             std::memcpy(kData->rack.out, kData->rack.in, sizeof(EngineEvent)*RACK_EVENT_COUNT);

  1672.         }

  1673. #endif

  1674. 

  1675.         // set peaks

  1676.         {

  1677.             float inPeak1  = 0.0f;

  1678.             float inPeak2  = 0.0f;

  1679.             float outPeak1 = 0.0f;

  1680.             float outPeak2 = 0.0f;

  1681. 

  1682.             for (uint32_t k=0; k < frames; ++k)

  1683.             {

  1684.                 setValueIfHigher(inPeak1,  std::fabs(inBuf[0][k]));

  1685.                 setValueIfHigher(inPeak2,  std::fabs(inBuf[1][k]));

  1686.                 setValueIfHigher(outPeak1, std::fabs(outBuf[0][k]));

  1687.                 setValueIfHigher(outPeak2, std::fabs(outBuf[1][k]));

  1688.             }

  1689. 

  1690.             kData->plugins[i].insPeak[0]  = inPeak1;

  1691.             kData->plugins[i].insPeak[1]  = inPeak2;

  1692.             kData->plugins[i].outsPeak[0] = outPeak1;

  1693.             kData->plugins[i].outsPeak[1] = outPeak2;

  1694.         }

  1695. 

  1696.         processed = true;

  1697.     }

  1698. }

  1699. 

  1700. void CarlaEngine::processPatchbay(float** inBuf, float** outBuf, const uint32_t bufCount[2], const uint32_t frames)

  1701. {

  1702.     // TODO

  1703.     return;

  1704. 

  1705.     // unused, for now

  1706.     (void)inBuf;

  1707.     (void)outBuf;

  1708.     (void)bufCount;

  1709.     (void)frames;

  1710. }

  1711. #endif

  1712. 

  1713. // -------------------------------------------------------------------------------------------------------------------

  1714. // Carla Engine OSC stuff

  1715. 

  1716. #ifndef BUILD_BRIDGE

  1717. void CarlaEngine::osc_send_control_add_plugin_start(const int32_t pluginId, const char* const pluginName)

  1718. {

  1719.     CARLA_ASSERT(kData->oscData != nullptr);

  1720.     CARLA_ASSERT(pluginId >= 0 && pluginId < (int32_t)kData->curPluginCount);

  1721.     CARLA_ASSERT(pluginName);

  1722.     carla_debug("CarlaEngine::osc_send_control_add_plugin_start(%i, \"%s\")", pluginId, pluginName);

  1723. 

  1724.     if (kData->oscData != nullptr && kData->oscData->target != nullptr)

  1725.     {

  1726.         char targetPath[std::strlen(kData->oscData->path)+18];

  1727.         std::strcpy(targetPath, kData->oscData->path);

  1728.         std::strcat(targetPath, "/add_plugin_start");

  1729.         lo_send(kData->oscData->target, targetPath, "is", pluginId, pluginName);

  1730.     }

  1731. }

  1732. 

  1733. void CarlaEngine::osc_send_control_add_plugin_end(const int32_t pluginId)

  1734. {

  1735.     carla_debug("CarlaEngine::osc_send_control_add_plugin_end(%i)", pluginId);

  1736.     CARLA_ASSERT(kData->oscData != nullptr);

  1737.     CARLA_ASSERT(pluginId >= 0 && pluginId < (int32_t)kData->curPluginCount);

  1738. 

  1739.     if (kData->oscData != nullptr && kData->oscData->target != nullptr)

  1740.     {

  1741.         char targetPath[std::strlen(kData->oscData->path)+16];

  1742.         std::strcpy(targetPath, kData->oscData->path);

  1743.         std::strcat(targetPath, "/add_plugin_end");

  1744.         lo_send(kData->oscData->target, targetPath, "i", pluginId);

  1745.     }

  1746. }

  1747. 

  1748. void CarlaEngine::osc_send_control_remove_plugin(const int32_t pluginId)

  1749. {

  1750.     carla_debug("CarlaEngine::osc_send_control_remove_plugin(%i)", pluginId);

  1751.     CARLA_ASSERT(kData->oscData != nullptr);

  1752.     CARLA_ASSERT(pluginId >= 0 && pluginId < (int32_t)kData->curPluginCount);

  1753. 

  1754.     if (kData->oscData != nullptr && kData->oscData->target != nullptr)

  1755.     {

  1756.         char targetPath[std::strlen(kData->oscData->path)+15];

  1757.         std::strcpy(targetPath, kData->oscData->path);

  1758.         std::strcat(targetPath, "/remove_plugin");

  1759.         lo_send(kData->oscData->target, targetPath, "i", pluginId);

  1760.     }

  1761. }

  1762. 

  1763. void CarlaEngine::osc_send_control_set_plugin_data(const int32_t pluginId, const int32_t type, const int32_t category, const int32_t hints, const char* const realName, const char* const label, const char* const maker, const char* const copyright, const int64_t uniqueId)

  1764. {

  1765.     carla_debug("CarlaEngine::osc_send_control_set_plugin_data(%i, %i, %i, %i, \"%s\", \"%s\", \"%s\", \"%s\", " P_INT64 ")", pluginId, type, category, hints, realName, label, maker, copyright, uniqueId);

  1766.     CARLA_ASSERT(kData->oscData != nullptr);

  1767.     CARLA_ASSERT(pluginId >= 0 && pluginId < (int32_t)kData->curPluginCount);

  1768.     CARLA_ASSERT(type != PLUGIN_NONE);

  1769. 

  1770.     if (kData->oscData != nullptr && kData->oscData->target != nullptr)

  1771.     {

  1772.         char targetPath[std::strlen(kData->oscData->path)+17];

  1773.         std::strcpy(targetPath, kData->oscData->path);

  1774.         std::strcat(targetPath, "/set_plugin_data");

  1775.         lo_send(kData->oscData->target, targetPath, "iiiissssh", pluginId, type, category, hints, realName, label, maker, copyright, uniqueId);

  1776.     }

  1777. }

  1778. 

  1779. void CarlaEngine::osc_send_control_set_plugin_ports(const int32_t pluginId, const int32_t audioIns, const int32_t audioOuts, const int32_t midiIns, const int32_t midiOuts, const int32_t cIns, const int32_t cOuts, const int32_t cTotals)

  1780. {

  1781.     carla_debug("CarlaEngine::osc_send_control_set_plugin_ports(%i, %i, %i, %i, %i, %i, %i, %i)", pluginId, audioIns, audioOuts, midiIns, midiOuts, cIns, cOuts, cTotals);

  1782.     CARLA_ASSERT(kData->oscData != nullptr);

  1783.     CARLA_ASSERT(pluginId >= 0 && pluginId < (int32_t)kData->curPluginCount);

  1784. 

  1785.     if (kData->oscData != nullptr && kData->oscData->target != nullptr)

  1786.     {

  1787.         char targetPath[std::strlen(kData->oscData->path)+18];

  1788.         std::strcpy(targetPath, kData->oscData->path);

  1789.         std::strcat(targetPath, "/set_plugin_ports");

  1790.         lo_send(kData->oscData->target, targetPath, "iiiiiiii", pluginId, audioIns, audioOuts, midiIns, midiOuts, cIns, cOuts, cTotals);

  1791.     }

  1792. }

  1793. 

  1794. void CarlaEngine::osc_send_control_set_parameter_data(const int32_t pluginId, const int32_t index, const int32_t type, const int32_t hints, const char* const name, const char* const label, const float current)

  1795. {

  1796.     carla_debug("CarlaEngine::osc_send_control_set_parameter_data(%i, %i, %i, %i, \"%s\", \"%s\", %g)", pluginId, index, type, hints, name, label, current);

  1797.     CARLA_ASSERT(kData->oscData != nullptr);

  1798.     CARLA_ASSERT(pluginId >= 0 && pluginId < (int32_t)kData->curPluginCount);

  1799.     CARLA_ASSERT(index >= 0);

  1800.     CARLA_ASSERT(type != PARAMETER_UNKNOWN);

  1801. 

  1802.     if (kData->oscData != nullptr && kData->oscData->target != nullptr)

  1803.     {

  1804.         char targetPath[std::strlen(kData->oscData->path)+20];

  1805.         std::strcpy(targetPath, kData->oscData->path);

  1806.         std::strcat(targetPath, "/set_parameter_data");

  1807.         lo_send(kData->oscData->target, targetPath, "iiiissd", pluginId, index, type, hints, name, label, current);

  1808.     }

  1809. }

  1810. 

  1811. void CarlaEngine::osc_send_control_set_parameter_ranges(const int32_t pluginId, const int32_t index, const float min, const float max, const float def, const float step, const float stepSmall, const float stepLarge)

  1812. {

  1813.     carla_debug("CarlaEngine::osc_send_control_set_parameter_ranges(%i, %i, %g, %g, %g, %g, %g, %g)", pluginId, index, min, max, def, step, stepSmall, stepLarge);

  1814.     CARLA_ASSERT(kData->oscData != nullptr);

  1815.     CARLA_ASSERT(pluginId >= 0 && pluginId < (int32_t)kData->curPluginCount);

  1816.     CARLA_ASSERT(index >= 0);

  1817.     CARLA_ASSERT(min < max);

  1818. 

  1819.     if (kData->oscData != nullptr && kData->oscData->target != nullptr)

  1820.     {

  1821.         char targetPath[std::strlen(kData->oscData->path)+22];

  1822.         std::strcpy(targetPath, kData->oscData->path);

  1823.         std::strcat(targetPath, "/set_parameter_ranges");

  1824.         lo_send(kData->oscData->target, targetPath, "iidddddd", pluginId, index, min, max, def, step, stepSmall, stepLarge);

  1825.     }

  1826. }

  1827. 

  1828. void CarlaEngine::osc_send_control_set_parameter_midi_cc(const int32_t pluginId, const int32_t index, const int32_t cc)

  1829. {

  1830.     carla_debug("CarlaEngine::osc_send_control_set_parameter_midi_cc(%i, %i, %i)", pluginId, index, cc);

  1831.     CARLA_ASSERT(kData->oscData != nullptr);

  1832.     CARLA_ASSERT(pluginId >= 0 && pluginId < (int32_t)kData->curPluginCount);

  1833.     CARLA_ASSERT(index >= 0);

  1834. 

  1835.     if (kData->oscData != nullptr && kData->oscData->target != nullptr)

  1836.     {

  1837.         char targetPath[std::strlen(kData->oscData->path)+23];

  1838.         std::strcpy(targetPath, kData->oscData->path);

  1839.         std::strcat(targetPath, "/set_parameter_midi_cc");

  1840.         lo_send(kData->oscData->target, targetPath, "iii", pluginId, index, cc);

  1841.     }

  1842. }

  1843. 

  1844. void CarlaEngine::osc_send_control_set_parameter_midi_channel(const int32_t pluginId, const int32_t index, const int32_t channel)

  1845. {

  1846.     carla_debug("CarlaEngine::osc_send_control_set_parameter_midi_channel(%i, %i, %i)", pluginId, index, channel);

  1847.     CARLA_ASSERT(kData->oscData != nullptr);

  1848.     CARLA_ASSERT(pluginId >= 0 && pluginId < (int32_t)kData->curPluginCount);

  1849.     CARLA_ASSERT(index >= 0);

  1850.     CARLA_ASSERT(channel >= 0 && channel < 16);

  1851. 

  1852.     if (kData->oscData != nullptr && kData->oscData->target != nullptr)

  1853.     {

  1854.         char targetPath[std::strlen(kData->oscData->path)+28];

  1855.         std::strcpy(targetPath, kData->oscData->path);

  1856.         std::strcat(targetPath, "/set_parameter_midi_channel");

  1857.         lo_send(kData->oscData->target, targetPath, "iii", pluginId, index, channel);

  1858.     }

  1859. }

  1860. 

  1861. void CarlaEngine::osc_send_control_set_parameter_value(const int32_t pluginId, const int32_t index, const float value)

  1862. {

  1863. #if DEBUG

  1864.     if (index < 0)

  1865.         carla_debug("CarlaEngine::osc_send_control_set_parameter_value(%i, %s, %g)", pluginId, InternalParametersIndex2Str((InternalParametersIndex)index), value);

  1866.     else

  1867.         carla_debug("CarlaEngine::osc_send_control_set_parameter_value(%i, %i, %g)", pluginId, index, value);

  1868. #endif

  1869.     CARLA_ASSERT(kData->oscData != nullptr);

  1870.     CARLA_ASSERT(pluginId >= 0 && pluginId < (int32_t)kData->curPluginCount);

  1871. 

  1872.     if (kData->oscData != nullptr && kData->oscData->target != nullptr)

  1873.     {

  1874.         char targetPath[std::strlen(kData->oscData->path)+21];

  1875.         std::strcpy(targetPath, kData->oscData->path);

  1876.         std::strcat(targetPath, "/set_parameter_value");

  1877.         lo_send(kData->oscData->target, targetPath, "iid", pluginId, index, value);

  1878.     }

  1879. }

  1880. 

  1881. void CarlaEngine::osc_send_control_set_default_value(const int32_t pluginId, const int32_t index, const float value)

  1882. {

  1883.     carla_debug("CarlaEngine::osc_send_control_set_default_value(%i, %i, %g)", pluginId, index, value);

  1884.     CARLA_ASSERT(kData->oscData != nullptr);

  1885.     CARLA_ASSERT(pluginId >= 0 && pluginId < (int32_t)kData->maxPluginNumber);

  1886.     CARLA_ASSERT(index >= 0);

  1887. 

  1888.     if (kData->oscData != nullptr && kData->oscData->target != nullptr)

  1889.     {

  1890.         char targetPath[std::strlen(kData->oscData->path)+19];

  1891.         std::strcpy(targetPath, kData->oscData->path);

  1892.         std::strcat(targetPath, "/set_default_value");

  1893.         lo_send(kData->oscData->target, targetPath, "iid", pluginId, index, value);

  1894.     }

  1895. }

  1896. 

  1897. void CarlaEngine::osc_send_control_set_program(const int32_t pluginId, const int32_t index)

  1898. {

  1899.     carla_debug("CarlaEngine::osc_send_control_set_program(%i, %i)", pluginId, index);

  1900.     CARLA_ASSERT(kData->oscData != nullptr);

  1901.     CARLA_ASSERT(pluginId >= 0 && pluginId < (int32_t)kData->maxPluginNumber);

  1902. 

  1903.     if (kData->oscData != nullptr && kData->oscData->target != nullptr)

  1904.     {

  1905.         char targetPath[std::strlen(kData->oscData->path)+13];

  1906.         std::strcpy(targetPath, kData->oscData->path);

  1907.         std::strcat(targetPath, "/set_program");

  1908.         lo_send(kData->oscData->target, targetPath, "ii", pluginId, index);

  1909.     }

  1910. }

  1911. 

  1912. void CarlaEngine::osc_send_control_set_program_count(const int32_t pluginId, const int32_t count)

  1913. {

  1914.     carla_debug("CarlaEngine::osc_send_control_set_program_count(%i, %i)", pluginId, count);

  1915.     CARLA_ASSERT(kData->oscData != nullptr);

  1916.     CARLA_ASSERT(pluginId >= 0 && pluginId < (int32_t)kData->maxPluginNumber);

  1917.     CARLA_ASSERT(count >= 0);

  1918. 

  1919.     if (kData->oscData != nullptr && kData->oscData->target != nullptr)

  1920.     {

  1921.         char targetPath[std::strlen(kData->oscData->path)+19];

  1922.         std::strcpy(targetPath, kData->oscData->path);

  1923.         std::strcat(targetPath, "/set_program_count");

  1924.         lo_send(kData->oscData->target, targetPath, "ii", pluginId, count);

  1925.     }

  1926. }

  1927. 

  1928. void CarlaEngine::osc_send_control_set_program_name(const int32_t pluginId, const int32_t index, const char* const name)

  1929. {

  1930.     carla_debug("CarlaEngine::osc_send_control_set_program_name(%i, %i, \"%s\")", pluginId, index, name);

  1931.     CARLA_ASSERT(kData->oscData != nullptr);

  1932.     CARLA_ASSERT(pluginId >= 0 && pluginId < (int32_t)kData->maxPluginNumber);

  1933.     CARLA_ASSERT(index >= 0);

  1934.     CARLA_ASSERT(name);

  1935. 

  1936.     if (kData->oscData != nullptr && kData->oscData->target != nullptr)

  1937.     {

  1938.         char targetPath[std::strlen(kData->oscData->path)+18];

  1939.         std::strcpy(targetPath, kData->oscData->path);

  1940.         std::strcat(targetPath, "/set_program_name");

  1941.         lo_send(kData->oscData->target, targetPath, "iis", pluginId, index, name);

  1942.     }

  1943. }

  1944. 

  1945. void CarlaEngine::osc_send_control_set_midi_program(const int32_t pluginId, const int32_t index)

  1946. {

  1947.     carla_debug("CarlaEngine::osc_send_control_set_midi_program(%i, %i)", pluginId, index);

  1948.     CARLA_ASSERT(kData->oscData != nullptr);

  1949.     CARLA_ASSERT(pluginId >= 0 && pluginId < (int32_t)kData->maxPluginNumber);

  1950. 

  1951.     if (kData->oscData != nullptr && kData->oscData->target != nullptr)

  1952.     {

  1953.         char targetPath[std::strlen(kData->oscData->path)+18];

  1954.         std::strcpy(targetPath, kData->oscData->path);

  1955.         std::strcat(targetPath, "/set_midi_program");

  1956.         lo_send(kData->oscData->target, targetPath, "ii", pluginId, index);

  1957.     }

  1958. }

  1959. 

  1960. void CarlaEngine::osc_send_control_set_midi_program_count(const int32_t pluginId, const int32_t count)

  1961. {

  1962.     carla_debug("CarlaEngine::osc_send_control_set_midi_program_count(%i, %i)", pluginId, count);

  1963.     CARLA_ASSERT(kData->oscData != nullptr);

  1964.     CARLA_ASSERT(pluginId >= 0 && pluginId < (int32_t)kData->maxPluginNumber);

  1965.     CARLA_ASSERT(count >= 0);

  1966. 

  1967.     if (kData->oscData != nullptr && kData->oscData->target != nullptr)

  1968.     {

  1969.         char targetPath[std::strlen(kData->oscData->path)+24];

  1970.         std::strcpy(targetPath, kData->oscData->path);

  1971.         std::strcat(targetPath, "/set_midi_program_count");

  1972.         lo_send(kData->oscData->target, targetPath, "ii", pluginId, count);

  1973.     }

  1974. }

  1975. 

  1976. void CarlaEngine::osc_send_control_set_midi_program_data(const int32_t pluginId, const int32_t index, const int32_t bank, const int32_t program, const char* const name)

  1977. {

  1978.     carla_debug("CarlaEngine::osc_send_control_set_midi_program_data(%i, %i, %i, %i, \"%s\")", pluginId, index, bank, program, name);

  1979.     CARLA_ASSERT(kData->oscData != nullptr);

  1980.     CARLA_ASSERT(pluginId >= 0 && pluginId < (int32_t)kData->maxPluginNumber);

  1981.     CARLA_ASSERT(index >= 0);

  1982.     CARLA_ASSERT(bank >= 0);

  1983.     CARLA_ASSERT(program >= 0);

  1984.     CARLA_ASSERT(name);

  1985. 

  1986.     if (kData->oscData != nullptr && kData->oscData->target != nullptr)

  1987.     {

  1988.         char targetPath[std::strlen(kData->oscData->path)+23];

  1989.         std::strcpy(targetPath, kData->oscData->path);

  1990.         std::strcat(targetPath, "/set_midi_program_data");

  1991.         lo_send(kData->oscData->target, targetPath, "iiiis", pluginId, index, bank, program, name);

  1992.     }

  1993. }

  1994. 

  1995. void CarlaEngine::osc_send_control_note_on(const int32_t pluginId, const int32_t channel, const int32_t note, const int32_t velo)

  1996. {

  1997.     carla_debug("CarlaEngine::osc_send_control_note_on(%i, %i, %i, %i)", pluginId, channel, note, velo);

  1998.     CARLA_ASSERT(kData->oscData != nullptr);

  1999.     CARLA_ASSERT(pluginId >= 0 && pluginId < (int32_t)kData->maxPluginNumber);

  2000.     CARLA_ASSERT(channel >= 0 && channel < 16);

  2001.     CARLA_ASSERT(note >= 0 && note < 128);

  2002.     CARLA_ASSERT(velo > 0 && velo < 128);

  2003. 

  2004.     if (kData->oscData != nullptr && kData->oscData->target != nullptr)

  2005.     {

  2006.         char targetPath[std::strlen(kData->oscData->path)+9];

  2007.         std::strcpy(targetPath, kData->oscData->path);

  2008.         std::strcat(targetPath, "/note_on");

  2009.         lo_send(kData->oscData->target, targetPath, "iiii", pluginId, channel, note, velo);

  2010.     }

  2011. }

  2012. 

  2013. void CarlaEngine::osc_send_control_note_off(const int32_t pluginId, const int32_t channel, const int32_t note)

  2014. {

  2015.     carla_debug("CarlaEngine::osc_send_control_note_off(%i, %i, %i)", pluginId, channel, note);

  2016.     CARLA_ASSERT(kData->oscData != nullptr);

  2017.     CARLA_ASSERT(pluginId >= 0 && pluginId < (int32_t)kData->maxPluginNumber);

  2018.     CARLA_ASSERT(channel >= 0 && channel < 16);

  2019.     CARLA_ASSERT(note >= 0 && note < 128);

  2020. 

  2021.     if (kData->oscData != nullptr && kData->oscData->target != nullptr)

  2022.     {

  2023.         char targetPath[std::strlen(kData->oscData->path)+10];

  2024.         std::strcpy(targetPath, kData->oscData->path);

  2025.         std::strcat(targetPath, "/note_off");

  2026.         lo_send(kData->oscData->target, targetPath, "iii", pluginId, channel, note);

  2027.     }

  2028. }

  2029. 

  2030. void CarlaEngine::osc_send_control_set_peaks(const int32_t pluginId)

  2031. {

  2032.     CARLA_ASSERT(kData->oscData != nullptr);

  2033.     CARLA_ASSERT(pluginId >= 0 && pluginId < (int32_t)kData->maxPluginNumber);

  2034. 

  2035.     const EnginePluginData& pData = kData->plugins[pluginId];

  2036. 

  2037.     if (kData->oscData != nullptr && kData->oscData->target != nullptr)

  2038.     {

  2039.         char targetPath[std::strlen(kData->oscData->path)+22];

  2040.         std::strcpy(targetPath, kData->oscData->path);

  2041.         std::strcat(targetPath, "/set_peaks");

  2042.         lo_send(kData->oscData->target, targetPath, "iffff", pluginId, pData.insPeak[0], pData.insPeak[1], pData.outsPeak[0], pData.outsPeak[1]);

  2043.     }

  2044. }

  2045. 

  2046. void CarlaEngine::osc_send_control_exit()

  2047. {

  2048.     carla_debug("CarlaEngine::osc_send_control_exit()");

  2049.     CARLA_ASSERT(kData->oscData != nullptr);

  2050. 

  2051.     if (kData->oscData && kData->oscData->target)

  2052.     {

  2053.         char targetPath[std::strlen(kData->oscData->path)+6];

  2054.         std::strcpy(targetPath, kData->oscData->path);

  2055.         std::strcat(targetPath, "/exit");

  2056.         lo_send(kData->oscData->target, targetPath, "");

  2057.     }

  2058. }

  2059. #else

  2060. void CarlaEngine::osc_send_bridge_audio_count(const int32_t ins, const int32_t outs, const int32_t total)

  2061. {

  2062.     carla_debug("CarlaEngine::osc_send_bridge_audio_count(%i, %i, %i)", ins, outs, total);

  2063.     CARLA_ASSERT(kData->oscData != nullptr);

  2064.     CARLA_ASSERT(total >= 0 && total >= ins + outs);

  2065. 

  2066.     if (kData->oscData != nullptr && kData->oscData->target != nullptr)

  2067.     {

  2068.         char targetPath[std::strlen(kData->oscData->path)+20];

  2069.         std::strcpy(targetPath, kData->oscData->path);

  2070.         std::strcat(targetPath, "/bridge_audio_count");

  2071.         lo_send(kData->oscData->target, targetPath, "iii", ins, outs, total);

  2072.     }

  2073. }

  2074. 

  2075. void CarlaEngine::osc_send_bridge_midi_count(const int32_t ins, const int32_t outs, const int32_t total)

  2076. {

  2077.     carla_debug("CarlaEngine::osc_send_bridge_midi_count(%i, %i, %i)", ins, outs, total);

  2078.     CARLA_ASSERT(kData->oscData != nullptr);

  2079.     CARLA_ASSERT(total >= 0 && total >= ins + outs);

  2080. 

  2081.     if (kData->oscData != nullptr && kData->oscData->target != nullptr)

  2082.     {

  2083.         char targetPath[std::strlen(kData->oscData->path)+19];

  2084.         std::strcpy(targetPath, kData->oscData->path);

  2085.         std::strcat(targetPath, "/bridge_midi_count");

  2086.         lo_send(kData->oscData->target, targetPath, "iii", ins, outs, total);

  2087.     }

  2088. }

  2089. 

  2090. void CarlaEngine::osc_send_bridge_parameter_count(const int32_t ins, const int32_t outs, const int32_t total)

  2091. {

  2092.     carla_debug("CarlaEngine::osc_send_bridge_parameter_count(%i, %i, %i)", ins, outs, total);

  2093.     CARLA_ASSERT(kData->oscData != nullptr);

  2094.     CARLA_ASSERT(total >= 0 && total >= ins + outs);

  2095. 

  2096.     if (kData->oscData != nullptr && kData->oscData->target != nullptr)

  2097.     {

  2098.         char targetPath[std::strlen(kData->oscData->path)+24];

  2099.         std::strcpy(targetPath, kData->oscData->path);

  2100.         std::strcat(targetPath, "/bridge_parameter_count");

  2101.         lo_send(kData->oscData->target, targetPath, "iii", ins, outs, total);

  2102.     }

  2103. }

  2104. 

  2105. void CarlaEngine::osc_send_bridge_program_count(const int32_t count)

  2106. {

  2107.     carla_debug("CarlaEngine::osc_send_bridge_program_count(%i)", count);

  2108.     CARLA_ASSERT(kData->oscData != nullptr);

  2109.     CARLA_ASSERT(count >= 0);

  2110. 

  2111.     if (kData->oscData != nullptr && kData->oscData->target != nullptr)

  2112.     {

  2113.         char targetPath[std::strlen(kData->oscData->path)+22];

  2114.         std::strcpy(targetPath, kData->oscData->path);

  2115.         std::strcat(targetPath, "/bridge_program_count");

  2116.         lo_send(kData->oscData->target, targetPath, "i", count);

  2117.     }

  2118. }

  2119. 

  2120. void CarlaEngine::osc_send_bridge_midi_program_count(const int32_t count)

  2121. {

  2122.     carla_debug("CarlaEngine::osc_send_bridge_midi_program_count(%i)", count);

  2123.     CARLA_ASSERT(kData->oscData != nullptr);

  2124.     CARLA_ASSERT(count >= 0);

  2125. 

  2126.     if (kData->oscData != nullptr && kData->oscData->target != nullptr)

  2127.     {

  2128.         char targetPath[std::strlen(kData->oscData->path)+27];

  2129.         std::strcpy(targetPath, kData->oscData->path);

  2130.         std::strcat(targetPath, "/bridge_midi_program_count");

  2131.         lo_send(kData->oscData->target, targetPath, "i", count);

  2132.     }

  2133. }

  2134. 

  2135. void CarlaEngine::osc_send_bridge_plugin_info(const int32_t category, const int32_t hints, const char* const name, const char* const label, const char* const maker, const char* const copyright, const int64_t uniqueId)

  2136. {

  2137.     carla_debug("CarlaEngine::osc_send_bridge_plugin_info(%i, %i, \"%s\", \"%s\", \"%s\", \"%s\", " P_INT64 ")", category, hints, name, label, maker, copyright, uniqueId);

  2138.     CARLA_ASSERT(kData->oscData != nullptr);

  2139.     CARLA_ASSERT(name != nullptr);

  2140.     CARLA_ASSERT(label != nullptr);

  2141.     CARLA_ASSERT(maker != nullptr);

  2142.     CARLA_ASSERT(copyright != nullptr);

  2143. 

  2144.     if (kData->oscData != nullptr && kData->oscData->target != nullptr)

  2145.     {

  2146.         char targetPath[std::strlen(kData->oscData->path)+20];

  2147.         std::strcpy(targetPath, kData->oscData->path);

  2148.         std::strcat(targetPath, "/bridge_plugin_info");

  2149.         lo_send(kData->oscData->target, targetPath, "iissssh", category, hints, name, label, maker, copyright, uniqueId);

  2150.     }

  2151. }

  2152. 

  2153. void CarlaEngine::osc_send_bridge_parameter_info(const int32_t index, const char* const name, const char* const unit)

  2154. {

  2155.     carla_debug("CarlaEngine::osc_send_bridge_parameter_info(%i, \"%s\", \"%s\")", index, name, unit);

  2156.     CARLA_ASSERT(kData->oscData != nullptr);

  2157.     CARLA_ASSERT(name != nullptr);

  2158.     CARLA_ASSERT(unit != nullptr);

  2159. 

  2160.     if (kData->oscData != nullptr && kData->oscData->target != nullptr)

  2161.     {

  2162.         char targetPath[std::strlen(kData->oscData->path)+23];

  2163.         std::strcpy(targetPath, kData->oscData->path);

  2164.         std::strcat(targetPath, "/bridge_parameter_info");

  2165.         lo_send(kData->oscData->target, targetPath, "iss", index, name, unit);

  2166.     }

  2167. }

  2168. 

  2169. void CarlaEngine::osc_send_bridge_parameter_data(const int32_t index, const int32_t type, const int32_t rindex, const int32_t hints, const int32_t midiChannel, const int32_t midiCC)

  2170. {

  2171.     carla_debug("CarlaEngine::osc_send_bridge_parameter_data(%i, %i, %i, %i, %i, %i)", index, type, rindex, hints, midiChannel, midiCC);

  2172.     CARLA_ASSERT(kData->oscData != nullptr);

  2173. 

  2174.     if (kData->oscData != nullptr && kData->oscData->target != nullptr)

  2175.     {

  2176.         char targetPath[std::strlen(kData->oscData->path)+23];

  2177.         std::strcpy(targetPath, kData->oscData->path);

  2178.         std::strcat(targetPath, "/bridge_parameter_data");

  2179.         lo_send(kData->oscData->target, targetPath, "iiiiii", index, type, rindex, hints, midiChannel, midiCC);

  2180.     }

  2181. }

  2182. 

  2183. void CarlaEngine::osc_send_bridge_parameter_ranges(const int32_t index, const float def, const float min, const float max, const float step, const float stepSmall, const float stepLarge)

  2184. {

  2185.     carla_debug("CarlaEngine::osc_send_bridge_parameter_ranges(%i, %g, %g, %g, %g, %g, %g)", index, def, min, max, step, stepSmall, stepLarge);

  2186.     CARLA_ASSERT(kData->oscData != nullptr);

  2187. 

  2188.     if (kData->oscData != nullptr && kData->oscData->target != nullptr)

  2189.     {

  2190.         char targetPath[std::strlen(kData->oscData->path)+25];

  2191.         std::strcpy(targetPath, kData->oscData->path);

  2192.         std::strcat(targetPath, "/bridge_parameter_ranges");

  2193.         lo_send(kData->oscData->target, targetPath, "idddddd", index, def, min, max, step, stepSmall, stepLarge);

  2194.     }

  2195. }

  2196. 

  2197. void CarlaEngine::osc_send_bridge_program_info(const int32_t index, const char* const name)

  2198. {

  2199.     carla_debug("CarlaEngine::osc_send_bridge_program_info(%i, \"%s\")", index, name);

  2200.     CARLA_ASSERT(kData->oscData != nullptr);

  2201. 

  2202.     if (kData->oscData != nullptr && kData->oscData->target != nullptr)

  2203.     {

  2204.         char targetPath[std::strlen(kData->oscData->path)+21];

  2205.         std::strcpy(targetPath, kData->oscData->path);

  2206.         std::strcat(targetPath, "/bridge_program_info");

  2207.         lo_send(kData->oscData->target, targetPath, "is", index, name);

  2208.     }

  2209. }

  2210. 

  2211. void CarlaEngine::osc_send_bridge_midi_program_info(const int32_t index, const int32_t bank, const int32_t program, const char* const label)

  2212. {

  2213.     carla_debug("CarlaEngine::osc_send_bridge_midi_program_info(%i, %i, %i, \"%s\")", index, bank, program, label);

  2214.     CARLA_ASSERT(kData->oscData != nullptr);

  2215. 

  2216.     if (kData->oscData != nullptr && kData->oscData->target != nullptr)

  2217.     {

  2218.         char targetPath[std::strlen(kData->oscData->path)+26];

  2219.         std::strcpy(targetPath, kData->oscData->path);

  2220.         std::strcat(targetPath, "/bridge_midi_program_info");

  2221.         lo_send(kData->oscData->target, targetPath, "iiis", index, bank, program, label);

  2222.     }

  2223. }

  2224. 

  2225. void CarlaEngine::osc_send_bridge_configure(const char* const key, const char* const value)

  2226. {

  2227.     carla_debug("CarlaEngine::osc_send_bridge_configure(\"%s\", \"%s\")", key, value);

  2228.     CARLA_ASSERT(kData->oscData != nullptr);

  2229.     CARLA_ASSERT(key != nullptr);

  2230.     CARLA_ASSERT(value != nullptr);

  2231. 

  2232.     if (kData->oscData != nullptr && kData->oscData->target != nullptr)

  2233.     {

  2234.         char targetPath[std::strlen(kData->oscData->path)+18];

  2235.         std::strcpy(targetPath, kData->oscData->path);

  2236.         std::strcat(targetPath, "/bridge_configure");

  2237.         lo_send(kData->oscData->target, targetPath, "ss", key, value);

  2238.     }

  2239. }

  2240. 

  2241. void CarlaEngine::osc_send_bridge_set_parameter_value(const int32_t index, const float value)

  2242. {

  2243.     carla_debug("CarlaEngine::osc_send_bridge_set_parameter_value(%i, %g)", index, value);

  2244.     CARLA_ASSERT(kData->oscData != nullptr);

  2245. 

  2246.     if (kData->oscData != nullptr && kData->oscData->target != nullptr)

  2247.     {

  2248.         char targetPath[std::strlen(kData->oscData->path)+28];

  2249.         std::strcpy(targetPath, kData->oscData->path);

  2250.         std::strcat(targetPath, "/bridge_set_parameter_value");

  2251.         lo_send(kData->oscData->target, targetPath, "id", index, value);

  2252.     }

  2253. }

  2254. 

  2255. void CarlaEngine::osc_send_bridge_set_default_value(const int32_t index, const float value)

  2256. {

  2257.     carla_debug("CarlaEngine::osc_send_bridge_set_default_value(%i, %g)", index, value);

  2258.     CARLA_ASSERT(kData->oscData != nullptr);

  2259. 

  2260.     if (kData->oscData != nullptr && kData->oscData->target != nullptr)

  2261.     {

  2262.         char targetPath[std::strlen(kData->oscData->path)+26];

  2263.         std::strcpy(targetPath, kData->oscData->path);

  2264.         std::strcat(targetPath, "/bridge_set_default_value");

  2265.         lo_send(kData->oscData->target, targetPath, "id", index, value);

  2266.     }

  2267. }

  2268. 

  2269. void CarlaEngine::osc_send_bridge_set_program(const int32_t index)

  2270. {

  2271.     carla_debug("CarlaEngine::osc_send_bridge_set_program(%i)", index);

  2272.     CARLA_ASSERT(kData->oscData != nullptr);

  2273. 

  2274.     if (kData->oscData != nullptr && kData->oscData->target != nullptr)

  2275.     {

  2276.         char targetPath[std::strlen(kData->oscData->path)+20];

  2277.         std::strcpy(targetPath, kData->oscData->path);

  2278.         std::strcat(targetPath, "/bridge_set_program");

  2279.         lo_send(kData->oscData->target, targetPath, "i", index);

  2280.     }

  2281. }

  2282. 

  2283. void CarlaEngine::osc_send_bridge_set_midi_program(const int32_t index)

  2284. {

  2285.     carla_debug("CarlaEngine::osc_send_bridge_set_midi_program(%i)", index);

  2286.     CARLA_ASSERT(kData->oscData != nullptr);

  2287. 

  2288.     if (kData->oscData != nullptr && kData->oscData->target != nullptr)

  2289.     {

  2290.         char targetPath[std::strlen(kData->oscData->path)+25];

  2291.         std::strcpy(targetPath, kData->oscData->path);

  2292.         std::strcat(targetPath, "/bridge_set_midi_program");

  2293.         lo_send(kData->oscData->target, targetPath, "i", index);

  2294.     }

  2295. }

  2296. 

  2297. void CarlaEngine::osc_send_bridge_set_custom_data(const char* const type, const char* const key, const char* const value)

  2298. {

  2299.     carla_debug("CarlaEngine::osc_send_bridge_set_custom_data(\"%s\", \"%s\", \"%s\")", type, key, value);

  2300.     CARLA_ASSERT(kData->oscData != nullptr);

  2301. 

  2302.     if (kData->oscData != nullptr && kData->oscData->target != nullptr)

  2303.     {

  2304.         char targetPath[std::strlen(kData->oscData->path)+24];

  2305.         std::strcpy(targetPath, kData->oscData->path);

  2306.         std::strcat(targetPath, "/bridge_set_custom_data");

  2307.         lo_send(kData->oscData->target, targetPath, "sss", type, key, value);

  2308.     }

  2309. }

  2310. 

  2311. void CarlaEngine::osc_send_bridge_set_chunk_data(const char* const chunkFile)

  2312. {

  2313.     carla_debug("CarlaEngine::osc_send_bridge_set_chunk_data(\"%s\")", chunkFile);

  2314.     CARLA_ASSERT(kData->oscData != nullptr);

  2315. 

  2316.     if (kData->oscData != nullptr && kData->oscData->target != nullptr)

  2317.     {

  2318.         char targetPath[std::strlen(kData->oscData->path)+23];

  2319.         std::strcpy(targetPath, kData->oscData->path);

  2320.         std::strcat(targetPath, "/bridge_set_chunk_data");

  2321.         lo_send(kData->oscData->target, targetPath, "s", chunkFile);

  2322.     }

  2323. }

  2324. #endif

  2325. 

  2326. CARLA_BACKEND_END_NAMESPACE