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

2404 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. #ifdef WANT_RTAUDIO

  344.     count += getRtAudioApiCount();

  345. #endif

  346. 

  347.     return count;

  348. }

  349. 

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

  351. {

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

  353. 

  354.     if (index == 0)

  355.         return "JACK";

  356. 

  357. #ifdef WANT_RTAUDIO

  358.     const unsigned int rtIndex(index-1);

  359. 

  360.     if (rtIndex < getRtAudioApiCount())

  361.         return getRtAudioApiName(rtIndex);

  362. #endif

  363. 

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

  365.     return nullptr;

  366. }

  367. 

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

  369. {

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

  371. 

  372.     if (index == 0)

  373.         return nullptr;

  374. 

  375. #ifdef WANT_RTAUDIO

  376.     const unsigned int rtIndex(index-1);

  377. 

  378.     if (rtIndex < getRtAudioApiCount())

  379.         return getRtAudioApiDeviceNames(rtIndex);

  380. #endif

  381. 

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

  383.     return nullptr;

  384. }

  385. 

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

  387. {

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

  389. 

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

  391.         return newJack();

  392. 

  393. #ifdef WANT_RTAUDIO

  394. # ifdef __LINUX_ALSA__

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

  396.         return newRtAudio(RTAUDIO_LINUX_ALSA);

  397. # endif

  398. # ifdef __LINUX_PULSE__

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

  400.         return newRtAudio(RTAUDIO_LINUX_PULSE);

  401. # endif

  402. # ifdef __LINUX_OSS__

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

  404.         return newRtAudio(RTAUDIO_LINUX_OSS);

  405. # endif

  406. # ifdef __UNIX_JACK__

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

  408.         return newRtAudio(RTAUDIO_UNIX_JACK);

  409. # endif

  410. # ifdef __MACOSX_CORE__

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

  412.         return newRtAudio(RTAUDIO_MACOSX_CORE);

  413. # endif

  414. # ifdef __WINDOWS_ASIO__

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

  416.         return newRtAudio(RTAUDIO_WINDOWS_ASIO);

  417. # endif

  418. # ifdef __WINDOWS_DS__

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

  420.         return newRtAudio(RTAUDIO_WINDOWS_DS);

  421. # endif

  422. #endif

  423. 

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

  425.     return nullptr;

  426. }

  427. 

  428. // -----------------------------------------------------------------------

  429. // Maximum values

  430. 

  431. unsigned int CarlaEngine::getMaxClientNameSize() const

  432. {

  433.     return STR_MAX/2;

  434. }

  435. 

  436. unsigned int CarlaEngine::getMaxPortNameSize() const

  437. {

  438.     return STR_MAX;

  439. }

  440. 

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

  442. {

  443.     return pData->curPluginCount;

  444. }

  445. 

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

  447. {

  448.     return pData->maxPluginNumber;

  449. }

  450. 

  451. // -----------------------------------------------------------------------

  452. // Virtual, per-engine type calls

  453. 

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

  455. {

  456.     CARLA_ASSERT(fName.isEmpty());

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

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

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

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

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

  462. 

  463.     pData->aboutToClose = false;

  464.     pData->curPluginCount = 0;

  465.     pData->maxPluginNumber = 0;

  466.     pData->nextPluginId = 0;

  467. 

  468.     switch (fOptions.processMode)

  469.     {

  470.     case PROCESS_MODE_SINGLE_CLIENT:

  471.     case PROCESS_MODE_MULTIPLE_CLIENTS:

  472.         pData->maxPluginNumber = MAX_DEFAULT_PLUGINS;

  473.         break;

  474. 

  475.     case PROCESS_MODE_CONTINUOUS_RACK:

  476.         pData->maxPluginNumber = MAX_RACK_PLUGINS;

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

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

  479.         break;

  480. 

  481.     case PROCESS_MODE_PATCHBAY:

  482.         pData->maxPluginNumber = MAX_PATCHBAY_PLUGINS;

  483.         break;

  484. 

  485.     case PROCESS_MODE_BRIDGE:

  486.         pData->maxPluginNumber = 1;

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

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

  489.         break;

  490.     }

  491. 

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

  493.         return false;

  494. 

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

  496. 

  497.     fName = clientName;

  498.     fName.toBasic();

  499. 

  500.     fTimeInfo.clear();

  501. 

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

  503. 

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

  505. #ifndef BUILD_BRIDGE

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

  507. #endif

  508. 

  509.     pData->nextAction.ready();

  510.     pData->thread.startThread();

  511. 

  512.     return true;

  513. }

  514. 

  515. bool CarlaEngine::close()

  516. {

  517.     CARLA_ASSERT(fName.isNotEmpty());

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

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

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

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

  522. 

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

  524.     pData->nextAction.ready();

  525. 

  526. #ifndef BUILD_BRIDGE

  527.     oscSend_control_exit();

  528. #endif

  529.     pData->osc.close();

  530.     pData->oscData = nullptr;

  531. 

  532.     pData->aboutToClose = true;

  533.     pData->curPluginCount = 0;

  534.     pData->maxPluginNumber = 0;

  535.     pData->nextPluginId = 0;

  536. 

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

  538.     {

  539.         delete[] pData->plugins;

  540.         pData->plugins = nullptr;

  541.     }

  542. 

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

  544.     {

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

  546.         pData->bufEvents.in = nullptr;

  547.     }

  548. 

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

  550.     {

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

  552.         pData->bufEvents.out = nullptr;

  553.     }

  554. 

  555.     fName.clear();

  556. 

  557.     return true;

  558. }

  559. 

  560. void CarlaEngine::idle()

  561. {

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

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

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

  565. 

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

  567.     {

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

  569. 

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

  571.             plugin->idleGui();

  572.     }

  573. }

  574. 

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

  576. {

  577.     return new CarlaEngineClient(*this);

  578. }

  579. 

  580. // -----------------------------------------------------------------------

  581. // Plugin management

  582. 

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

  584. {

  585.     CARLA_ASSERT(btype != BINARY_NONE);

  586.     CARLA_ASSERT(ptype != PLUGIN_NONE);

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

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

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

  590. 

  591.     unsigned int id;

  592. 

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

  594.     {

  595.         id = pData->nextPluginId;

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

  597. 

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

  599.     }

  600.     else

  601.     {

  602.         id = pData->curPluginCount;

  603. 

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

  605.         {

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

  607.             return false;

  608.         }

  609. 

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

  611.     }

  612. 

  613.     CarlaPlugin::Initializer init = {

  614.         this,

  615.         id,

  616.         filename,

  617.         name,

  618.         label

  619.     };

  620. 

  621.     CarlaPlugin* plugin = nullptr;

  622. 

  623. #ifndef BUILD_BRIDGE

  624.     const char* bridgeBinary;

  625. 

  626.     switch (btype)

  627.     {

  628.     case BINARY_POSIX32:

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

  630.         break;

  631.     case BINARY_POSIX64:

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

  633.         break;

  634.     case BINARY_WIN32:

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

  636.         break;

  637.     case BINARY_WIN64:

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

  639.         break;

  640.     default:

  641.         bridgeBinary = nullptr;

  642.         break;

  643.     }

  644. 

  645. # ifndef Q_OS_WIN

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

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

  648. # endif

  649. 

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

  651.     {

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

  653.     }

  654.     else

  655. #endif // BUILD_BRIDGE

  656.     {

  657.         switch (ptype)

  658.         {

  659.         case PLUGIN_NONE:

  660.             break;

  661. 

  662.         case PLUGIN_INTERNAL:

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

  664.             break;

  665. 

  666.         case PLUGIN_LADSPA:

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

  668.             break;

  669. 

  670.         case PLUGIN_DSSI:

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

  672.             break;

  673. 

  674.         case PLUGIN_LV2:

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

  676.             break;

  677. 

  678.         case PLUGIN_VST:

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

  680.             break;

  681. 

  682.         case PLUGIN_AU:

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

  684.             break;

  685. 

  686.         case PLUGIN_CSOUND:

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

  688.             break;

  689. 

  690.         case PLUGIN_GIG:

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

  692.             break;

  693. 

  694.         case PLUGIN_SF2:

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

  696.             break;

  697. 

  698.         case PLUGIN_SFZ:

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

  700.             break;

  701.         }

  702.     }

  703. 

  704.     if (plugin == nullptr)

  705.         return false;

  706. 

  707.     plugin->registerToOscClient();

  708. 

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

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

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

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

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

  714. 

  715.     ++pData->curPluginCount;

  716. 

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

  718.     return true;

  719. }

  720. 

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

  722. {

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

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

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

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

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

  728. 

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

  730.     {

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

  732.         return false;

  733.     }

  734. 

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

  736. 

  737.     if (plugin == nullptr)

  738.     {

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

  740.         return false;

  741.     }

  742. 

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

  744. 

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

  746. 

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

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

  749. 

  750. #ifndef BUILD_BRIDGE

  751.     if (isOscControlRegistered())

  752.         oscSend_control_remove_plugin(id);

  753. #endif

  754. 

  755.     delete plugin;

  756. 

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

  758.         pData->thread.startThread();

  759. 

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

  761.     return true;

  762. }

  763. 

  764. void CarlaEngine::removeAllPlugins()

  765. {

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

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

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

  769. 

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

  771.         return;

  772. 

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

  774. 

  775.     const bool lockWait(isRunning());

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

  777. 

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

  779.     {

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

  781. 

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

  783. 

  784.         if (plugin != nullptr)

  785.             delete plugin;

  786. 

  787.         // clear this plugin

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

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

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

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

  792.     }

  793. 

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

  795.         pData->thread.startThread();

  796. 

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

  798. }

  799. 

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

  801. {

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

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

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

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

  806.     CARLA_ASSERT(newName != nullptr);

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

  808. 

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

  810.     {

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

  812.         return nullptr;

  813.     }

  814. 

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

  816. 

  817.     if (plugin == nullptr)

  818.     {

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

  820.         return nullptr;

  821.     }

  822. 

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

  824. 

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

  826.     {

  827.         plugin->setName(name);

  828.         return name;

  829.     }

  830. 

  831.     return nullptr;

  832. }

  833. 

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

  835. {

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

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

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

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

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

  841. 

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

  843.     {

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

  845.         return false;

  846.     }

  847. 

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

  849. 

  850.     if (plugin == nullptr)

  851.     {

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

  853.         return false;

  854.     }

  855. 

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

  857. 

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

  859.     plugin->getLabel(label);

  860. 

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

  862. 

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

  864.         return false;

  865. 

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

  867. 

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

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

  870. 

  871.     return true;

  872. }

  873. 

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

  875. {

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

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

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

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

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

  881. 

  882.     if (id < pData->curPluginCount)

  883.         pData->nextPluginId = id;

  884. 

  885.     return false;

  886. }

  887. 

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

  889. {

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

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

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

  893.     CARLA_ASSERT(idA != idB);

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

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

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

  897. 

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

  899.     {

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

  901.         return false;

  902.     }

  903. 

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

  905. 

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

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

  908. 

  909. #ifndef BUILD_BRIDGE // TODO

  910.     //if (isOscControlRegistered())

  911.     //    oscSend_control_switch_plugins(idA, idB);

  912. #endif

  913. 

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

  915.         pData->thread.startThread();

  916. 

  917.     return true;

  918. }

  919. 

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

  921. {

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

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

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

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

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

  927. 

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

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

  930. 

  931.     return nullptr;

  932. }

  933. 

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

  935. {

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

  937. }

  938. 

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

  940. {

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

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

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

  944.     CARLA_ASSERT(name != nullptr);

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

  946. 

  947.     static CarlaString sname;

  948.     sname = name;

  949. 

  950.     if (sname.isEmpty())

  951.     {

  952.         sname = "(No name)";

  953.         return (const char*)sname;

  954.     }

  955. 

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

  957.         return (const char*)sname;

  958. 

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

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

  961. 

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

  963.     {

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

  965. 

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

  967.             break;

  968. 

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

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

  971.         {

  972.             if (sname != pluginName)

  973.                 continue;

  974.         }

  975. 

  976.         // Check if string has already been modified

  977.         {

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

  979. 

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

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

  982.             {

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

  984. 

  985.                 if (number == 9)

  986.                 {

  987.                     // next number is 10, 2 digits

  988.                     sname.truncate(len-4);

  989.                     sname += " (10)";

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

  991.                 }

  992.                 else

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

  994. 

  995.                 continue;

  996.             }

  997. 

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

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

  1000.             {

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

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

  1003. 

  1004.                 if (n2 == '9')

  1005.                 {

  1006.                     n2  = '0';

  1007.                     n3 += 1;

  1008.                 }

  1009.                 else

  1010.                     n2 += 1;

  1011. 

  1012.                 sname[len-2] = n2;

  1013.                 sname[len-3] = n3;

  1014. 

  1015.                 continue;

  1016.             }

  1017.         }

  1018. 

  1019.         // Modify string if not

  1020.         sname += " (2)";

  1021.     }

  1022. 

  1023.     return (const char*)sname;

  1024. }

  1025. 

  1026. // -----------------------------------------------------------------------

  1027. // Project management

  1028. 

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

  1030. {

  1031.     CARLA_ASSERT(filename != nullptr);

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

  1033. 

  1034. #if 0

  1035.     QFileInfo fileInfo(filename);

  1036. 

  1037.     if (! fileInfo.exists())

  1038.     {

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

  1040.         return false;

  1041.     }

  1042. 

  1043.     if (! fileInfo.isFile())

  1044.     {

  1045.         setLastError("Not a file");

  1046.         return false;

  1047.     }

  1048. 

  1049.     if (! fileInfo.isReadable())

  1050.     {

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

  1052.         return false;

  1053.     }

  1054. 

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

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

  1057. 

  1058.     // -------------------------------------------------------------------

  1059. 

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

  1061.         return loadProject(filename);

  1062. 

  1063.     // -------------------------------------------------------------------

  1064. 

  1065.     if (extension == "gig")

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

  1067. 

  1068.     if (extension == "sf2")

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

  1070. 

  1071.     if (extension == "sfz")

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

  1073. 

  1074.     // -------------------------------------------------------------------

  1075. 

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

  1077.     {

  1078. #ifdef WANT_AUDIOFILE

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

  1080.         {

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

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

  1083.             return true;

  1084.         }

  1085.         return false;

  1086. #else

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

  1088.         return false;

  1089. #endif

  1090.     }

  1091. 

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

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

  1094.     {

  1095. #ifdef WANT_AUDIOFILE

  1096. # ifdef HAVE_FFMPEG

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

  1098.         {

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

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

  1101.             return true;

  1102.         }

  1103.         return false;

  1104. # else

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

  1106.         return false;

  1107. # endif

  1108. #else

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

  1110.         return false;

  1111. #endif

  1112.     }

  1113. 

  1114.     // -------------------------------------------------------------------

  1115. 

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

  1117.     {

  1118. #ifdef WANT_MIDIFILE

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

  1120.         {

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

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

  1123.             return true;

  1124.         }

  1125.         return false;

  1126. #else

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

  1128.         return false;

  1129. #endif

  1130.     }

  1131. 

  1132.     // -------------------------------------------------------------------

  1133.     // ZynAddSubFX

  1134. 

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

  1136.     {

  1137. #ifdef WANT_ZYNADDSUBFX

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

  1139.         {

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

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

  1142.             return true;

  1143.         }

  1144.         return false;

  1145. #else

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

  1147.         return false;

  1148. #endif

  1149.     }

  1150. 

  1151.     // -------------------------------------------------------------------

  1152. #endif

  1153. 

  1154.     setLastError("Unknown file extension");

  1155.     return false;

  1156. }

  1157. 

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

  1159. {

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

  1161.         return false;

  1162. 

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

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

  1165. 

  1166.     if (strLen < suffixLen)

  1167.         return false;

  1168. 

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

  1170. }

  1171. 

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

  1173. {

  1174.     CARLA_ASSERT(filename != nullptr);

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

  1176. 

  1177. #if 0

  1178.     QFile file(filename);

  1179. 

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

  1181.         return false;

  1182. 

  1183.     QDomDocument xml;

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

  1185.     file.close();

  1186. 

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

  1188. 

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

  1190.     {

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

  1192.         return false;

  1193.     }

  1194. 

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

  1196. 

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

  1198. 

  1199.     while (! node.isNull())

  1200.     {

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

  1202.         {

  1203.             SaveState saveState;

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

  1205. 

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

  1207. 

  1208.             if (saveState.type == nullptr)

  1209.                 continue;

  1210. 

  1211.             const void* extraStuff = nullptr;

  1212. 

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

  1214.             {

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

  1216.             }

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

  1218.             {

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

  1220. 

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

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

  1223.             }

  1224. 

  1225.             // TODO - proper find&load plugins

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

  1227.             {

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

  1229.                     plugin->loadSaveState(saveState);

  1230.             }

  1231.         }

  1232. 

  1233.         if (isPreset)

  1234.             break;

  1235. 

  1236.         node = node.nextSibling();

  1237.     }

  1238. 

  1239.     return true;

  1240. #endif

  1241.     setLastError("Not implemented yet");

  1242.     return false;

  1243. }

  1244. 

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

  1246. {

  1247.     CARLA_ASSERT(filename != nullptr);

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

  1249. 

  1250. #if 0

  1251.     QFile file(filename);

  1252. 

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

  1254.         return false;

  1255. 

  1256.     QTextStream out(&file);

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

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

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

  1260. 

  1261.     bool firstPlugin = true;

  1262.     char strBuf[STR_MAX+1];

  1263. 

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

  1265.     {

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

  1267. 

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

  1269.         {

  1270.             if (! firstPlugin)

  1271.                 out << "\n";

  1272. 

  1273.             plugin->getRealName(strBuf);

  1274. 

  1275.             if (*strBuf != 0)

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

  1277. 

  1278.             QString content;

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

  1280. 

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

  1282.             out << content;

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

  1284. 

  1285.             firstPlugin = false;

  1286.         }

  1287.     }

  1288. 

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

  1290. 

  1291.     file.close();

  1292.     return true;

  1293. #endif

  1294.     setLastError("Not implemented yet");

  1295.     return false;

  1296. }

  1297. 

  1298. // -----------------------------------------------------------------------

  1299. // Information (peaks)

  1300. 

  1301. // FIXME

  1302. 

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

  1304. {

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

  1306.     CARLA_ASSERT(id-1 < 2);

  1307. 

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

  1309.         return 0.0f;

  1310. 

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

  1312. }

  1313. 

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

  1315. {

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

  1317.     CARLA_ASSERT(id-1 < 2);

  1318. 

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

  1320.         return 0.0f;

  1321. 

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

  1323. }

  1324. 

  1325. // -----------------------------------------------------------------------

  1326. // Callback

  1327. 

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

  1329. {

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

  1331. 

  1332.     if (pData->callback)

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

  1334. }

  1335. 

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

  1337. {

  1338.     CARLA_ASSERT(func != nullptr);

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

  1340. 

  1341.     pData->callback    = func;

  1342.     pData->callbackPtr = ptr;

  1343. }

  1344. 

  1345. // -----------------------------------------------------------------------

  1346. // Patchbay

  1347. 

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

  1349. {

  1350.     setLastError("Unsupported operation");

  1351.     return false;

  1352. }

  1353. 

  1354. bool CarlaEngine::patchbayDisconnect(int)

  1355. {

  1356.     setLastError("Unsupported operation");

  1357.     return false;

  1358. }

  1359. 

  1360. void CarlaEngine::patchbayRefresh()

  1361. {

  1362.     // nothing

  1363. }

  1364. 

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

  1366. // Transport

  1367. 

  1368. void CarlaEngine::transportPlay()

  1369. {

  1370.     pData->time.playing = true;

  1371. }

  1372. 

  1373. void CarlaEngine::transportPause()

  1374. {

  1375.     pData->time.playing = false;

  1376. }

  1377. 

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

  1379. {

  1380.     pData->time.frame = frame;

  1381. }

  1382. 

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

  1384. // Error handling

  1385. 

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

  1387. {

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

  1389. }

  1390. 

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

  1392. {

  1393.     pData->lastError = error;

  1394. }

  1395. 

  1396. void CarlaEngine::setAboutToClose()

  1397. {

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

  1399.     pData->aboutToClose = true;

  1400. }

  1401. 

  1402. // -----------------------------------------------------------------------

  1403. // Global options

  1404. 

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

  1406. {

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

  1408. 

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

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

  1411. 

  1412.     switch (option)

  1413.     {

  1414.     case OPTION_PROCESS_NAME:

  1415.         break;

  1416. 

  1417.     case OPTION_PROCESS_MODE:

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

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

  1420. 

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

  1422.         break;

  1423. 

  1424.     case OPTION_TRANSPORT_MODE:

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

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

  1427. 

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

  1429.         break;

  1430. 

  1431.     case OPTION_FORCE_STEREO:

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

  1433.         break;

  1434. 

  1435.     case OPTION_PREFER_PLUGIN_BRIDGES:

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

  1437.         break;

  1438. 

  1439.     case OPTION_PREFER_UI_BRIDGES:

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

  1441.         break;

  1442. 

  1443.     case OPTION_UIS_ALWAYS_ON_TOP:

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

  1445.         break;

  1446. 

  1447. #ifdef WANT_DSSI

  1448.     case OPTION_USE_DSSI_VST_CHUNKS:

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

  1450.         break;

  1451. #endif

  1452. 

  1453.     case OPTION_MAX_PARAMETERS:

  1454.         if (value < 1)

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

  1456. 

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

  1458.         break;

  1459. 

  1460.     case OPTION_UI_BRIDGES_TIMEOUT:

  1461.         if (value < 1)

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

  1463. 

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

  1465.         break;

  1466. 

  1467. #ifdef WANT_RTAUDIO

  1468.     case OPTION_RTAUDIO_NUMBER_PERIODS:

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

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

  1471. 

  1472.         fOptions.rtaudioNumPeriods = static_cast<uint>(value);

  1473.         break;

  1474. 

  1475.     case OPTION_RTAUDIO_BUFFER_SIZE:

  1476.         if (value < 8)

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

  1478. 

  1479.         fOptions.rtaudioBufferSize = static_cast<uint>(value);

  1480.         break;

  1481. 

  1482.     case OPTION_RTAUDIO_SAMPLE_RATE:

  1483.         if (value < 22050)

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

  1485. 

  1486.         fOptions.rtaudioSampleRate = static_cast<uint>(value);

  1487.         break;

  1488. 

  1489.     case OPTION_RTAUDIO_DEVICE:

  1490.         fOptions.rtaudioDevice = valueStr;

  1491.         break;

  1492. #endif

  1493. 

  1494.     case OPTION_PATH_RESOURCES:

  1495.         fOptions.resourceDir = valueStr;

  1496.         break;

  1497. 

  1498. #ifndef BUILD_BRIDGE

  1499.     case OPTION_PATH_BRIDGE_NATIVE:

  1500.         fOptions.bridge_native = valueStr;

  1501.         break;

  1502.     case OPTION_PATH_BRIDGE_POSIX32:

  1503.         fOptions.bridge_posix32 = valueStr;

  1504.         break;

  1505.     case OPTION_PATH_BRIDGE_POSIX64:

  1506.         fOptions.bridge_posix64 = valueStr;

  1507.         break;

  1508.     case OPTION_PATH_BRIDGE_WIN32:

  1509.         fOptions.bridge_win32 = valueStr;

  1510.         break;

  1511.     case OPTION_PATH_BRIDGE_WIN64:

  1512.         fOptions.bridge_win64 = valueStr;

  1513.         break;

  1514. #endif

  1515. 

  1516. #ifdef WANT_LV2

  1517.     case OPTION_PATH_BRIDGE_LV2_EXTERNAL:

  1518.         fOptions.bridge_lv2Extrn = valueStr;

  1519.         break;

  1520.     case OPTION_PATH_BRIDGE_LV2_GTK2:

  1521.         fOptions.bridge_lv2Gtk2 = valueStr;

  1522.         break;

  1523.     case OPTION_PATH_BRIDGE_LV2_GTK3:

  1524.         fOptions.bridge_lv2Gtk3 = valueStr;

  1525.         break;

  1526.     case OPTION_PATH_BRIDGE_LV2_QT4:

  1527.         fOptions.bridge_lv2Qt4 = valueStr;

  1528.         break;

  1529.     case OPTION_PATH_BRIDGE_LV2_QT5:

  1530.         fOptions.bridge_lv2Qt5 = valueStr;

  1531.         break;

  1532.     case OPTION_PATH_BRIDGE_LV2_COCOA:

  1533.         fOptions.bridge_lv2Cocoa = valueStr;

  1534.         break;

  1535.     case OPTION_PATH_BRIDGE_LV2_WINDOWS:

  1536.         fOptions.bridge_lv2Win = valueStr;

  1537.         break;

  1538.     case OPTION_PATH_BRIDGE_LV2_X11:

  1539.         fOptions.bridge_lv2X11 = valueStr;

  1540.         break;

  1541. #endif

  1542. 

  1543. #ifdef WANT_VST

  1544.     case OPTION_PATH_BRIDGE_VST_MAC:

  1545.         fOptions.bridge_vstMac = valueStr;

  1546.         break;

  1547.     case OPTION_PATH_BRIDGE_VST_HWND:

  1548.         fOptions.bridge_vstHWND = valueStr;

  1549.         break;

  1550.     case OPTION_PATH_BRIDGE_VST_X11:

  1551.         fOptions.bridge_vstX11 = valueStr;

  1552.         break;

  1553. #endif

  1554.     }

  1555. }

  1556. 

  1557. // -----------------------------------------------------------------------

  1558. // OSC Stuff

  1559. 

  1560. #ifdef BUILD_BRIDGE

  1561. bool CarlaEngine::isOscBridgeRegistered() const noexcept

  1562. {

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

  1564. }

  1565. #else

  1566. bool CarlaEngine::isOscControlRegistered() const noexcept

  1567. {

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

  1569. }

  1570. #endif

  1571. 

  1572. void CarlaEngine::idleOsc()

  1573. {

  1574.     pData->osc.idle();

  1575. }

  1576. 

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

  1578. {

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

  1580. }

  1581. 

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

  1583. {

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

  1585. }

  1586. 

  1587. #ifdef BUILD_BRIDGE

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

  1589. {

  1590.     pData->oscData = oscData;

  1591. }

  1592. #endif

  1593. 

  1594. // -----------------------------------------------------------------------

  1595. // protected calls

  1596. 

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

  1598. {

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

  1600. 

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

  1602.     {

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

  1604. 

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

  1606.             plugin->bufferSizeChanged(newBufferSize);

  1607.     }

  1608. 

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

  1610. }

  1611. 

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

  1613. {

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

  1615. 

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

  1617.     {

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

  1619. 

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

  1621.             plugin->sampleRateChanged(newSampleRate);

  1622.     }

  1623. 

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

  1625. }

  1626. 

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

  1628. {

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

  1630. 

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

  1632.     {

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

  1634. 

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

  1636.             plugin->offlineModeChanged(isOffline);

  1637.     }

  1638. }

  1639. 

  1640. void CarlaEngine::runPendingRtEvents()

  1641. {

  1642.     pData->doNextPluginAction(true);

  1643. 

  1644.     if (pData->time.playing)

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

  1646. 

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

  1648.     {

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

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

  1651.     }

  1652. 

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

  1654.     {

  1655.         // TODO - peak values?

  1656.     }

  1657. }

  1658. 

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

  1660. {

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

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

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

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

  1665. }

  1666. 

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

  1668. {

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

  1670. }

  1671. 

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

  1673. {

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

  1675. 

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

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

  1678. }

  1679. 

  1680. #ifndef BUILD_BRIDGE

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

  1682. {

  1683.     if (value < compare)

  1684.         value = compare;

  1685. }

  1686. 

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

  1688. {

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

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

  1691. 

  1692.     // initialize outputs (zero)

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

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

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

  1696. 

  1697.     bool processed = false;

  1698. 

  1699.     // process plugins

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

  1701.     {

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

  1703. 

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

  1705.             continue;

  1706. 

  1707.         if (processed)

  1708.         {

  1709.             // initialize inputs (from previous outputs)

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

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

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

  1713. 

  1714.             // initialize outputs (zero)

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

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

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

  1718.         }

  1719. 

  1720.         // process

  1721.         plugin->initBuffers();

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

  1723.         plugin->unlock();

  1724. 

  1725. #if 0

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

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

  1728.         {

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

  1730.             {

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

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

  1733.             }

  1734.         }

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

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

  1737.         {

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

  1739.             {

  1740. 

  1741.             }

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

  1743.         }

  1744. #endif

  1745. 

  1746.         // set peaks

  1747.         {

  1748.             float inPeak1  = 0.0f;

  1749.             float inPeak2  = 0.0f;

  1750.             float outPeak1 = 0.0f;

  1751.             float outPeak2 = 0.0f;

  1752. 

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

  1754.             {

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

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

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

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

  1759.             }

  1760. 

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

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

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

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

  1765.         }

  1766. 

  1767.         processed = true;

  1768.     }

  1769. }

  1770. 

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

  1772. {

  1773.     // TODO

  1774.     return;

  1775. 

  1776.     // unused, for now

  1777.     (void)inBuf;

  1778.     (void)outBuf;

  1779.     (void)bufCount;

  1780.     (void)frames;

  1781. }

  1782. #endif

  1783. 

  1784. // -----------------------------------------------------------------------

  1785. // Carla Engine OSC stuff

  1786. 

  1787. #ifndef BUILD_BRIDGE

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

  1789. {

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

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

  1792.     CARLA_ASSERT(pluginName != nullptr);

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

  1794. 

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

  1796.     {

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

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

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

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

  1801.     }

  1802. }

  1803. 

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

  1805. {

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

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

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

  1809. 

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

  1811.     {

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

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

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

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

  1816.     }

  1817. }

  1818. 

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

  1820. {

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

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

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

  1824. 

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

  1826.     {

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

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

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

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

  1831.     }

  1832. }

  1833. 

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

  1835. {

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

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

  1838.     CARLA_ASSERT(type != PLUGIN_NONE);

  1839.     CARLA_ASSERT(realName != nullptr);

  1840.     CARLA_ASSERT(label != nullptr);

  1841.     CARLA_ASSERT(maker != nullptr);

  1842.     CARLA_ASSERT(copyright != nullptr);

  1843.     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);

  1844. 

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

  1846.     {

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

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

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

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

  1851.     }

  1852. }

  1853. 

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

  1855. {

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

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

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

  1859. 

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

  1861.     {

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

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

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

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

  1866.     }

  1867. }

  1868. 

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

  1870. {

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

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

  1873.     CARLA_ASSERT(index >= 0);

  1874.     CARLA_ASSERT(type != PARAMETER_UNKNOWN);

  1875.     CARLA_ASSERT(name != nullptr);

  1876.     CARLA_ASSERT(label != nullptr);

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

  1878. 

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

  1880.     {

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

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

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

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

  1885.     }

  1886. }

  1887. 

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

  1889. {

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

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

  1892.     CARLA_ASSERT(index >= 0);

  1893.     CARLA_ASSERT(min < max);

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

  1895. 

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

  1897.     {

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

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

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

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

  1902.     }

  1903. }

  1904. 

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

  1906. {

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

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

  1909.     CARLA_ASSERT(index >= 0);

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

  1911. 

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

  1913.     {

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

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

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

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

  1918.     }

  1919. }

  1920. 

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

  1922. {

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

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

  1925.     CARLA_ASSERT(index >= 0);

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

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

  1928. 

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

  1930.     {

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

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

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

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

  1935.     }

  1936. }

  1937. 

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

  1939. {

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

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

  1942. #if DEBUG

  1943.     if (index < 0)

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

  1945.     else

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

  1947. #endif

  1948. 

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

  1950.     {

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

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

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

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

  1955.     }

  1956. }

  1957. 

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

  1959. {

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

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

  1962.     CARLA_ASSERT(index >= 0);

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

  1964. 

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

  1966.     {

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

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

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

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

  1971.     }

  1972. }

  1973. 

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

  1975. {

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

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

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

  1979. 

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

  1981.     {

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

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

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

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

  1986.     }

  1987. }

  1988. 

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

  1990. {

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

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

  1993.     CARLA_ASSERT(count >= 0);

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

  1995. 

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

  1997.     {

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

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

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

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

  2002.     }

  2003. }

  2004. 

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

  2006. {

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

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

  2009.     CARLA_ASSERT(index >= 0);

  2010.     CARLA_ASSERT(name != nullptr);

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

  2012. 

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

  2014.     {

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

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

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

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

  2019.     }

  2020. }

  2021. 

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

  2023. {

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

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

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

  2027. 

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

  2029.     {

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

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

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

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

  2034.     }

  2035. }

  2036. 

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

  2038. {

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

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

  2041.     CARLA_ASSERT(count >= 0);

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

  2043. 

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

  2045.     {

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

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

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

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

  2050.     }

  2051. }

  2052. 

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

  2054. {

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

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

  2057.     CARLA_ASSERT(index >= 0);

  2058.     CARLA_ASSERT(bank >= 0);

  2059.     CARLA_ASSERT(program >= 0);

  2060.     CARLA_ASSERT(name != nullptr);

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

  2062. 

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

  2064.     {

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

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

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

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

  2069.     }

  2070. }

  2071. 

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

  2073. {

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

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

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

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

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

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

  2080. 

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

  2082.     {

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

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

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

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

  2087.     }

  2088. }

  2089. 

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

  2091. {

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

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

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

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

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

  2097. 

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

  2099.     {

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

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

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

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

  2104.     }

  2105. }

  2106. 

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

  2108. {

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

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

  2111. 

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

  2113. 

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

  2115.     {

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

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

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

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

  2120.     }

  2121. }

  2122. 

  2123. void CarlaEngine::oscSend_control_exit()

  2124. {

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

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

  2127. 

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

  2129.     {

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

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

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

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

  2134.     }

  2135. }

  2136. #else

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

  2138. {

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

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

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

  2142. 

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

  2144.     {

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

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

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

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

  2149.     }

  2150. }

  2151. 

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

  2153. {

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

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

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

  2157. 

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

  2159.     {

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

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

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

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

  2164.     }

  2165. }

  2166. 

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

  2168. {

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

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

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

  2172. 

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

  2174.     {

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

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

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

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

  2179.     }

  2180. }

  2181. 

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

  2183. {

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

  2185.     CARLA_ASSERT(count >= 0);

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

  2187. 

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

  2189.     {

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

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

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

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

  2194.     }

  2195. }

  2196. 

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

  2198. {

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

  2200.     CARLA_ASSERT(count >= 0);

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

  2202. 

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

  2204.     {

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

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

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

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

  2209.     }

  2210. }

  2211. 

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

  2213. {

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

  2215.     CARLA_ASSERT(name != nullptr);

  2216.     CARLA_ASSERT(label != nullptr);

  2217.     CARLA_ASSERT(maker != nullptr);

  2218.     CARLA_ASSERT(copyright != nullptr);

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

  2220. 

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

  2222.     {

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

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

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

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

  2227.     }

  2228. }

  2229. 

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

  2231. {

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

  2233.     CARLA_ASSERT(name != nullptr);

  2234.     CARLA_ASSERT(unit != nullptr);

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

  2236. 

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

  2238.     {

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

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

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

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

  2243.     }

  2244. }

  2245. 

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

  2247. {

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

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

  2250. 

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

  2252.     {

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

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

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

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

  2257.     }

  2258. }

  2259. 

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

  2261. {

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

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

  2264. 

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

  2266.     {

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

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

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

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

  2271.     }

  2272. }

  2273. 

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

  2275. {

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

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

  2278. 

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

  2280.     {

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

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

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

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

  2285.     }

  2286. }

  2287. 

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

  2289. {

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

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

  2292. 

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

  2294.     {

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

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

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

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

  2299.     }

  2300. }

  2301. 

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

  2303. {

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

  2305.     CARLA_ASSERT(key != nullptr);

  2306.     CARLA_ASSERT(value != nullptr);

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

  2308. 

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

  2310.     {

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

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

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

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

  2315.     }

  2316. }

  2317. 

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

  2319. {

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

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

  2322. 

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

  2324.     {

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

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

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

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

  2329.     }

  2330. }

  2331. 

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

  2333. {

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

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

  2336. 

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

  2338.     {

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

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

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

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

  2343.     }

  2344. }

  2345. 

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

  2347. {

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

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

  2350. 

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

  2352.     {

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

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

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

  2356.         lo_send(pData->oscData->target, targetPath, "i", index);

  2357.     }

  2358. }

  2359. 

  2360. void CarlaEngine::oscSend_bridge_set_midi_program(const int32_t index)

  2361. {

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

  2363.     carla_debug("CarlaEngine::oscSend_bridge_set_midi_program(%i)", index);

  2364. 

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

  2366.     {

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

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

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

  2370.         lo_send(pData->oscData->target, targetPath, "i", index);

  2371.     }

  2372. }

  2373. 

  2374. void CarlaEngine::oscSend_bridge_set_custom_data(const char* const type, const char* const key, const char* const value)

  2375. {

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

  2377.     carla_debug("CarlaEngine::oscSend_bridge_set_custom_data(\"%s\", \"%s\", \"%s\")", type, key, value);

  2378. 

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

  2380.     {

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

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

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

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

  2385.     }

  2386. }

  2387. 

  2388. void CarlaEngine::oscSend_bridge_set_chunk_data(const char* const chunkFile)

  2389. {

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

  2391.     carla_debug("CarlaEngine::oscSend_bridge_set_chunk_data(\"%s\")", chunkFile);

  2392. 

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

  2394.     {

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

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

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

  2398.         lo_send(pData->oscData->target, targetPath, "s", chunkFile);

  2399.     }

  2400. }

  2401. #endif

  2402. 

  2403. CARLA_BACKEND_END_NAMESPACE