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

2405 lines
78KB
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 doc/GPL.txt file.

  16.  */

  17. 

  18. #include "CarlaEngineInternal.hpp"

  19. #include "CarlaBackendUtils.hpp"

  20. #include "CarlaStateUtils.hpp"

  21. #include "CarlaMIDI.h"

  22. 

  23. #include <cmath>

  24. 

  25. CARLA_BACKEND_START_NAMESPACE

  26. 

  27. #if 0

  28. } // Fix editor indentation

  29. #endif

  30. 

  31. // -----------------------------------------------------------------------

  32. // Fallback data

  33. 

  34. static const EngineEvent kFallbackEngineEvent;

  35. 

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

  37. // Carla Engine port (Abstract)

  38. 

  39. CarlaEnginePort::CarlaEnginePort(const CarlaEngine& engine, const bool isInput)

  40.     : fEngine(engine),

  41.       fIsInput(isInput)

  42. {

  43.     carla_debug("CarlaEnginePort::CarlaEnginePort(name:\"%s\", %s)", engine.getName(), bool2str(isInput));

  44. }

  45. 

  46. CarlaEnginePort::~CarlaEnginePort()

  47. {

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

  49. }

  50. 

  51. // -----------------------------------------------------------------------

  52. // Carla Engine Audio port

  53. 

  54. CarlaEngineAudioPort::CarlaEngineAudioPort(const CarlaEngine& engine, const bool isInput)

  55.     : CarlaEnginePort(engine, isInput),

  56.       fBuffer(nullptr)

  57. {

  58.     carla_debug("CarlaEngineAudioPort::CarlaEngineAudioPort(name:\"%s\", %s)", engine.getName(), bool2str(isInput));

  59. }

  60. 

  61. CarlaEngineAudioPort::~CarlaEngineAudioPort()

  62. {

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

  64. }

  65. 

  66. void CarlaEngineAudioPort::initBuffer()

  67. {

  68. }

  69. 

  70. // -----------------------------------------------------------------------

  71. // Carla Engine CV port

  72. 

  73. CarlaEngineCVPort::CarlaEngineCVPort(const CarlaEngine& engine, const bool isInput)

  74.     : CarlaEnginePort(engine, isInput),

  75.       fBuffer(new float[engine.getBufferSize()])

  76. {

  77.     carla_debug("CarlaEngineCVPort::CarlaEngineCVPort(name:\"%s\", %s)", engine.getName(), bool2str(isInput));

  78. }

  79. 

  80. CarlaEngineCVPort::~CarlaEngineCVPort()

  81. {

  82.     CARLA_SAFE_ASSERT_RETURN(fBuffer != nullptr,);

  83.     carla_debug("CarlaEngineCVPort::~CarlaEngineCVPort()");

  84. 

  85.     delete[] fBuffer;

  86.     fBuffer = nullptr;

  87. }

  88. 

  89. void CarlaEngineCVPort::initBuffer()

  90. {

  91.     CARLA_SAFE_ASSERT_RETURN(fBuffer != nullptr,);

  92. 

  93.     carla_zeroFloat(fBuffer, fEngine.getBufferSize());

  94. }

  95. 

  96. void CarlaEngineCVPort::writeBuffer(const uint32_t, const uint32_t)

  97. {

  98.     CARLA_ASSERT(! fIsInput);

  99. }

  100. 

  101. void CarlaEngineCVPort::setBufferSize(const uint32_t bufferSize)

  102. {

  103.     if (fBuffer != nullptr)

  104.         delete[] fBuffer;

  105. 

  106.     fBuffer = new float[bufferSize];

  107. }

  108. 

  109. // -----------------------------------------------------------------------

  110. // Carla Engine Event port

  111. 

  112. CarlaEngineEventPort::CarlaEngineEventPort(const CarlaEngine& engine, const bool isInput)

  113.     : CarlaEnginePort(engine, isInput),

  114.       fBuffer(nullptr)

  115. {

  116.     carla_debug("CarlaEngineEventPort::CarlaEngineEventPort(name:\"%s\", %s)", engine.getName(), bool2str(isInput));

  117. 

  118.     if (fEngine.getProccessMode() == PROCESS_MODE_PATCHBAY)

  119.         fBuffer = new EngineEvent[kEngineMaxInternalEventCount];

  120. }

  121. 

  122. CarlaEngineEventPort::~CarlaEngineEventPort()

  123. {

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

  125. 

  126.     if (fEngine.getProccessMode() == PROCESS_MODE_PATCHBAY)

  127.     {

  128.         CARLA_SAFE_ASSERT_RETURN(fBuffer != nullptr,);

  129. 

  130.         delete[] fBuffer;

  131.         fBuffer = nullptr;

  132.     }

  133. }

  134. 

  135. void CarlaEngineEventPort::initBuffer()

  136. {

  137.     if (fEngine.getProccessMode() == PROCESS_MODE_CONTINUOUS_RACK || fEngine.getProccessMode() == PROCESS_MODE_BRIDGE)

  138.         fBuffer = fEngine.getInternalEventBuffer(fIsInput);

  139.     else if (fEngine.getProccessMode() == PROCESS_MODE_PATCHBAY && ! fIsInput)

  140.         carla_zeroStruct<EngineEvent>(fBuffer, kEngineMaxInternalEventCount);

  141. }

  142. 

  143. uint32_t CarlaEngineEventPort::getEventCount() const

  144. {

  145.     CARLA_SAFE_ASSERT_RETURN(fIsInput, 0);

  146.     CARLA_SAFE_ASSERT_RETURN(fBuffer != nullptr, 0);

  147.     CARLA_SAFE_ASSERT_RETURN(fEngine.getProccessMode() != PROCESS_MODE_SINGLE_CLIENT && fEngine.getProccessMode() != PROCESS_MODE_MULTIPLE_CLIENTS, 0);

  148. 

  149.     uint32_t i=0;

  150. 

  151.     for (; i < kEngineMaxInternalEventCount; ++i)

  152.     {

  153.         if (fBuffer[i].type == kEngineEventTypeNull)

  154.             break;

  155.     }

  156. 

  157.     return i;

  158. }

  159. 

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

  161. {

  162.     CARLA_SAFE_ASSERT_RETURN(fIsInput, kFallbackEngineEvent);

  163.     CARLA_SAFE_ASSERT_RETURN(fBuffer != nullptr, kFallbackEngineEvent);

  164.     CARLA_SAFE_ASSERT_RETURN(fEngine.getProccessMode() != PROCESS_MODE_SINGLE_CLIENT && fEngine.getProccessMode() != PROCESS_MODE_MULTIPLE_CLIENTS, kFallbackEngineEvent);

  165.     CARLA_SAFE_ASSERT_RETURN(index < kEngineMaxInternalEventCount, kFallbackEngineEvent);

  166. 

  167.     return fBuffer[index];

  168. }

  169. 

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

  171. {

  172.     CARLA_SAFE_ASSERT_RETURN(! fIsInput,);

  173.     CARLA_SAFE_ASSERT_RETURN(fBuffer != nullptr,);

  174.     CARLA_SAFE_ASSERT_RETURN(fEngine.getProccessMode() != PROCESS_MODE_SINGLE_CLIENT && fEngine.getProccessMode() != PROCESS_MODE_MULTIPLE_CLIENTS,);

  175.     CARLA_SAFE_ASSERT_RETURN(type != kEngineControlEventTypeNull,);

  176.     CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

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

  178. 

  179.     if (type == kEngineControlEventTypeParameter)

  180.     {

  181.         CARLA_ASSERT(! MIDI_IS_CONTROL_BANK_SELECT(param));

  182.     }

  183. 

  184.     const float fixedValue(carla_fixValue<float>(0.0f, 1.0f, value));

  185. 

  186.     for (uint32_t i=0; i < kEngineMaxInternalEventCount; ++i)

  187.     {

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

  189.             continue;

  190. 

  191.         fBuffer[i].type    = kEngineEventTypeControl;

  192.         fBuffer[i].time    = time;

  193.         fBuffer[i].channel = channel;

  194. 

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

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

  197.         fBuffer[i].ctrl.value = fixedValue;

  198. 

  199.         return;

  200.     }

  201. 

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

  203. }

  204. 

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

  206. {

  207.     CARLA_SAFE_ASSERT_RETURN(! fIsInput,);

  208.     CARLA_SAFE_ASSERT_RETURN(fBuffer != nullptr,);

  209.     CARLA_SAFE_ASSERT_RETURN(fEngine.getProccessMode() != PROCESS_MODE_SINGLE_CLIENT && fEngine.getProccessMode() != PROCESS_MODE_MULTIPLE_CLIENTS,);

  210.     CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

  211.     CARLA_SAFE_ASSERT_RETURN(data != nullptr,);

  212.     CARLA_SAFE_ASSERT_RETURN(size > 0 && size <= 4,);

  213. 

  214.     for (uint32_t i=0; i < kEngineMaxInternalEventCount; ++i)

  215.     {

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

  217.             continue;

  218. 

  219.         fBuffer[i].type    = kEngineEventTypeMidi;

  220.         fBuffer[i].time    = time;

  221.         fBuffer[i].channel = channel;

  222. 

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

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

  225. 

  226.         fBuffer[i].midi.data[0] = MIDI_GET_CHANNEL_FROM_DATA(data);

  227. 

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

  229.             fBuffer[i].midi.data[j] = data[j];

  230. 

  231.         return;

  232.     }

  233. 

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

  235. }

  236. 

  237. // -----------------------------------------------------------------------

  238. // Carla Engine client (Abstract)

  239. 

  240. CarlaEngineClient::CarlaEngineClient(const CarlaEngine& engine)

  241.     : fEngine(engine),

  242.       fActive(false),

  243.       fLatency(0)

  244. {

  245.     carla_debug("CarlaEngineClient::CarlaEngineClient(name:\"%s\")", engine.getName());

  246. }

  247. 

  248. CarlaEngineClient::~CarlaEngineClient()

  249. {

  250.     CARLA_ASSERT(! fActive);

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

  252. }

  253. 

  254. void CarlaEngineClient::activate()

  255. {

  256.     CARLA_ASSERT(! fActive);

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

  258. 

  259.     fActive = true;

  260. }

  261. 

  262. void CarlaEngineClient::deactivate()

  263. {

  264.     CARLA_ASSERT(fActive);

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

  266. 

  267.     fActive = false;

  268. }

  269. 

  270. bool CarlaEngineClient::isActive() const

  271. {

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

  273. 

  274.     return fActive;

  275. }

  276. 

  277. bool CarlaEngineClient::isOk() const

  278. {

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

  280. 

  281.     return true;

  282. }

  283. 

  284. uint32_t CarlaEngineClient::getLatency() const

  285. {

  286.     return fLatency;

  287. }

  288. 

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

  290. {

  291.     fLatency = samples;

  292. }

  293. 

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

  295. {

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

  297. 

  298.     switch (portType)

  299.     {

  300.     case kEnginePortTypeNull:

  301.         break;

  302.     case kEnginePortTypeAudio:

  303.         return new CarlaEngineAudioPort(fEngine, isInput);

  304.     case kEnginePortTypeCV:

  305.         return new CarlaEngineCVPort(fEngine, isInput);

  306.     case kEnginePortTypeEvent:

  307.         return new CarlaEngineEventPort(fEngine, isInput);

  308.     case kEnginePortTypeOSC:

  309.         return nullptr; //new CarlaEngineOscPort(fEngine, isInput);

  310.     }

  311. 

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

  313.     return nullptr;

  314. }

  315. 

  316. // -----------------------------------------------------------------------

  317. // Carla Engine

  318. 

  319. CarlaEngine::CarlaEngine()

  320.     : fBufferSize(0),

  321.       fSampleRate(0.0),

  322.       pData(new CarlaEngineProtectedData(this))

  323. {

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

  325. }

  326. 

  327. CarlaEngine::~CarlaEngine()

  328. {

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

  330. 

  331.     delete pData;

  332. }

  333. 

  334. // -----------------------------------------------------------------------

  335. // Static values and calls

  336. 

  337. unsigned int CarlaEngine::getDriverCount()

  338. {

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

  340. 

  341.     unsigned int count = 1; // JACK

  342. 

  343. #ifndef BUILD_BRIDGE

  344.     count += getRtAudioApiCount();

  345.     count += getJuceApiCount();

  346. #endif

  347. 

  348.     return count;

  349. }

  350. 

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

  352. {

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

  354. 

  355.     if (index == 0)

  356.         return "JACK";

  357. 

  358. #ifndef BUILD_BRIDGE

  359.     const unsigned int rtAudioIndex(index-1);

  360. 

  361.     if (rtAudioIndex < getRtAudioApiCount())

  362.         return getRtAudioApiName(rtAudioIndex);

  363. 

  364.     const unsigned int juceIndex(index-rtAudioIndex-1);

  365. 

  366.     if (juceIndex < getJuceApiCount())

  367.         return getJuceApiName(juceIndex);

  368. #endif

  369. 

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

  371.     return nullptr;

  372. }

  373. 

  374. const char** CarlaEngine::getDriverDeviceNames(const unsigned int index)

  375. {

  376.     carla_debug("CarlaEngine::getDriverDeviceNames(%i)", index);

  377. 

  378.     if (index == 0)

  379.         return nullptr;

  380. 

  381. #ifndef BUILD_BRIDGE

  382.     const unsigned int rtAudioIndex(index-1);

  383. 

  384.     if (rtAudioIndex < getRtAudioApiCount())

  385.         return getRtAudioApiDeviceNames(rtAudioIndex);

  386. 

  387.     const unsigned int juceIndex(index-rtAudioIndex-1);

  388. 

  389.     if (juceIndex < getJuceApiCount())

  390.         return getJuceApiDeviceNames(juceIndex);

  391. #endif

  392. 

  393.     carla_stderr("CarlaEngine::getDriverDeviceNames(%i) - invalid index", index);

  394.     return nullptr;

  395. }

  396. 

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

  398. {

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

  400. 

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

  402.         return newJack();

  403. 

  404. #ifdef __LINUX_ALSA__

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

  406.         return newRtAudio(RTAUDIO_LINUX_ALSA);

  407. #endif

  408. #ifdef __LINUX_PULSE__

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

  410.         return newRtAudio(RTAUDIO_LINUX_PULSE);

  411. #endif

  412. #ifdef __LINUX_OSS__

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

  414.         return newRtAudio(RTAUDIO_LINUX_OSS);

  415. #endif

  416. #ifdef __UNIX_JACK__

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

  418.         return newRtAudio(RTAUDIO_UNIX_JACK);

  419. #endif

  420. #ifdef __MACOSX_CORE__

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

  422.         return newRtAudio(RTAUDIO_MACOSX_CORE);

  423. #endif

  424. #ifdef __WINDOWS_ASIO__

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

  426.         return newRtAudio(RTAUDIO_WINDOWS_ASIO);

  427. #endif

  428. #ifdef __WINDOWS_DS__

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

  430.         return newRtAudio(RTAUDIO_WINDOWS_DS);

  431. #endif

  432. 

  433.     carla_stderr("CarlaEngine::newDriverByName(\"%s\") - invalid driver name", driverName);

  434.     return nullptr;

  435. }

  436. 

  437. // -----------------------------------------------------------------------

  438. // Maximum values

  439. 

  440. unsigned int CarlaEngine::getMaxClientNameSize() const

  441. {

  442.     return STR_MAX/2;

  443. }

  444. 

  445. unsigned int CarlaEngine::getMaxPortNameSize() const

  446. {

  447.     return STR_MAX;

  448. }

  449. 

  450. unsigned int CarlaEngine::getCurrentPluginCount() const noexcept

  451. {

  452.     return pData->curPluginCount;

  453. }

  454. 

  455. unsigned int CarlaEngine::getMaxPluginNumber() const noexcept

  456. {

  457.     return pData->maxPluginNumber;

  458. }

  459. 

  460. // -----------------------------------------------------------------------

  461. // Virtual, per-engine type calls

  462. 

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

  464. {

  465.     CARLA_ASSERT(fName.isEmpty());

  466.     CARLA_ASSERT(pData->oscData == nullptr);

  467.     CARLA_ASSERT(pData->plugins == nullptr);

  468.     CARLA_ASSERT(pData->bufEvents.in  == nullptr);

  469.     CARLA_ASSERT(pData->bufEvents.out == nullptr);

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

  471. 

  472.     pData->aboutToClose = false;

  473.     pData->curPluginCount = 0;

  474.     pData->maxPluginNumber = 0;

  475.     pData->nextPluginId = 0;

  476. 

  477.     switch (fOptions.processMode)

  478.     {

  479.     case PROCESS_MODE_SINGLE_CLIENT:

  480.     case PROCESS_MODE_MULTIPLE_CLIENTS:

  481.         pData->maxPluginNumber = MAX_DEFAULT_PLUGINS;

  482.         break;

  483. 

  484.     case PROCESS_MODE_CONTINUOUS_RACK:

  485.         pData->maxPluginNumber = MAX_RACK_PLUGINS;

  486.         pData->bufEvents.in  = new EngineEvent[kEngineMaxInternalEventCount];

  487.         pData->bufEvents.out = new EngineEvent[kEngineMaxInternalEventCount];

  488.         break;

  489. 

  490.     case PROCESS_MODE_PATCHBAY:

  491.         pData->maxPluginNumber = MAX_PATCHBAY_PLUGINS;

  492.         break;

  493. 

  494.     case PROCESS_MODE_BRIDGE:

  495.         pData->maxPluginNumber = 1;

  496.         pData->bufEvents.in  = new EngineEvent[kEngineMaxInternalEventCount];

  497.         pData->bufEvents.out = new EngineEvent[kEngineMaxInternalEventCount];

  498.         break;

  499.     }

  500. 

  501.     if (pData->maxPluginNumber == 0)

  502.         return false;

  503. 

  504.     pData->nextPluginId = pData->maxPluginNumber;

  505. 

  506.     fName = clientName;

  507.     fName.toBasic();

  508. 

  509.     fTimeInfo.clear();

  510. 

  511.     pData->plugins = new EnginePluginData[pData->maxPluginNumber];

  512. 

  513.     pData->osc.init(clientName);

  514. #ifndef BUILD_BRIDGE

  515.     pData->oscData = pData->osc.getControlData();

  516. #endif

  517. 

  518.     pData->nextAction.ready();

  519.     pData->thread.startThread();

  520. 

  521.     return true;

  522. }

  523. 

  524. bool CarlaEngine::close()

  525. {

  526.     CARLA_ASSERT(fName.isNotEmpty());

  527.     CARLA_ASSERT(pData->plugins != nullptr);

  528.     CARLA_ASSERT(pData->nextAction.opcode == kEnginePostActionNull);

  529.     CARLA_ASSERT(pData->nextPluginId == pData->maxPluginNumber);

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

  531. 

  532.     pData->thread.stopThread(500);

  533.     pData->nextAction.ready();

  534. 

  535. #ifndef BUILD_BRIDGE

  536.     oscSend_control_exit();

  537. #endif

  538.     pData->osc.close();

  539.     pData->oscData = nullptr;

  540. 

  541.     pData->aboutToClose = true;

  542.     pData->curPluginCount = 0;

  543.     pData->maxPluginNumber = 0;

  544.     pData->nextPluginId = 0;

  545. 

  546.     if (pData->plugins != nullptr)

  547.     {

  548.         delete[] pData->plugins;

  549.         pData->plugins = nullptr;

  550.     }

  551. 

  552.     if (pData->bufEvents.in != nullptr)

  553.     {

  554.         delete[] pData->bufEvents.in;

  555.         pData->bufEvents.in = nullptr;

  556.     }

  557. 

  558.     if (pData->bufEvents.out != nullptr)

  559.     {

  560.         delete[] pData->bufEvents.out;

  561.         pData->bufEvents.out = nullptr;

  562.     }

  563. 

  564.     fName.clear();

  565. 

  566.     return true;

  567. }

  568. 

  569. void CarlaEngine::idle()

  570. {

  571.     CARLA_ASSERT(pData->nextAction.opcode == kEnginePostActionNull); // TESTING, remove later

  572.     CARLA_ASSERT(pData->nextPluginId == pData->maxPluginNumber);     // TESTING, remove later

  573.     CARLA_ASSERT(pData->plugins != nullptr); // this one too maybe

  574. 

  575.     for (unsigned int i=0; i < pData->curPluginCount; ++i)

  576.     {

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

  578. 

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

  580.             plugin->idleGui();

  581.     }

  582. }

  583. 

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

  585. {

  586.     return new CarlaEngineClient(*this);

  587. }

  588. 

  589. // -----------------------------------------------------------------------

  590. // Plugin management

  591. 

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

  593. {

  594.     CARLA_ASSERT(btype != BINARY_NONE);

  595.     CARLA_ASSERT(ptype != PLUGIN_NONE);

  596.     CARLA_ASSERT(pData->plugins != nullptr);

  597.     CARLA_ASSERT(pData->nextAction.opcode == kEnginePostActionNull);

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

  599. 

  600.     unsigned int id;

  601. 

  602.     if (pData->nextPluginId < pData->curPluginCount)

  603.     {

  604.         id = pData->nextPluginId;

  605.         pData->nextPluginId = pData->maxPluginNumber;

  606. 

  607.         CARLA_ASSERT(pData->plugins[id].plugin != nullptr);

  608.     }

  609.     else

  610.     {

  611.         id = pData->curPluginCount;

  612. 

  613.         if (id == pData->maxPluginNumber)

  614.         {

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

  616.             return false;

  617.         }

  618. 

  619.         CARLA_ASSERT(pData->plugins[id].plugin == nullptr);

  620.     }

  621. 

  622.     CarlaPlugin::Initializer init = {

  623.         this,

  624.         id,

  625.         filename,

  626.         name,

  627.         label

  628.     };

  629. 

  630.     CarlaPlugin* plugin = nullptr;

  631. 

  632. #ifndef BUILD_BRIDGE

  633.     const char* bridgeBinary;

  634. 

  635.     switch (btype)

  636.     {

  637.     case BINARY_POSIX32:

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

  639.         break;

  640.     case BINARY_POSIX64:

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

  642.         break;

  643.     case BINARY_WIN32:

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

  645.         break;

  646.     case BINARY_WIN64:

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

  648.         break;

  649.     default:

  650.         bridgeBinary = nullptr;

  651.         break;

  652.     }

  653. 

  654. # ifndef Q_OS_WIN

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

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

  657. # endif

  658. 

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

  660.     {

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

  662.     }

  663.     else

  664. #endif // BUILD_BRIDGE

  665.     {

  666.         switch (ptype)

  667.         {

  668.         case PLUGIN_NONE:

  669.             break;

  670. 

  671.         case PLUGIN_INTERNAL:

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

  673.             break;

  674. 

  675.         case PLUGIN_LADSPA:

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

  677.             break;

  678. 

  679.         case PLUGIN_DSSI:

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

  681.             break;

  682. 

  683.         case PLUGIN_LV2:

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

  685.             break;

  686. 

  687.         case PLUGIN_VST:

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

  689.             break;

  690. 

  691.         case PLUGIN_AU:

  692.             //plugin = CarlaPlugin::newAU(init);

  693.             break;

  694. 

  695.         case PLUGIN_CSOUND:

  696.             //plugin = CarlaPlugin::newCSOUND(init);

  697.             break;

  698. 

  699.         case PLUGIN_GIG:

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

  701.             break;

  702. 

  703.         case PLUGIN_SF2:

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

  705.             break;

  706. 

  707.         case PLUGIN_SFZ:

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

  709.             break;

  710.         }

  711.     }

  712. 

  713.     if (plugin == nullptr)

  714.         return false;

  715. 

  716.     plugin->registerToOscClient();

  717. 

  718.     pData->plugins[id].plugin      = plugin;

  719.     pData->plugins[id].insPeak[0]  = 0.0f;

  720.     pData->plugins[id].insPeak[1]  = 0.0f;

  721.     pData->plugins[id].outsPeak[0] = 0.0f;

  722.     pData->plugins[id].outsPeak[1] = 0.0f;

  723. 

  724.     ++pData->curPluginCount;

  725. 

  726.     callback(CALLBACK_PLUGIN_ADDED, id, 0, 0, 0.0f, plugin->getName());

  727.     return true;

  728. }

  729. 

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

  731. {

  732.     CARLA_ASSERT(pData->curPluginCount != 0);

  733.     CARLA_ASSERT(id < pData->curPluginCount);

  734.     CARLA_ASSERT(pData->plugins != nullptr);

  735.     CARLA_ASSERT(pData->nextAction.opcode == kEnginePostActionNull);

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

  737. 

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

  739.     {

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

  741.         return false;

  742.     }

  743. 

  744.     CarlaPlugin* const plugin(pData->plugins[id].plugin);

  745. 

  746.     if (plugin == nullptr)

  747.     {

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

  749.         return false;

  750.     }

  751. 

  752.     CARLA_ASSERT(plugin->getId() == id);

  753. 

  754.     pData->thread.stopThread(500);

  755. 

  756.     const bool lockWait(isRunning() && fOptions.processMode != PROCESS_MODE_MULTIPLE_CLIENTS);

  757.     const CarlaEngineProtectedData::ScopedActionLock sal(pData, kEnginePostActionRemovePlugin, id, 0, lockWait);

  758. 

  759. #ifndef BUILD_BRIDGE

  760.     if (isOscControlRegistered())

  761.         oscSend_control_remove_plugin(id);

  762. #endif

  763. 

  764.     delete plugin;

  765. 

  766.     if (isRunning() && ! pData->aboutToClose)

  767.         pData->thread.startThread();

  768. 

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

  770.     return true;

  771. }

  772. 

  773. void CarlaEngine::removeAllPlugins()

  774. {

  775.     CARLA_ASSERT(pData->plugins != nullptr);

  776.     CARLA_ASSERT(pData->nextAction.opcode == kEnginePostActionNull);

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

  778. 

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

  780.         return;

  781. 

  782.     pData->thread.stopThread(500);

  783. 

  784.     const bool lockWait(isRunning());

  785.     const CarlaEngineProtectedData::ScopedActionLock sal(pData, kEnginePostActionZeroCount, 0, 0, lockWait);

  786. 

  787.     for (unsigned int i=0; i < pData->maxPluginNumber; ++i)

  788.     {

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

  790. 

  791.         pData->plugins[i].plugin = nullptr;

  792. 

  793.         if (plugin != nullptr)

  794.             delete plugin;

  795. 

  796.         // clear this plugin

  797.         pData->plugins[i].insPeak[0]  = 0.0f;

  798.         pData->plugins[i].insPeak[1]  = 0.0f;

  799.         pData->plugins[i].outsPeak[0] = 0.0f;

  800.         pData->plugins[i].outsPeak[1] = 0.0f;

  801.     }

  802. 

  803.     if (isRunning() && ! pData->aboutToClose)

  804.         pData->thread.startThread();

  805. 

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

  807. }

  808. 

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

  810. {

  811.     CARLA_ASSERT(pData->curPluginCount != 0);

  812.     CARLA_ASSERT(id < pData->curPluginCount);

  813.     CARLA_ASSERT(pData->plugins != nullptr);

  814.     CARLA_ASSERT(pData->nextAction.opcode == kEnginePostActionNull);

  815.     CARLA_ASSERT(newName != nullptr);

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

  817. 

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

  819.     {

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

  821.         return nullptr;

  822.     }

  823. 

  824.     CarlaPlugin* const plugin(pData->plugins[id].plugin);

  825. 

  826.     if (plugin == nullptr)

  827.     {

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

  829.         return nullptr;

  830.     }

  831. 

  832.     CARLA_ASSERT(plugin->getId() == id);

  833. 

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

  835.     {

  836.         plugin->setName(name);

  837.         return name;

  838.     }

  839. 

  840.     return nullptr;

  841. }

  842. 

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

  844. {

  845.     CARLA_ASSERT(pData->curPluginCount > 0);

  846.     CARLA_ASSERT(id < pData->curPluginCount);

  847.     CARLA_ASSERT(pData->plugins != nullptr);

  848.     CARLA_ASSERT(pData->nextAction.opcode == kEnginePostActionNull);

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

  850. 

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

  852.     {

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

  854.         return false;

  855.     }

  856. 

  857.     CarlaPlugin* const plugin(pData->plugins[id].plugin);

  858. 

  859.     if (plugin == nullptr)

  860.     {

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

  862.         return false;

  863.     }

  864. 

  865.     CARLA_ASSERT(plugin->getId() == id);

  866. 

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

  868.     plugin->getLabel(label);

  869. 

  870.     const unsigned int pluginCountBefore(pData->curPluginCount);

  871. 

  872.     if (! addPlugin(plugin->getBinaryType(), plugin->getType(), plugin->getFilename(), plugin->getName(), label, plugin->getExtraStuff()))

  873.         return false;

  874. 

  875.     CARLA_ASSERT(pluginCountBefore+1 == pData->curPluginCount);

  876. 

  877.     if (CarlaPlugin* const newPlugin = pData->plugins[pluginCountBefore].plugin)

  878.         newPlugin->loadSaveState(plugin->getSaveState());

  879. 

  880.     return true;

  881. }

  882. 

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

  884. {

  885.     CARLA_ASSERT(pData->curPluginCount > 0);

  886.     CARLA_ASSERT(id < pData->curPluginCount);

  887.     CARLA_ASSERT(pData->plugins != nullptr);

  888.     CARLA_ASSERT(pData->nextAction.opcode == kEnginePostActionNull);

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

  890. 

  891.     if (id < pData->curPluginCount)

  892.         pData->nextPluginId = id;

  893. 

  894.     return false;

  895. }

  896. 

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

  898. {

  899.     CARLA_ASSERT(pData->curPluginCount >= 2);

  900.     CARLA_ASSERT(pData->plugins != nullptr);

  901.     CARLA_ASSERT(pData->nextAction.opcode == kEnginePostActionNull);

  902.     CARLA_ASSERT(idA != idB);

  903.     CARLA_ASSERT(idA < pData->curPluginCount);

  904.     CARLA_ASSERT(idB < pData->curPluginCount);

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

  906. 

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

  908.     {

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

  910.         return false;

  911.     }

  912. 

  913.     pData->thread.stopThread(500);

  914. 

  915.     const bool lockWait(isRunning() && fOptions.processMode != PROCESS_MODE_MULTIPLE_CLIENTS);

  916.     const CarlaEngineProtectedData::ScopedActionLock sal(pData, kEnginePostActionSwitchPlugins, idA, idB, lockWait);

  917. 

  918. #ifndef BUILD_BRIDGE // TODO

  919.     //if (isOscControlRegistered())

  920.     //    oscSend_control_switch_plugins(idA, idB);

  921. #endif

  922. 

  923.     if (isRunning() && ! pData->aboutToClose)

  924.         pData->thread.startThread();

  925. 

  926.     return true;

  927. }

  928. 

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

  930. {

  931.     CARLA_ASSERT(pData->curPluginCount != 0);

  932.     CARLA_ASSERT(id < pData->curPluginCount);

  933.     CARLA_ASSERT(pData->plugins != nullptr);

  934.     CARLA_ASSERT(pData->nextAction.opcode == kEnginePostActionNull); // TESTING, remove later

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

  936. 

  937.     if (id < pData->curPluginCount && pData->plugins != nullptr)

  938.         return pData->plugins[id].plugin;

  939. 

  940.     return nullptr;

  941. }

  942. 

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

  944. {

  945.     return pData->plugins[id].plugin;

  946. }

  947. 

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

  949. {

  950.     CARLA_ASSERT(pData->maxPluginNumber != 0);

  951.     CARLA_ASSERT(pData->plugins != nullptr);

  952.     CARLA_ASSERT(pData->nextAction.opcode == kEnginePostActionNull);

  953.     CARLA_ASSERT(name != nullptr);

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

  955. 

  956.     static CarlaString sname;

  957.     sname = name;

  958. 

  959.     if (sname.isEmpty())

  960.     {

  961.         sname = "(No name)";

  962.         return (const char*)sname;

  963.     }

  964. 

  965.     if (pData->plugins == nullptr || pData->maxPluginNumber == 0)

  966.         return (const char*)sname;

  967. 

  968.     sname.truncate(getMaxClientNameSize()-5-1); // 5 = strlen(" (10)")

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

  970. 

  971.     for (unsigned short i=0; i < pData->curPluginCount; ++i)

  972.     {

  973.         CARLA_ASSERT(pData->plugins[i].plugin != nullptr);

  974. 

  975.         if (pData->plugins[i].plugin == nullptr)

  976.             break;

  977. 

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

  979.         if (const char* const pluginName = pData->plugins[i].plugin->getName())

  980.         {

  981.             if (sname != pluginName)

  982.                 continue;

  983.         }

  984. 

  985.         // Check if string has already been modified

  986.         {

  987.             const size_t len(sname.length());

  988. 

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

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

  991.             {

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

  993. 

  994.                 if (number == 9)

  995.                 {

  996.                     // next number is 10, 2 digits

  997.                     sname.truncate(len-4);

  998.                     sname += " (10)";

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

  1000.                 }

  1001.                 else

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

  1003. 

  1004.                 continue;

  1005.             }

  1006. 

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

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

  1009.             {

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

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

  1012. 

  1013.                 if (n2 == '9')

  1014.                 {

  1015.                     n2  = '0';

  1016.                     n3 += 1;

  1017.                 }

  1018.                 else

  1019.                     n2 += 1;

  1020. 

  1021.                 sname[len-2] = n2;

  1022.                 sname[len-3] = n3;

  1023. 

  1024.                 continue;

  1025.             }

  1026.         }

  1027. 

  1028.         // Modify string if not

  1029.         sname += " (2)";

  1030.     }

  1031. 

  1032.     return (const char*)sname;

  1033. }

  1034. 

  1035. // -----------------------------------------------------------------------

  1036. // Project management

  1037. 

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

  1039. {

  1040.     CARLA_ASSERT(filename != nullptr);

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

  1042. 

  1043. #if 0

  1044.     QFileInfo fileInfo(filename);

  1045. 

  1046.     if (! fileInfo.exists())

  1047.     {

  1048.         setLastError("File does not exist");

  1049.         return false;

  1050.     }

  1051. 

  1052.     if (! fileInfo.isFile())

  1053.     {

  1054.         setLastError("Not a file");

  1055.         return false;

  1056.     }

  1057. 

  1058.     if (! fileInfo.isReadable())

  1059.     {

  1060.         setLastError("File is not readable");

  1061.         return false;

  1062.     }

  1063. 

  1064.     CarlaString baseName(fileInfo.baseName().toUtf8().constData());

  1065.     CarlaString extension(fileInfo.suffix().toLower().toUtf8().constData());

  1066. 

  1067.     // -------------------------------------------------------------------

  1068. 

  1069.     if (extension == "carxp" || extension ==  "carxs")

  1070.         return loadProject(filename);

  1071. 

  1072.     // -------------------------------------------------------------------

  1073. 

  1074.     if (extension == "gig")

  1075.         return addPlugin(PLUGIN_GIG, filename, baseName, baseName);

  1076. 

  1077.     if (extension == "sf2")

  1078.         return addPlugin(PLUGIN_SF2, filename, baseName, baseName);

  1079. 

  1080.     if (extension == "sfz")

  1081.         return addPlugin(PLUGIN_SFZ, filename, baseName, baseName);

  1082. 

  1083.     // -------------------------------------------------------------------

  1084. 

  1085.     if (extension == "aiff" || extension == "flac" || extension == "oga" || extension == "ogg" || extension == "w64" || extension == "wav")

  1086.     {

  1087. #ifdef WANT_AUDIOFILE

  1088.         if (addPlugin(PLUGIN_INTERNAL, nullptr, baseName, "audiofile"))

  1089.         {

  1090.             if (CarlaPlugin* const plugin = getPlugin(pData->curPluginCount-1))

  1091.                 plugin->setCustomData(CUSTOM_DATA_STRING, "file", filename, true);

  1092.             return true;

  1093.         }

  1094.         return false;

  1095. #else

  1096.         setLastError("This Carla build does not have Audio file support");

  1097.         return false;

  1098. #endif

  1099.     }

  1100. 

  1101.     if (extension == "3g2" || extension == "3gp" || extension == "aac" || extension == "ac3" || extension == "amr" || extension == "ape" ||

  1102.         extension == "mp2" || extension == "mp3" || extension == "mpc" || extension == "wma")

  1103.     {

  1104. #ifdef WANT_AUDIOFILE

  1105. # ifdef HAVE_FFMPEG

  1106.         if (addPlugin(PLUGIN_INTERNAL, nullptr, baseName, "audiofile"))

  1107.         {

  1108.             if (CarlaPlugin* const plugin = getPlugin(pData->curPluginCount-1))

  1109.                 plugin->setCustomData(CUSTOM_DATA_STRING, "file", filename, true);

  1110.             return true;

  1111.         }

  1112.         return false;

  1113. # else

  1114.         setLastError("This Carla build has Audio file support, but not libav/ffmpeg");

  1115.         return false;

  1116. # endif

  1117. #else

  1118.         setLastError("This Carla build does not have Audio file support");

  1119.         return false;

  1120. #endif

  1121.     }

  1122. 

  1123.     // -------------------------------------------------------------------

  1124. 

  1125.     if (extension == "mid" || extension == "midi")

  1126.     {

  1127. #ifdef WANT_MIDIFILE

  1128.         if (addPlugin(PLUGIN_INTERNAL, nullptr, baseName, "midifile"))

  1129.         {

  1130.             if (CarlaPlugin* const plugin = getPlugin(pData->curPluginCount-1))

  1131.                 plugin->setCustomData(CUSTOM_DATA_STRING, "file", filename, true);

  1132.             return true;

  1133.         }

  1134.         return false;

  1135. #else

  1136.         setLastError("This Carla build does not have MIDI file support");

  1137.         return false;

  1138. #endif

  1139.     }

  1140. 

  1141.     // -------------------------------------------------------------------

  1142.     // ZynAddSubFX

  1143. 

  1144.     if (extension == "xmz" || extension == "xiz")

  1145.     {

  1146. #ifdef WANT_ZYNADDSUBFX

  1147.         if (addPlugin(PLUGIN_INTERNAL, nullptr, baseName, "zynaddsubfx"))

  1148.         {

  1149.             if (CarlaPlugin* const plugin = getPlugin(pData->curPluginCount-1))

  1150.                 plugin->setCustomData(CUSTOM_DATA_STRING, (extension == "xmz") ? "CarlaAlternateFile1" : "CarlaAlternateFile2", filename, true);

  1151.             return true;

  1152.         }

  1153.         return false;

  1154. #else

  1155.         setLastError("This Carla build does not have ZynAddSubFX support");

  1156.         return false;

  1157. #endif

  1158.     }

  1159. 

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

  1161. #endif

  1162. 

  1163.     setLastError("Unknown file extension");

  1164.     return false;

  1165. }

  1166. 

  1167. bool charEndsWith(const char* const str, const char* const suffix)

  1168. {

  1169.     if (str == nullptr || suffix == nullptr)

  1170.         return false;

  1171. 

  1172.     const size_t strLen(std::strlen(str));

  1173.     const size_t suffixLen(std::strlen(suffix));

  1174. 

  1175.     if (strLen < suffixLen)

  1176.         return false;

  1177. 

  1178.     return (std::strncmp(str + (strLen-suffixLen), suffix, suffixLen) == 0);

  1179. }

  1180. 

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

  1182. {

  1183.     CARLA_ASSERT(filename != nullptr);

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

  1185. 

  1186. #if 0

  1187.     QFile file(filename);

  1188. 

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

  1190.         return false;

  1191. 

  1192.     QDomDocument xml;

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

  1194.     file.close();

  1195. 

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

  1197. 

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

  1199.     {

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

  1201.         return false;

  1202.     }

  1203. 

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

  1205. 

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

  1207. 

  1208.     while (! node.isNull())

  1209.     {

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

  1211.         {

  1212.             SaveState saveState;

  1213.             fillSaveStateFromXmlNode(saveState, isPreset ? xmlNode : node);

  1214. 

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

  1216. 

  1217.             if (saveState.type == nullptr)

  1218.                 continue;

  1219. 

  1220.             const void* extraStuff = nullptr;

  1221. 

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

  1223.             {

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

  1225.             }

  1226.             else if (std::strcmp(saveState.type, "SF2") == 0)

  1227.             {

  1228.                 const char use16OutsSuffix[] = " (16 outs)";

  1229. 

  1230.                 if (charEndsWith(saveState.label, use16OutsSuffix))

  1231.                     extraStuff = (void*)0x1; // non-null

  1232.             }

  1233. 

  1234.             // TODO - proper find&load plugins

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

  1236.             {

  1237.                 if (CarlaPlugin* plugin = getPlugin(pData->curPluginCount-1))

  1238.                     plugin->loadSaveState(saveState);

  1239.             }

  1240.         }

  1241. 

  1242.         if (isPreset)

  1243.             break;

  1244. 

  1245.         node = node.nextSibling();

  1246.     }

  1247. 

  1248.     return true;

  1249. #endif

  1250.     setLastError("Not implemented yet");

  1251.     return false;

  1252. }

  1253. 

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

  1255. {

  1256.     CARLA_ASSERT(filename != nullptr);

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

  1258. 

  1259. #if 0

  1260.     QFile file(filename);

  1261. 

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

  1263.         return false;

  1264. 

  1265.     QTextStream out(&file);

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

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

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

  1269. 

  1270.     bool firstPlugin = true;

  1271.     char strBuf[STR_MAX+1];

  1272. 

  1273.     for (unsigned int i=0; i < pData->curPluginCount; ++i)

  1274.     {

  1275.         CarlaPlugin* const plugin = pData->plugins[i].plugin;

  1276. 

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

  1278.         {

  1279.             if (! firstPlugin)

  1280.                 out << "\n";

  1281. 

  1282.             plugin->getRealName(strBuf);

  1283. 

  1284.             if (*strBuf != 0)

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

  1286. 

  1287.             QString content;

  1288.             fillXmlStringFromSaveState(content, plugin->getSaveState());

  1289. 

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

  1291.             out << content;

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

  1293. 

  1294.             firstPlugin = false;

  1295.         }

  1296.     }

  1297. 

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

  1299. 

  1300.     file.close();

  1301.     return true;

  1302. #endif

  1303.     setLastError("Not implemented yet");

  1304.     return false;

  1305. }

  1306. 

  1307. // -----------------------------------------------------------------------

  1308. // Information (peaks)

  1309. 

  1310. // FIXME

  1311. 

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

  1313. {

  1314.     CARLA_ASSERT(pluginId < pData->curPluginCount);

  1315.     CARLA_ASSERT(id-1 < 2);

  1316. 

  1317.     if (id == 0 || id > 2)

  1318.         return 0.0f;

  1319. 

  1320.     return pData->plugins[pluginId].insPeak[id-1];

  1321. }

  1322. 

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

  1324. {

  1325.     CARLA_ASSERT(pluginId < pData->curPluginCount);

  1326.     CARLA_ASSERT(id-1 < 2);

  1327. 

  1328.     if (id == 0 || id > 2)

  1329.         return 0.0f;

  1330. 

  1331.     return pData->plugins[pluginId].outsPeak[id-1];

  1332. }

  1333. 

  1334. // -----------------------------------------------------------------------

  1335. // Callback

  1336. 

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

  1338. {

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

  1340. 

  1341.     if (pData->callback)

  1342.         pData->callback(pData->callbackPtr, action, pluginId, value1, value2, value3, valueStr);

  1343. }

  1344. 

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

  1346. {

  1347.     CARLA_ASSERT(func != nullptr);

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

  1349. 

  1350.     pData->callback    = func;

  1351.     pData->callbackPtr = ptr;

  1352. }

  1353. 

  1354. // -----------------------------------------------------------------------

  1355. // Patchbay

  1356. 

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

  1358. {

  1359.     setLastError("Unsupported operation");

  1360.     return false;

  1361. }

  1362. 

  1363. bool CarlaEngine::patchbayDisconnect(int)

  1364. {

  1365.     setLastError("Unsupported operation");

  1366.     return false;

  1367. }

  1368. 

  1369. void CarlaEngine::patchbayRefresh()

  1370. {

  1371.     // nothing

  1372. }

  1373. 

  1374. // -----------------------------------------------------------------------

  1375. // Transport

  1376. 

  1377. void CarlaEngine::transportPlay()

  1378. {

  1379.     pData->time.playing = true;

  1380. }

  1381. 

  1382. void CarlaEngine::transportPause()

  1383. {

  1384.     pData->time.playing = false;

  1385. }

  1386. 

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

  1388. {

  1389.     pData->time.frame = frame;

  1390. }

  1391. 

  1392. // -----------------------------------------------------------------------

  1393. // Error handling

  1394. 

  1395. const char* CarlaEngine::getLastError() const noexcept

  1396. {

  1397.     return (const char*)pData->lastError;

  1398. }

  1399. 

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

  1401. {

  1402.     pData->lastError = error;

  1403. }

  1404. 

  1405. void CarlaEngine::setAboutToClose()

  1406. {

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

  1408.     pData->aboutToClose = true;

  1409. }

  1410. 

  1411. // -----------------------------------------------------------------------

  1412. // Global options

  1413. 

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

  1415. {

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

  1417. 

  1418.     if (option >= OPTION_PROCESS_MODE && option < OPTION_PATH_RESOURCES && isRunning())

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

  1420. 

  1421.     switch (option)

  1422.     {

  1423.     case OPTION_PROCESS_NAME:

  1424.         break;

  1425. 

  1426.     case OPTION_PROCESS_MODE:

  1427.         if (value < PROCESS_MODE_SINGLE_CLIENT || value > PROCESS_MODE_PATCHBAY)

  1428.             return carla_stderr("CarlaEngine::setOption(OPTION_PROCESS_MODE, %i, \"%s\") - invalid value", value, valueStr);

  1429. 

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

  1431.         break;

  1432. 

  1433.     case OPTION_TRANSPORT_MODE:

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

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

  1436. 

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

  1438.         break;

  1439. 

  1440.     case OPTION_FORCE_STEREO:

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

  1442.         break;

  1443. 

  1444.     case OPTION_PREFER_PLUGIN_BRIDGES:

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

  1446.         break;

  1447. 

  1448.     case OPTION_PREFER_UI_BRIDGES:

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

  1450.         break;

  1451. 

  1452.     case OPTION_UIS_ALWAYS_ON_TOP:

  1453.         fOptions.uisAlwaysOnTop = (value != 0);

  1454.         break;

  1455. 

  1456.     case OPTION_MAX_PARAMETERS:

  1457.         if (value < 1)

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

  1459. 

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

  1461.         break;

  1462. 

  1463.     case OPTION_UI_BRIDGES_TIMEOUT:

  1464.         if (value < 1)

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

  1466. 

  1467.         fOptions.uiBridgesTimeout = static_cast<uint>(value);

  1468.         break;

  1469. 

  1470.     case OPTION_AUDIO_NUM_PERIODS:

  1471.         if (value < 2 || value > 3)

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

  1473. 

  1474.         fOptions.audioNumPeriods = static_cast<uint>(value);

  1475.         break;

  1476. 

  1477.     case OPTION_AUDIO_BUFFER_SIZE:

  1478.         if (value < 8)

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

  1480. 

  1481.         fOptions.audioBufferSize = static_cast<uint>(value);

  1482.         break;

  1483. 

  1484.     case OPTION_AUDIO_SAMPLE_RATE:

  1485.         if (value < 22050)

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

  1487. 

  1488.         fOptions.audioSampleRate = static_cast<uint>(value);

  1489.         break;

  1490. 

  1491.     case OPTION_AUDIO_DEVICE:

  1492.         fOptions.audioDevice = valueStr;

  1493.         break;

  1494. 

  1495.     case OPTION_PATH_RESOURCES:

  1496.         fOptions.resourceDir = valueStr;

  1497.         break;

  1498. 

  1499. #ifndef BUILD_BRIDGE

  1500.     case OPTION_PATH_BRIDGE_NATIVE:

  1501.         fOptions.bridge_native = valueStr;

  1502.         break;

  1503.     case OPTION_PATH_BRIDGE_POSIX32:

  1504.         fOptions.bridge_posix32 = valueStr;

  1505.         break;

  1506.     case OPTION_PATH_BRIDGE_POSIX64:

  1507.         fOptions.bridge_posix64 = valueStr;

  1508.         break;

  1509.     case OPTION_PATH_BRIDGE_WIN32:

  1510.         fOptions.bridge_win32 = valueStr;

  1511.         break;

  1512.     case OPTION_PATH_BRIDGE_WIN64:

  1513.         fOptions.bridge_win64 = valueStr;

  1514.         break;

  1515. #endif

  1516. 

  1517. #ifdef WANT_LV2

  1518.     case OPTION_PATH_BRIDGE_LV2_EXTERNAL:

  1519.         fOptions.bridge_lv2Extrn = valueStr;

  1520.         break;

  1521.     case OPTION_PATH_BRIDGE_LV2_GTK2:

  1522.         fOptions.bridge_lv2Gtk2 = valueStr;

  1523.         break;

  1524.     case OPTION_PATH_BRIDGE_LV2_GTK3:

  1525.         fOptions.bridge_lv2Gtk3 = valueStr;

  1526.         break;

  1527.     case OPTION_PATH_BRIDGE_LV2_QT4:

  1528.         fOptions.bridge_lv2Qt4 = valueStr;

  1529.         break;

  1530.     case OPTION_PATH_BRIDGE_LV2_QT5:

  1531.         fOptions.bridge_lv2Qt5 = valueStr;

  1532.         break;

  1533.     case OPTION_PATH_BRIDGE_LV2_COCOA:

  1534.         fOptions.bridge_lv2Cocoa = valueStr;

  1535.         break;

  1536.     case OPTION_PATH_BRIDGE_LV2_WINDOWS:

  1537.         fOptions.bridge_lv2Win = valueStr;

  1538.         break;

  1539.     case OPTION_PATH_BRIDGE_LV2_X11:

  1540.         fOptions.bridge_lv2X11 = valueStr;

  1541.         break;

  1542. #endif

  1543. 

  1544. #ifdef WANT_VST

  1545.     case OPTION_PATH_BRIDGE_VST_MAC:

  1546.         fOptions.bridge_vstMac = valueStr;

  1547.         break;

  1548.     case OPTION_PATH_BRIDGE_VST_HWND:

  1549.         fOptions.bridge_vstHWND = valueStr;

  1550.         break;

  1551.     case OPTION_PATH_BRIDGE_VST_X11:

  1552.         fOptions.bridge_vstX11 = valueStr;

  1553.         break;

  1554. #endif

  1555.     }

  1556. }

  1557. 

  1558. // -----------------------------------------------------------------------

  1559. // OSC Stuff

  1560. 

  1561. #ifdef BUILD_BRIDGE

  1562. bool CarlaEngine::isOscBridgeRegistered() const noexcept

  1563. {

  1564.     return (pData->oscData != nullptr);

  1565. }

  1566. #else

  1567. bool CarlaEngine::isOscControlRegistered() const noexcept

  1568. {

  1569.     return pData->osc.isControlRegistered();

  1570. }

  1571. #endif

  1572. 

  1573. void CarlaEngine::idleOsc()

  1574. {

  1575.     pData->osc.idle();

  1576. }

  1577. 

  1578. const char* CarlaEngine::getOscServerPathTCP() const noexcept

  1579. {

  1580.     return pData->osc.getServerPathTCP();

  1581. }

  1582. 

  1583. const char* CarlaEngine::getOscServerPathUDP() const noexcept

  1584. {

  1585.     return pData->osc.getServerPathUDP();

  1586. }

  1587. 

  1588. #ifdef BUILD_BRIDGE

  1589. void CarlaEngine::setOscBridgeData(const CarlaOscData* const oscData) noexcept

  1590. {

  1591.     pData->oscData = oscData;

  1592. }

  1593. #endif

  1594. 

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

  1596. // protected calls

  1597. 

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

  1599. {

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

  1601. 

  1602.     for (unsigned int i=0; i < pData->curPluginCount; ++i)

  1603.     {

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

  1605. 

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

  1607.             plugin->bufferSizeChanged(newBufferSize);

  1608.     }

  1609. 

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

  1611. }

  1612. 

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

  1614. {

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

  1616. 

  1617.     for (unsigned int i=0; i < pData->curPluginCount; ++i)

  1618.     {

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

  1620. 

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

  1622.             plugin->sampleRateChanged(newSampleRate);

  1623.     }

  1624. 

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

  1626. }

  1627. 

  1628. void CarlaEngine::offlineModeChanged(const bool isOffline)

  1629. {

  1630.     carla_debug("CarlaEngine::offlineModeChanged(%s)", bool2str(isOffline));

  1631. 

  1632.     for (unsigned int i=0; i < pData->curPluginCount; ++i)

  1633.     {

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

  1635. 

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

  1637.             plugin->offlineModeChanged(isOffline);

  1638.     }

  1639. }

  1640. 

  1641. void CarlaEngine::runPendingRtEvents()

  1642. {

  1643.     pData->doNextPluginAction(true);

  1644. 

  1645.     if (pData->time.playing)

  1646.         pData->time.frame += fBufferSize;

  1647. 

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

  1649.     {

  1650.         fTimeInfo.playing = pData->time.playing;

  1651.         fTimeInfo.frame   = pData->time.frame;

  1652.     }

  1653. 

  1654.     for (unsigned int i=0; i < pData->curPluginCount; ++i)

  1655.     {

  1656.         // TODO - peak values?

  1657.     }

  1658. }

  1659. 

  1660. void CarlaEngine::setPluginPeaks(const unsigned int pluginId, float const inPeaks[2], float const outPeaks[2]) noexcept

  1661. {

  1662.     pData->plugins[pluginId].insPeak[0]  = inPeaks[0];

  1663.     pData->plugins[pluginId].insPeak[1]  = inPeaks[1];

  1664.     pData->plugins[pluginId].outsPeak[0] = outPeaks[0];

  1665.     pData->plugins[pluginId].outsPeak[1] = outPeaks[1];

  1666. }

  1667. 

  1668. EngineEvent* CarlaEngine::getInternalEventBuffer(const bool isInput) const noexcept

  1669. {

  1670.     return isInput ? pData->bufEvents.in : pData->bufEvents.out;

  1671. }

  1672. 

  1673. void CarlaEngine::registerEnginePlugin(const unsigned int id, CarlaPlugin* const plugin)

  1674. {

  1675.     CARLA_ASSERT(id == pData->curPluginCount);

  1676. 

  1677.     if (id == pData->curPluginCount)

  1678.         pData->plugins[id].plugin = plugin;

  1679. }

  1680. 

  1681. #ifndef BUILD_BRIDGE

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

  1683. {

  1684.     if (value < compare)

  1685.         value = compare;

  1686. }

  1687. 

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

  1689. {

  1690.     CARLA_ASSERT(pData->bufEvents.in != nullptr);

  1691.     CARLA_ASSERT(pData->bufEvents.out != nullptr);

  1692. 

  1693.     // initialize outputs (zero)

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

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

  1696.     carla_zeroMem(pData->bufEvents.out, sizeof(EngineEvent)*kEngineMaxInternalEventCount);

  1697. 

  1698.     bool processed = false;

  1699. 

  1700.     // process plugins

  1701.     for (unsigned int i=0; i < pData->curPluginCount; ++i)

  1702.     {

  1703.         CarlaPlugin* const plugin = pData->plugins[i].plugin;

  1704. 

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

  1706.             continue;

  1707. 

  1708.         if (processed)

  1709.         {

  1710.             // initialize inputs (from previous outputs)

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

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

  1713.             std::memcpy(pData->bufEvents.in, pData->bufEvents.out, sizeof(EngineEvent)*kEngineMaxInternalEventCount);

  1714. 

  1715.             // initialize outputs (zero)

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

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

  1718.             carla_zeroMem(pData->bufEvents.out, sizeof(EngineEvent)*kEngineMaxInternalEventCount);

  1719.         }

  1720. 

  1721.         // process

  1722.         plugin->initBuffers();

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

  1724.         plugin->unlock();

  1725. 

  1726. #if 0

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

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

  1729.         {

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

  1731.             {

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

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

  1734.             }

  1735.         }

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

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

  1738.         {

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

  1740.             {

  1741. 

  1742.             }

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

  1744.         }

  1745. #endif

  1746. 

  1747.         // set peaks

  1748.         {

  1749.             float inPeak1  = 0.0f;

  1750.             float inPeak2  = 0.0f;

  1751.             float outPeak1 = 0.0f;

  1752.             float outPeak2 = 0.0f;

  1753. 

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

  1755.             {

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

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

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

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

  1760.             }

  1761. 

  1762.             pData->plugins[i].insPeak[0]  = inPeak1;

  1763.             pData->plugins[i].insPeak[1]  = inPeak2;

  1764.             pData->plugins[i].outsPeak[0] = outPeak1;

  1765.             pData->plugins[i].outsPeak[1] = outPeak2;

  1766.         }

  1767. 

  1768.         processed = true;

  1769.     }

  1770. }

  1771. 

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

  1773. {

  1774.     // TODO

  1775.     return;

  1776. 

  1777.     // unused, for now

  1778.     (void)inBuf;

  1779.     (void)outBuf;

  1780.     (void)bufCount;

  1781.     (void)frames;

  1782. }

  1783. #endif

  1784. 

  1785. // -----------------------------------------------------------------------

  1786. // Carla Engine OSC stuff

  1787. 

  1788. #ifndef BUILD_BRIDGE

  1789. void CarlaEngine::oscSend_control_add_plugin_start(const int32_t pluginId, const char* const pluginName)

  1790. {

  1791.     CARLA_ASSERT(pData->oscData != nullptr);

  1792.     CARLA_ASSERT(pluginId >= 0 && pluginId < static_cast<int32_t>(pData->maxPluginNumber));

  1793.     CARLA_ASSERT(pluginName != nullptr);

  1794.     carla_debug("CarlaEngine::oscSend_control_add_plugin_start(%i, \"%s\")", pluginId, pluginName);

  1795. 

  1796.     if (pData->oscData != nullptr && pData->oscData->target != nullptr)

  1797.     {

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

  1799.         std::strcpy(targetPath, pData->oscData->path);

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

  1801.         lo_send(pData->oscData->target, targetPath, "is", pluginId, pluginName);

  1802.     }

  1803. }

  1804. 

  1805. void CarlaEngine::oscSend_control_add_plugin_end(const int32_t pluginId)

  1806. {

  1807.     CARLA_ASSERT(pData->oscData != nullptr);

  1808.     CARLA_ASSERT(pluginId >= 0 && pluginId < static_cast<int32_t>(pData->maxPluginNumber));

  1809.     carla_debug("CarlaEngine::oscSend_control_add_plugin_end(%i)", pluginId);

  1810. 

  1811.     if (pData->oscData != nullptr && pData->oscData->target != nullptr)

  1812.     {

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

  1814.         std::strcpy(targetPath, pData->oscData->path);

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

  1816.         lo_send(pData->oscData->target, targetPath, "i", pluginId);

  1817.     }

  1818. }

  1819. 

  1820. void CarlaEngine::oscSend_control_remove_plugin(const int32_t pluginId)

  1821. {

  1822.     CARLA_ASSERT(pData->oscData != nullptr);

  1823.     CARLA_ASSERT(pluginId >= 0 && pluginId < static_cast<int32_t>(pData->curPluginCount));

  1824.     carla_debug("CarlaEngine::oscSend_control_remove_plugin(%i)", pluginId);

  1825. 

  1826.     if (pData->oscData != nullptr && pData->oscData->target != nullptr)

  1827.     {

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

  1829.         std::strcpy(targetPath, pData->oscData->path);

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

  1831.         lo_send(pData->oscData->target, targetPath, "i", pluginId);

  1832.     }

  1833. }

  1834. 

  1835. void CarlaEngine::oscSend_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)

  1836. {

  1837.     CARLA_ASSERT(pData->oscData != nullptr);

  1838.     CARLA_ASSERT(pluginId >= 0 && pluginId < static_cast<int32_t>(pData->maxPluginNumber));

  1839.     CARLA_ASSERT(type != PLUGIN_NONE);

  1840.     CARLA_ASSERT(realName != nullptr);

  1841.     CARLA_ASSERT(label != nullptr);

  1842.     CARLA_ASSERT(maker != nullptr);

  1843.     CARLA_ASSERT(copyright != nullptr);

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

  1845. 

  1846.     if (pData->oscData != nullptr && pData->oscData->target != nullptr)

  1847.     {

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

  1849.         std::strcpy(targetPath, pData->oscData->path);

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

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

  1852.     }

  1853. }

  1854. 

  1855. void CarlaEngine::oscSend_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)

  1856. {

  1857.     CARLA_ASSERT(pData->oscData != nullptr);

  1858.     CARLA_ASSERT(pluginId >= 0 && pluginId < static_cast<int32_t>(pData->maxPluginNumber));

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

  1860. 

  1861.     if (pData->oscData != nullptr && pData->oscData->target != nullptr)

  1862.     {

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

  1864.         std::strcpy(targetPath, pData->oscData->path);

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

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

  1867.     }

  1868. }

  1869. 

  1870. void CarlaEngine::oscSend_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)

  1871. {

  1872.     CARLA_ASSERT(pData->oscData != nullptr);

  1873.     CARLA_ASSERT(pluginId >= 0 && pluginId < static_cast<int32_t>(pData->maxPluginNumber));

  1874.     CARLA_ASSERT(index >= 0);

  1875.     CARLA_ASSERT(type != PARAMETER_UNKNOWN);

  1876.     CARLA_ASSERT(name != nullptr);

  1877.     CARLA_ASSERT(label != nullptr);

  1878.     carla_debug("CarlaEngine::oscSend_control_set_parameter_data(%i, %i, %i, %i, \"%s\", \"%s\", %f)", pluginId, index, type, hints, name, label, current);

  1879. 

  1880.     if (pData->oscData != nullptr && pData->oscData->target != nullptr)

  1881.     {

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

  1883.         std::strcpy(targetPath, pData->oscData->path);

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

  1885.         lo_send(pData->oscData->target, targetPath, "iiiissf", pluginId, index, type, hints, name, label, current);

  1886.     }

  1887. }

  1888. 

  1889. void CarlaEngine::oscSend_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)

  1890. {

  1891.     CARLA_ASSERT(pData->oscData != nullptr);

  1892.     CARLA_ASSERT(pluginId >= 0 && pluginId < static_cast<int32_t>(pData->maxPluginNumber));

  1893.     CARLA_ASSERT(index >= 0);

  1894.     CARLA_ASSERT(min < max);

  1895.     carla_debug("CarlaEngine::oscSend_control_set_parameter_ranges(%i, %i, %f, %f, %f, %f, %f, %f)", pluginId, index, min, max, def, step, stepSmall, stepLarge);

  1896. 

  1897.     if (pData->oscData != nullptr && pData->oscData->target != nullptr)

  1898.     {

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

  1900.         std::strcpy(targetPath, pData->oscData->path);

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

  1902.         lo_send(pData->oscData->target, targetPath, "iiffffff", pluginId, index, min, max, def, step, stepSmall, stepLarge);

  1903.     }

  1904. }

  1905. 

  1906. void CarlaEngine::oscSend_control_set_parameter_midi_cc(const int32_t pluginId, const int32_t index, const int32_t cc)

  1907. {

  1908.     CARLA_ASSERT(pData->oscData != nullptr);

  1909.     CARLA_ASSERT(pluginId >= 0 && pluginId < static_cast<int32_t>(pData->maxPluginNumber));

  1910.     CARLA_ASSERT(index >= 0);

  1911.     carla_debug("CarlaEngine::oscSend_control_set_parameter_midi_cc(%i, %i, %i)", pluginId, index, cc);

  1912. 

  1913.     if (pData->oscData != nullptr && pData->oscData->target != nullptr)

  1914.     {

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

  1916.         std::strcpy(targetPath, pData->oscData->path);

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

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

  1919.     }

  1920. }

  1921. 

  1922. void CarlaEngine::oscSend_control_set_parameter_midi_channel(const int32_t pluginId, const int32_t index, const int32_t channel)

  1923. {

  1924.     CARLA_ASSERT(pData->oscData != nullptr);

  1925.     CARLA_ASSERT(pluginId >= 0 && pluginId < static_cast<int32_t>(pData->maxPluginNumber));

  1926.     CARLA_ASSERT(index >= 0);

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

  1928.     carla_debug("CarlaEngine::oscSend_control_set_parameter_midi_channel(%i, %i, %i)", pluginId, index, channel);

  1929. 

  1930.     if (pData->oscData != nullptr && pData->oscData->target != nullptr)

  1931.     {

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

  1933.         std::strcpy(targetPath, pData->oscData->path);

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

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

  1936.     }

  1937. }

  1938. 

  1939. void CarlaEngine::oscSend_control_set_parameter_value(const int32_t pluginId, const int32_t index, const float value)

  1940. {

  1941.     CARLA_ASSERT(pData->oscData != nullptr);

  1942.     CARLA_ASSERT(pluginId >= 0 && pluginId < static_cast<int32_t>(pData->maxPluginNumber));

  1943. #if DEBUG

  1944.     if (index < 0)

  1945.         carla_debug("CarlaEngine::oscSend_control_set_parameter_value(%i, %s, %f)", pluginId, InternalParametersIndex2Str((InternalParametersIndex)index), value);

  1946.     else

  1947.         carla_debug("CarlaEngine::oscSend_control_set_parameter_value(%i, %i, %f)", pluginId, index, value);

  1948. #endif

  1949. 

  1950.     if (pData->oscData != nullptr && pData->oscData->target != nullptr)

  1951.     {

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

  1953.         std::strcpy(targetPath, pData->oscData->path);

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

  1955.         lo_send(pData->oscData->target, targetPath, "iif", pluginId, index, value);

  1956.     }

  1957. }

  1958. 

  1959. void CarlaEngine::oscSend_control_set_default_value(const int32_t pluginId, const int32_t index, const float value)

  1960. {

  1961.     CARLA_ASSERT(pData->oscData != nullptr);

  1962.     CARLA_ASSERT(pluginId >= 0 && pluginId < static_cast<int32_t>(pData->maxPluginNumber));

  1963.     CARLA_ASSERT(index >= 0);

  1964.     carla_debug("CarlaEngine::oscSend_control_set_default_value(%i, %i, %f)", pluginId, index, value);

  1965. 

  1966.     if (pData->oscData != nullptr && pData->oscData->target != nullptr)

  1967.     {

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

  1969.         std::strcpy(targetPath, pData->oscData->path);

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

  1971.         lo_send(pData->oscData->target, targetPath, "iif", pluginId, index, value);

  1972.     }

  1973. }

  1974. 

  1975. void CarlaEngine::oscSend_control_set_program(const int32_t pluginId, const int32_t index)

  1976. {

  1977.     CARLA_ASSERT(pData->oscData != nullptr);

  1978.     CARLA_ASSERT(pluginId >= 0 && pluginId < static_cast<int32_t>(pData->maxPluginNumber));

  1979.     carla_debug("CarlaEngine::oscSend_control_set_program(%i, %i)", pluginId, index);

  1980. 

  1981.     if (pData->oscData != nullptr && pData->oscData->target != nullptr)

  1982.     {

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

  1984.         std::strcpy(targetPath, pData->oscData->path);

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

  1986.         lo_send(pData->oscData->target, targetPath, "ii", pluginId, index);

  1987.     }

  1988. }

  1989. 

  1990. void CarlaEngine::oscSend_control_set_program_count(const int32_t pluginId, const int32_t count)

  1991. {

  1992.     CARLA_ASSERT(pData->oscData != nullptr);

  1993.     CARLA_ASSERT(pluginId >= 0 && pluginId < static_cast<int32_t>(pData->maxPluginNumber));

  1994.     CARLA_ASSERT(count >= 0);

  1995.     carla_debug("CarlaEngine::oscSend_control_set_program_count(%i, %i)", pluginId, count);

  1996. 

  1997.     if (pData->oscData != nullptr && pData->oscData->target != nullptr)

  1998.     {

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

  2000.         std::strcpy(targetPath, pData->oscData->path);

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

  2002.         lo_send(pData->oscData->target, targetPath, "ii", pluginId, count);

  2003.     }

  2004. }

  2005. 

  2006. void CarlaEngine::oscSend_control_set_program_name(const int32_t pluginId, const int32_t index, const char* const name)

  2007. {

  2008.     CARLA_ASSERT(pData->oscData != nullptr);

  2009.     CARLA_ASSERT(pluginId >= 0 && pluginId < static_cast<int32_t>(pData->maxPluginNumber));

  2010.     CARLA_ASSERT(index >= 0);

  2011.     CARLA_ASSERT(name != nullptr);

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

  2013. 

  2014.     if (pData->oscData != nullptr && pData->oscData->target != nullptr)

  2015.     {

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

  2017.         std::strcpy(targetPath, pData->oscData->path);

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

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

  2020.     }

  2021. }

  2022. 

  2023. void CarlaEngine::oscSend_control_set_midi_program(const int32_t pluginId, const int32_t index)

  2024. {

  2025.     CARLA_ASSERT(pData->oscData != nullptr);

  2026.     CARLA_ASSERT(pluginId >= 0 && pluginId < static_cast<int32_t>(pData->maxPluginNumber));

  2027.     carla_debug("CarlaEngine::oscSend_control_set_midi_program(%i, %i)", pluginId, index);

  2028. 

  2029.     if (pData->oscData != nullptr && pData->oscData->target != nullptr)

  2030.     {

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

  2032.         std::strcpy(targetPath, pData->oscData->path);

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

  2034.         lo_send(pData->oscData->target, targetPath, "ii", pluginId, index);

  2035.     }

  2036. }

  2037. 

  2038. void CarlaEngine::oscSend_control_set_midi_program_count(const int32_t pluginId, const int32_t count)

  2039. {

  2040.     CARLA_ASSERT(pData->oscData != nullptr);

  2041.     CARLA_ASSERT(pluginId >= 0 && pluginId < static_cast<int32_t>(pData->maxPluginNumber));

  2042.     CARLA_ASSERT(count >= 0);

  2043.     carla_debug("CarlaEngine::oscSend_control_set_midi_program_count(%i, %i)", pluginId, count);

  2044. 

  2045.     if (pData->oscData != nullptr && pData->oscData->target != nullptr)

  2046.     {

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

  2048.         std::strcpy(targetPath, pData->oscData->path);

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

  2050.         lo_send(pData->oscData->target, targetPath, "ii", pluginId, count);

  2051.     }

  2052. }

  2053. 

  2054. void CarlaEngine::oscSend_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)

  2055. {

  2056.     CARLA_ASSERT(pData->oscData != nullptr);

  2057.     CARLA_ASSERT(pluginId >= 0 && pluginId < static_cast<int32_t>(pData->maxPluginNumber));

  2058.     CARLA_ASSERT(index >= 0);

  2059.     CARLA_ASSERT(bank >= 0);

  2060.     CARLA_ASSERT(program >= 0);

  2061.     CARLA_ASSERT(name != nullptr);

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

  2063. 

  2064.     if (pData->oscData != nullptr && pData->oscData->target != nullptr)

  2065.     {

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

  2067.         std::strcpy(targetPath, pData->oscData->path);

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

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

  2070.     }

  2071. }

  2072. 

  2073. void CarlaEngine::oscSend_control_note_on(const int32_t pluginId, const int32_t channel, const int32_t note, const int32_t velo)

  2074. {

  2075.     CARLA_ASSERT(pData->oscData != nullptr);

  2076.     CARLA_ASSERT(pluginId >= 0 && pluginId < static_cast<int32_t>(pData->curPluginCount));

  2077.     CARLA_ASSERT(channel >= 0 && channel < MAX_MIDI_CHANNELS);

  2078.     CARLA_ASSERT(note >= 0 && note < MAX_MIDI_NOTE);

  2079.     CARLA_ASSERT(velo > 0 && velo < MAX_MIDI_VALUE);

  2080.     carla_debug("CarlaEngine::oscSend_control_note_on(%i, %i, %i, %i)", pluginId, channel, note, velo);

  2081. 

  2082.     if (pData->oscData != nullptr && pData->oscData->target != nullptr)

  2083.     {

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

  2085.         std::strcpy(targetPath, pData->oscData->path);

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

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

  2088.     }

  2089. }

  2090. 

  2091. void CarlaEngine::oscSend_control_note_off(const int32_t pluginId, const int32_t channel, const int32_t note)

  2092. {

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

  2094.     CARLA_ASSERT(pluginId >= 0 && pluginId < static_cast<int32_t>(pData->curPluginCount));

  2095.     CARLA_ASSERT(channel >= 0 && channel < MAX_MIDI_CHANNELS);

  2096.     CARLA_ASSERT(note >= 0 && note < MAX_MIDI_NOTE);

  2097.     carla_debug("CarlaEngine::oscSend_control_note_off(%i, %i, %i)", pluginId, channel, note);

  2098. 

  2099.     if (pData->oscData != nullptr && pData->oscData->target != nullptr)

  2100.     {

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

  2102.         std::strcpy(targetPath, pData->oscData->path);

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

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

  2105.     }

  2106. }

  2107. 

  2108. void CarlaEngine::oscSend_control_set_peaks(const int32_t pluginId)

  2109. {

  2110.     CARLA_ASSERT(pData->oscData != nullptr);

  2111.     CARLA_ASSERT(pluginId >= 0 && pluginId < static_cast<int32_t>(pData->curPluginCount));

  2112. 

  2113.     const EnginePluginData& epData(pData->plugins[pluginId]);

  2114. 

  2115.     if (pData->oscData != nullptr && pData->oscData->target != nullptr)

  2116.     {

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

  2118.         std::strcpy(targetPath, pData->oscData->path);

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

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

  2121.     }

  2122. }

  2123. 

  2124. void CarlaEngine::oscSend_control_exit()

  2125. {

  2126.     CARLA_ASSERT(pData->oscData != nullptr);

  2127.     carla_debug("CarlaEngine::oscSend_control_exit()");

  2128. 

  2129.     if (pData->oscData != nullptr && pData->oscData->target != nullptr)

  2130.     {

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

  2132.         std::strcpy(targetPath, pData->oscData->path);

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

  2134.         lo_send(pData->oscData->target, targetPath, "");

  2135.     }

  2136. }

  2137. #else

  2138. void CarlaEngine::oscSend_bridge_audio_count(const int32_t ins, const int32_t outs, const int32_t total)

  2139. {

  2140.     CARLA_ASSERT(pData->oscData != nullptr);

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

  2142.     carla_debug("CarlaEngine::oscSend_bridge_audio_count(%i, %i, %i)", ins, outs, total);

  2143. 

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

  2145.     {

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

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

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

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

  2150.     }

  2151. }

  2152. 

  2153. void CarlaEngine::oscSend_bridge_midi_count(const int32_t ins, const int32_t outs, const int32_t total)

  2154. {

  2155.     CARLA_ASSERT(pData->oscData != nullptr);

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

  2157.     carla_debug("CarlaEngine::oscSend_bridge_midi_count(%i, %i, %i)", ins, outs, total);

  2158. 

  2159.     if (pData->oscData != nullptr && pData->oscData->target != nullptr)

  2160.     {

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

  2162.         std::strcpy(targetPath, pData->oscData->path);

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

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

  2165.     }

  2166. }

  2167. 

  2168. void CarlaEngine::oscSend_bridge_parameter_count(const int32_t ins, const int32_t outs, const int32_t total)

  2169. {

  2170.     CARLA_ASSERT(pData->oscData != nullptr);

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

  2172.     carla_debug("CarlaEngine::oscSend_bridge_parameter_count(%i, %i, %i)", ins, outs, total);

  2173. 

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

  2175.     {

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

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

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

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

  2180.     }

  2181. }

  2182. 

  2183. void CarlaEngine::oscSend_bridge_program_count(const int32_t count)

  2184. {

  2185.     CARLA_ASSERT(pData->oscData != nullptr);

  2186.     CARLA_ASSERT(count >= 0);

  2187.     carla_debug("CarlaEngine::oscSend_bridge_program_count(%i)", count);

  2188. 

  2189.     if (pData->oscData != nullptr && pData->oscData->target != nullptr)

  2190.     {

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

  2192.         std::strcpy(targetPath, pData->oscData->path);

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

  2194.         lo_send(pData->oscData->target, targetPath, "i", count);

  2195.     }

  2196. }

  2197. 

  2198. void CarlaEngine::oscSend_bridge_midi_program_count(const int32_t count)

  2199. {

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

  2201.     CARLA_ASSERT(count >= 0);

  2202.     carla_debug("CarlaEngine::oscSend_bridge_midi_program_count(%i)", count);

  2203. 

  2204.     if (pData->oscData != nullptr && pData->oscData->target != nullptr)

  2205.     {

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

  2207.         std::strcpy(targetPath, pData->oscData->path);

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

  2209.         lo_send(pData->oscData->target, targetPath, "i", count);

  2210.     }

  2211. }

  2212. 

  2213. void CarlaEngine::oscSend_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)

  2214. {

  2215.     CARLA_ASSERT(pData->oscData != nullptr);

  2216.     CARLA_ASSERT(name != nullptr);

  2217.     CARLA_ASSERT(label != nullptr);

  2218.     CARLA_ASSERT(maker != nullptr);

  2219.     CARLA_ASSERT(copyright != nullptr);

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

  2221. 

  2222.     if (pData->oscData != nullptr && pData->oscData->target != nullptr)

  2223.     {

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

  2225.         std::strcpy(targetPath, pData->oscData->path);

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

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

  2228.     }

  2229. }

  2230. 

  2231. void CarlaEngine::oscSend_bridge_parameter_info(const int32_t index, const char* const name, const char* const unit)

  2232. {

  2233.     CARLA_ASSERT(pData->oscData != nullptr);

  2234.     CARLA_ASSERT(name != nullptr);

  2235.     CARLA_ASSERT(unit != nullptr);

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

  2237. 

  2238.     if (pData->oscData != nullptr && pData->oscData->target != nullptr)

  2239.     {

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

  2241.         std::strcpy(targetPath, pData->oscData->path);

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

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

  2244.     }

  2245. }

  2246. 

  2247. void CarlaEngine::oscSend_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)

  2248. {

  2249.     CARLA_ASSERT(pData->oscData != nullptr);

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

  2251. 

  2252.     if (pData->oscData != nullptr && pData->oscData->target != nullptr)

  2253.     {

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

  2255.         std::strcpy(targetPath, pData->oscData->path);

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

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

  2258.     }

  2259. }

  2260. 

  2261. void CarlaEngine::oscSend_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)

  2262. {

  2263.     CARLA_ASSERT(pData->oscData != nullptr);

  2264.     carla_debug("CarlaEngine::oscSend_bridge_parameter_ranges(%i, %f, %f, %f, %f, %f, %f)", index, def, min, max, step, stepSmall, stepLarge);

  2265. 

  2266.     if (pData->oscData != nullptr && pData->oscData->target != nullptr)

  2267.     {

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

  2269.         std::strcpy(targetPath, pData->oscData->path);

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

  2271.         lo_send(pData->oscData->target, targetPath, "iffffff", index, def, min, max, step, stepSmall, stepLarge);

  2272.     }

  2273. }

  2274. 

  2275. void CarlaEngine::oscSend_bridge_program_info(const int32_t index, const char* const name)

  2276. {

  2277.     CARLA_ASSERT(pData->oscData != nullptr);

  2278.     carla_debug("CarlaEngine::oscSend_bridge_program_info(%i, \"%s\")", index, name);

  2279. 

  2280.     if (pData->oscData != nullptr && pData->oscData->target != nullptr)

  2281.     {

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

  2283.         std::strcpy(targetPath, pData->oscData->path);

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

  2285.         lo_send(pData->oscData->target, targetPath, "is", index, name);

  2286.     }

  2287. }

  2288. 

  2289. void CarlaEngine::oscSend_bridge_midi_program_info(const int32_t index, const int32_t bank, const int32_t program, const char* const label)

  2290. {

  2291.     CARLA_ASSERT(pData->oscData != nullptr);

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

  2293. 

  2294.     if (pData->oscData != nullptr && pData->oscData->target != nullptr)

  2295.     {

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

  2297.         std::strcpy(targetPath, pData->oscData->path);

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

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

  2300.     }

  2301. }

  2302. 

  2303. void CarlaEngine::oscSend_bridge_configure(const char* const key, const char* const value)

  2304. {

  2305.     CARLA_ASSERT(pData->oscData != nullptr);

  2306.     CARLA_ASSERT(key != nullptr);

  2307.     CARLA_ASSERT(value != nullptr);

  2308.     carla_debug("CarlaEngine::oscSend_bridge_configure(\"%s\", \"%s\")", key, value);

  2309. 

  2310.     if (pData->oscData != nullptr && pData->oscData->target != nullptr)

  2311.     {

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

  2313.         std::strcpy(targetPath, pData->oscData->path);

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

  2315.         lo_send(pData->oscData->target, targetPath, "ss", key, value);

  2316.     }

  2317. }

  2318. 

  2319. void CarlaEngine::oscSend_bridge_set_parameter_value(const int32_t index, const float value)

  2320. {

  2321.     CARLA_ASSERT(pData->oscData != nullptr);

  2322.     carla_debug("CarlaEngine::oscSend_bridge_set_parameter_value(%i, %f)", index, value);

  2323. 

  2324.     if (pData->oscData != nullptr && pData->oscData->target != nullptr)

  2325.     {

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

  2327.         std::strcpy(targetPath, pData->oscData->path);

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

  2329.         lo_send(pData->oscData->target, targetPath, "if", index, value);

  2330.     }

  2331. }

  2332. 

  2333. void CarlaEngine::oscSend_bridge_set_default_value(const int32_t index, const float value)

  2334. {

  2335.     CARLA_ASSERT(pData->oscData != nullptr);

  2336.     carla_debug("CarlaEngine::oscSend_bridge_set_default_value(%i, %f)", index, value);

  2337. 

  2338.     if (pData->oscData != nullptr && pData->oscData->target != nullptr)

  2339.     {

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

  2341.         std::strcpy(targetPath, pData->oscData->path);

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

  2343.         lo_send(pData->oscData->target, targetPath, "if", index, value);

  2344.     }

  2345. }

  2346. 

  2347. void CarlaEngine::oscSend_bridge_set_program(const int32_t index)

  2348. {

  2349.     CARLA_ASSERT(pData->oscData != nullptr);

  2350.     carla_debug("CarlaEngine::oscSend_bridge_set_program(%i)", index);

  2351. 

  2352.     if (pData->oscData != nullptr && pData->oscData->target != nullptr)

  2353.     {

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

  2355.         std::strcpy(targetPath, pData->oscData->path);

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

  2357.         lo_send(pData->oscData->target, targetPath, "i", index);

  2358.     }

  2359. }

  2360. 

  2361. void CarlaEngine::oscSend_bridge_set_midi_program(const int32_t index)

  2362. {

  2363.     CARLA_ASSERT(pData->oscData != nullptr);

  2364.     carla_debug("CarlaEngine::oscSend_bridge_set_midi_program(%i)", index);

  2365. 

  2366.     if (pData->oscData != nullptr && pData->oscData->target != nullptr)

  2367.     {

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

  2369.         std::strcpy(targetPath, pData->oscData->path);

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

  2371.         lo_send(pData->oscData->target, targetPath, "i", index);

  2372.     }

  2373. }

  2374. 

  2375. void CarlaEngine::oscSend_bridge_set_custom_data(const char* const type, const char* const key, const char* const value)

  2376. {

  2377.     CARLA_ASSERT(pData->oscData != nullptr);

  2378.     carla_debug("CarlaEngine::oscSend_bridge_set_custom_data(\"%s\", \"%s\", \"%s\")", type, key, value);

  2379. 

  2380.     if (pData->oscData != nullptr && pData->oscData->target != nullptr)

  2381.     {

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

  2383.         std::strcpy(targetPath, pData->oscData->path);

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

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

  2386.     }

  2387. }

  2388. 

  2389. void CarlaEngine::oscSend_bridge_set_chunk_data(const char* const chunkFile)

  2390. {

  2391.     CARLA_ASSERT(pData->oscData != nullptr);

  2392.     carla_debug("CarlaEngine::oscSend_bridge_set_chunk_data(\"%s\")", chunkFile);

  2393. 

  2394.     if (pData->oscData != nullptr && pData->oscData->target != nullptr)

  2395.     {

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

  2397.         std::strcpy(targetPath, pData->oscData->path);

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

  2399.         lo_send(pData->oscData->target, targetPath, "s", chunkFile);

  2400.     }

  2401. }

  2402. #endif

  2403. 

  2404. CARLA_BACKEND_END_NAMESPACE