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

2422 lines
84KB
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 "juce_audio_basics.h"

  24. 

  25. using juce::FloatVectorOperations;

  26. 

  27. CARLA_BACKEND_START_NAMESPACE

  28. 

  29. #if 0

  30. } // Fix editor indentation

  31. #endif

  32. 

  33. // Engine helper macro, sets lastError and returns false/NULL

  34. #define CARLA_SAFE_ASSERT_RETURN_ERR(cond, err)  if (cond) pass(); else { carla_assert(#cond, __FILE__, __LINE__); setLastError(err); return false; }

  35. #define CARLA_SAFE_ASSERT_RETURN_ERRN(cond, err) if (cond) pass(); else { carla_assert(#cond, __FILE__, __LINE__); setLastError(err); return nullptr; }

  36. 

  37. // -----------------------------------------------------------------------

  38. // Fallback data

  39. 

  40. static const EngineEvent kFallbackEngineEvent;

  41. 

  42. // -----------------------------------------------------------------------

  43. // Carla Engine port (Abstract)

  44. 

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

  46.     : fEngine(engine),

  47.       fIsInput(isInput)

  48. {

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

  50. }

  51. 

  52. CarlaEnginePort::~CarlaEnginePort()

  53. {

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

  55. }

  56. 

  57. // -----------------------------------------------------------------------

  58. // Carla Engine Audio port

  59. 

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

  61.     : CarlaEnginePort(engine, isInput),

  62.       fBuffer(nullptr)

  63. {

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

  65. }

  66. 

  67. CarlaEngineAudioPort::~CarlaEngineAudioPort()

  68. {

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

  70. }

  71. 

  72. // -----------------------------------------------------------------------

  73. // Carla Engine CV port

  74. 

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

  76.     : CarlaEnginePort(engine, isInput),

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

  78. {

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

  80. }

  81. 

  82. CarlaEngineCVPort::~CarlaEngineCVPort()

  83. {

  84.     CARLA_SAFE_ASSERT_RETURN(fBuffer != nullptr,);

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

  86. 

  87.     delete[] fBuffer;

  88.     fBuffer = nullptr;

  89. }

  90. 

  91. void CarlaEngineCVPort::initBuffer()

  92. {

  93.     CARLA_SAFE_ASSERT_RETURN(fBuffer != nullptr,);

  94. 

  95.     FloatVectorOperations::clear(fBuffer, fEngine.getBufferSize());

  96. }

  97. 

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

  99. {

  100.     CARLA_ASSERT(! fIsInput);

  101. }

  102. 

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

  104. {

  105.     if (fBuffer != nullptr)

  106.         delete[] fBuffer;

  107. 

  108.     fBuffer = new float[bufferSize];

  109. }

  110. 

  111. // -----------------------------------------------------------------------

  112. // Carla Engine Event port

  113. 

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

  115.     : CarlaEnginePort(engine, isInput),

  116.       fBuffer(nullptr)

  117. {

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

  119. 

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

  121.         fBuffer = new EngineEvent[kEngineMaxInternalEventCount];

  122. }

  123. 

  124. CarlaEngineEventPort::~CarlaEngineEventPort()

  125. {

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

  127. 

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

  129.     {

  130.         CARLA_SAFE_ASSERT_RETURN(fBuffer != nullptr,);

  131. 

  132.         delete[] fBuffer;

  133.         fBuffer = nullptr;

  134.     }

  135. }

  136. 

  137. void CarlaEngineEventPort::initBuffer()

  138. {

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

  140.         fBuffer = fEngine.getInternalEventBuffer(fIsInput);

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

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

  143. }

  144. 

  145. uint32_t CarlaEngineEventPort::getEventCount() const

  146. {

  147.     CARLA_SAFE_ASSERT_RETURN(fIsInput, 0);

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

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

  150. 

  151.     uint32_t i=0;

  152. 

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

  154.     {

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

  156.             break;

  157.     }

  158. 

  159.     return i;

  160. }

  161. 

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

  163. {

  164.     CARLA_SAFE_ASSERT_RETURN(fIsInput, kFallbackEngineEvent);

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

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

  167.     CARLA_SAFE_ASSERT_RETURN(index < kEngineMaxInternalEventCount, kFallbackEngineEvent);

  168. 

  169.     return fBuffer[index];

  170. }

  171. 

  172. const EngineEvent& CarlaEngineEventPort::getEventUnchecked(const uint32_t index)

  173. {

  174.     return fBuffer[index];

  175. }

  176. 

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

  178. {

  179.     CARLA_SAFE_ASSERT_RETURN(! fIsInput, false);

  180.     CARLA_SAFE_ASSERT_RETURN(fBuffer != nullptr, false);

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

  182.     CARLA_SAFE_ASSERT_RETURN(type != kEngineControlEventTypeNull, false);

  183.     CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS, false);

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

  185. 

  186.     if (type == kEngineControlEventTypeParameter)

  187.     {

  188.         CARLA_ASSERT(! MIDI_IS_CONTROL_BANK_SELECT(param));

  189.     }

  190. 

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

  192. 

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

  194.     {

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

  196.             continue;

  197. 

  198.         EngineEvent& event(fBuffer[i]);

  199. 

  200.         event.type    = kEngineEventTypeControl;

  201.         event.time    = time;

  202.         event.channel = channel;

  203. 

  204.         event.ctrl.type  = type;

  205.         event.ctrl.param = param;

  206.         event.ctrl.value = fixedValue;

  207. 

  208.         return true;

  209.     }

  210. 

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

  212.     return false;

  213. }

  214. 

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

  216. {

  217.     CARLA_SAFE_ASSERT_RETURN(! fIsInput, false);

  218.     CARLA_SAFE_ASSERT_RETURN(fBuffer != nullptr, false);

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

  220.     CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS, false);

  221.     CARLA_SAFE_ASSERT_RETURN(data != nullptr, false);

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

  223. 

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

  225.     {

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

  227.             continue;

  228. 

  229.         EngineEvent& event(fBuffer[i]);

  230. 

  231.         event.type    = kEngineEventTypeMidi;

  232.         event.time    = time;

  233.         event.channel = channel;

  234. 

  235.         event.midi.port = port;

  236.         event.midi.size = size;

  237. 

  238.         event.midi.data[0] = MIDI_GET_CHANNEL_FROM_DATA(data);

  239. 

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

  241.             event.midi.data[j] = data[j];

  242. 

  243.         return true;

  244.     }

  245. 

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

  247.     return false;

  248. }

  249. 

  250. // -----------------------------------------------------------------------

  251. // Carla Engine client (Abstract)

  252. 

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

  254.     : fEngine(engine),

  255.       fActive(false),

  256.       fLatency(0)

  257. {

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

  259. }

  260. 

  261. CarlaEngineClient::~CarlaEngineClient()

  262. {

  263.     CARLA_ASSERT(! fActive);

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

  265. }

  266. 

  267. void CarlaEngineClient::activate()

  268. {

  269.     CARLA_ASSERT(! fActive);

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

  271. 

  272.     fActive = true;

  273. }

  274. 

  275. void CarlaEngineClient::deactivate()

  276. {

  277.     CARLA_ASSERT(fActive);

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

  279. 

  280.     fActive = false;

  281. }

  282. 

  283. bool CarlaEngineClient::isActive() const noexcept

  284. {

  285.     return fActive;

  286. }

  287. 

  288. bool CarlaEngineClient::isOk() const noexcept

  289. {

  290.     return true;

  291. }

  292. 

  293. uint32_t CarlaEngineClient::getLatency() const noexcept

  294. {

  295.     return fLatency;

  296. }

  297. 

  298. void CarlaEngineClient::setLatency(const uint32_t samples) noexcept

  299. {

  300.     fLatency = samples;

  301. }

  302. 

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

  304. {

  305.     CARLA_SAFE_ASSERT_RETURN(name != nullptr && name[0] != '\0', nullptr);

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

  307. 

  308.     switch (portType)

  309.     {

  310.     case kEnginePortTypeNull:

  311.         break;

  312.     case kEnginePortTypeAudio:

  313.         return new CarlaEngineAudioPort(fEngine, isInput);

  314.     case kEnginePortTypeCV:

  315.         return new CarlaEngineCVPort(fEngine, isInput);

  316.     case kEnginePortTypeEvent:

  317.         return new CarlaEngineEventPort(fEngine, isInput);

  318.     case kEnginePortTypeOSC:

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

  320.     }

  321. 

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

  323.     return nullptr;

  324. }

  325. 

  326. // -----------------------------------------------------------------------

  327. // Carla Engine

  328. 

  329. CarlaEngine::CarlaEngine()

  330.     : fBufferSize(0),

  331.       fSampleRate(0.0),

  332.       pData(new CarlaEngineProtectedData(this))

  333. {

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

  335. }

  336. 

  337. CarlaEngine::~CarlaEngine()

  338. {

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

  340. 

  341.     delete pData;

  342. }

  343. 

  344. // -----------------------------------------------------------------------

  345. // Static calls

  346. 

  347. unsigned int CarlaEngine::getDriverCount()

  348. {

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

  350. 

  351.     unsigned int count = 1; // JACK

  352. 

  353. #ifndef BUILD_BRIDGE

  354.     count += getRtAudioApiCount();

  355.     count += getJuceApiCount();

  356. #endif

  357. 

  358.     return count;

  359. }

  360. 

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

  362. {

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

  364. 

  365.     if (index == 0)

  366.         return "JACK";

  367. 

  368. #ifndef BUILD_BRIDGE

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

  370. 

  371.     if (rtAudioIndex < getRtAudioApiCount())

  372.         return getRtAudioApiName(rtAudioIndex);

  373. 

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

  375. 

  376.     if (juceIndex < getJuceApiCount())

  377.         return getJuceApiName(juceIndex);

  378. #endif

  379. 

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

  381.     return nullptr;

  382. }

  383. 

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

  385. {

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

  387. 

  388.     if (index == 0)

  389.     {

  390.         static const char* ret[3] = { "Auto-Connect OFF", "Auto-Connect ON", nullptr };

  391.         return ret;

  392.     }

  393. 

  394. #ifndef BUILD_BRIDGE

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

  396. 

  397.     if (rtAudioIndex < getRtAudioApiCount())

  398.         return getRtAudioApiDeviceNames(rtAudioIndex);

  399. 

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

  401. 

  402.     if (juceIndex < getJuceApiCount())

  403.         return getJuceApiDeviceNames(juceIndex);

  404. #endif

  405. 

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

  407.     return nullptr;

  408. }

  409. 

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

  411. {

  412.     CARLA_SAFE_ASSERT_RETURN(driverName != nullptr && driverName[0] != '\0', nullptr);

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

  414. 

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

  416.         return newJack();

  417. 

  418.     // common

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

  420.         return newRtAudio(AUDIO_API_JACK);

  421. 

  422.     // linux

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

  424.         return newRtAudio(AUDIO_API_ALSA);

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

  426.         return newRtAudio(AUDIO_API_OSS);

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

  428.         return newRtAudio(AUDIO_API_PULSE);

  429. 

  430.     // macos

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

  432.         return newRtAudio(AUDIO_API_CORE);

  433. 

  434.     // windows

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

  436.         return newRtAudio(AUDIO_API_ASIO);

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

  438.         return newRtAudio(AUDIO_API_DS);

  439. 

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

  441.     return nullptr;

  442. }

  443. 

  444. // -----------------------------------------------------------------------

  445. // Maximum values

  446. 

  447. unsigned int CarlaEngine::getMaxClientNameSize() const noexcept

  448. {

  449.     return STR_MAX/2;

  450. }

  451. 

  452. unsigned int CarlaEngine::getMaxPortNameSize() const noexcept

  453. {

  454.     return STR_MAX;

  455. }

  456. 

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

  458. {

  459.     return pData->curPluginCount;

  460. }

  461. 

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

  463. {

  464.     return pData->maxPluginNumber;

  465. }

  466. 

  467. // -----------------------------------------------------------------------

  468. // Virtual, per-engine type calls

  469. 

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

  471. {

  472.     CARLA_SAFE_ASSERT_RETURN_ERR(fName.isEmpty(), "Invalid engine internal data (err #1)");

  473.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->oscData == nullptr, "Invalid engine internal data (err #2)");

  474.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->plugins == nullptr, "Invalid engine internal data (err #3)");

  475.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->bufEvents.in  == nullptr, "Invalid engine internal data (err #4)");

  476.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->bufEvents.out == nullptr, "Invalid engine internal data (err #5)");

  477.     CARLA_SAFE_ASSERT_RETURN_ERR(clientName != nullptr && clientName[0] != '\0', "Invalid client name");

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

  479. 

  480.     pData->aboutToClose    = false;

  481.     pData->curPluginCount  = 0;

  482.     pData->maxPluginNumber = 0;

  483.     pData->nextPluginId    = 0;

  484. 

  485.     switch (fOptions.processMode)

  486.     {

  487.     case PROCESS_MODE_SINGLE_CLIENT:

  488.     case PROCESS_MODE_MULTIPLE_CLIENTS:

  489.         pData->maxPluginNumber = MAX_DEFAULT_PLUGINS;

  490.         break;

  491. 

  492.     case PROCESS_MODE_CONTINUOUS_RACK:

  493.         pData->maxPluginNumber = MAX_RACK_PLUGINS;

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

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

  496.         break;

  497. 

  498.     case PROCESS_MODE_PATCHBAY:

  499.         pData->maxPluginNumber = MAX_PATCHBAY_PLUGINS;

  500.         break;

  501. 

  502.     case PROCESS_MODE_BRIDGE:

  503.         pData->maxPluginNumber = 1;

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

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

  506.         break;

  507.     }

  508. 

  509.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->maxPluginNumber != 0, "Invalid engine process mode");

  510. 

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

  512. 

  513.     fName = clientName;

  514.     fName.toBasic();

  515. 

  516.     fTimeInfo.clear();

  517. 

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

  519. 

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

  521. #ifndef BUILD_BRIDGE

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

  523. #endif

  524. 

  525.     pData->nextAction.ready();

  526.     pData->thread.startThread();

  527. 

  528.     callback(CALLBACK_ENGINE_STARTED, 0, 0, 0, 0.0f, getCurrentDriverName());

  529. 

  530.     return true;

  531. }

  532. 

  533. bool CarlaEngine::close()

  534. {

  535.     CARLA_SAFE_ASSERT_RETURN_ERR(fName.isNotEmpty(), "Invalid engine internal data (err #6)");

  536.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->plugins != nullptr, "Invalid engine internal data (err #7)");

  537.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->nextPluginId == pData->maxPluginNumber, "Invalid engine internal data (err #8)");

  538.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->nextAction.opcode == kEnginePostActionNull, "Invalid engine internal data (err #9)");

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

  540. 

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

  542.     pData->nextAction.ready();

  543. 

  544. #ifndef BUILD_BRIDGE

  545.     oscSend_control_exit();

  546. #endif

  547.     pData->osc.close();

  548.     pData->oscData = nullptr;

  549. 

  550.     pData->aboutToClose = true;

  551.     pData->curPluginCount = 0;

  552.     pData->maxPluginNumber = 0;

  553.     pData->nextPluginId = 0;

  554. 

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

  556.     {

  557.         delete[] pData->plugins;

  558.         pData->plugins = nullptr;

  559.     }

  560. 

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

  562.     {

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

  564.         pData->bufEvents.in = nullptr;

  565.     }

  566. 

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

  568.     {

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

  570.         pData->bufEvents.out = nullptr;

  571.     }

  572. 

  573.     fName.clear();

  574. 

  575.     callback(CALLBACK_ENGINE_STOPPED, 0, 0, 0, 0.0f, nullptr);

  576. 

  577.     return true;

  578. }

  579. 

  580. void CarlaEngine::idle()

  581. {

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

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

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

  585. 

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

  587.     {

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

  589. 

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

  591.             plugin->idleGui();

  592.     }

  593. }

  594. 

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

  596. {

  597.     return new CarlaEngineClient(*this);

  598. }

  599. 

  600. // -----------------------------------------------------------------------

  601. // Plugin management

  602. 

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

  604. {

  605.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->plugins != nullptr, "Invalid engine internal data (err #10)");

  606.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->nextPluginId <= pData->maxPluginNumber, "Invalid engine internal data (err #11)");

  607.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->nextAction.opcode == kEnginePostActionNull, "Invalid engine internal data (err #12)");

  608.     CARLA_SAFE_ASSERT_RETURN_ERR(btype != BINARY_NONE, "Invalid plugin params (err #1)");

  609.     CARLA_SAFE_ASSERT_RETURN_ERR(ptype != PLUGIN_NONE, "Invalid plugin params (err #2)");

  610.     CARLA_SAFE_ASSERT_RETURN_ERR((filename != nullptr && filename[0] != '\0') || (label != nullptr && label[0] != '\0'), "Invalid plugin params (err #3)");

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

  612. 

  613.     unsigned int id;

  614.     CarlaPlugin* oldPlugin = nullptr;

  615. 

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

  617.     {

  618.         id = pData->nextPluginId;

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

  620. 

  621.         oldPlugin = pData->plugins[id].plugin;

  622. 

  623.         CARLA_SAFE_ASSERT_RETURN_ERR(oldPlugin != nullptr, "Invalid replace plugin Id");

  624.     }

  625.     else

  626.     {

  627.         id = pData->curPluginCount;

  628. 

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

  630.         {

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

  632.             return false;

  633.         }

  634. 

  635.         CARLA_SAFE_ASSERT_RETURN_ERR(pData->plugins[id].plugin == nullptr, "Invalid engine internal data (err #13)");

  636.     }

  637. 

  638.     CarlaPlugin::Initializer init = {

  639.         this,

  640.         id,

  641.         filename,

  642.         name,

  643.         label

  644.     };

  645. 

  646.     CarlaPlugin* plugin = nullptr;

  647. 

  648. #ifndef BUILD_BRIDGE

  649.     const char* bridgeBinary;

  650. 

  651.     switch (btype)

  652.     {

  653.     case BINARY_POSIX32:

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

  655.         break;

  656.     case BINARY_POSIX64:

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

  658.         break;

  659.     case BINARY_WIN32:

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

  661.         break;

  662.     case BINARY_WIN64:

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

  664.         break;

  665.     default:

  666.         bridgeBinary = nullptr;

  667.         break;

  668.     }

  669. 

  670. # ifndef CARLA_OS_WIN

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

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

  673. # endif

  674. 

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

  676.     {

  677.         if (bridgeBinary != nullptr)

  678.         {

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

  680.         }

  681. # ifdef CARLA_OS_LINUX

  682.         else if (btype == BINARY_WIN32)

  683.         {

  684.             // fallback to dssi-vst

  685.             CarlaString label2("filename");

  686.             label2.replace(' ', '*');

  687. 

  688.             CarlaPlugin::Initializer init2 = {

  689.                 this,

  690.                 id,

  691.                 "/usr/lib/dssi/dssi-vst.so",

  692.                 name,

  693.                 (const char*)label2

  694.             };

  695. 

  696.             plugin = CarlaPlugin::newDSSI(init2);

  697.         }

  698. # endif

  699.         else

  700.         {

  701.             setLastError("This Carla build cannot handle this binary");

  702.             return false;

  703.         }

  704.     }

  705.     else

  706. #endif // BUILD_BRIDGE

  707.     {

  708.         setLastError("Invalid or unsupported plugin type");

  709. 

  710.         switch (ptype)

  711.         {

  712.         case PLUGIN_NONE:

  713.             break;

  714. 

  715.         case PLUGIN_INTERNAL:

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

  717.             break;

  718. 

  719.         case PLUGIN_LADSPA:

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

  721.             break;

  722. 

  723.         case PLUGIN_DSSI:

  724.             plugin = CarlaPlugin::newDSSI(init);

  725.             break;

  726. 

  727.         case PLUGIN_LV2:

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

  729.             break;

  730. 

  731.         case PLUGIN_VST:

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

  733.             break;

  734. 

  735.         case PLUGIN_AU:

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

  737.             break;

  738. 

  739.         case PLUGIN_CSOUND:

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

  741.             break;

  742. 

  743.         case PLUGIN_GIG:

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

  745.             break;

  746. 

  747.         case PLUGIN_SF2:

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

  749.             break;

  750. 

  751.         case PLUGIN_SFZ:

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

  753.             break;

  754.         }

  755.     }

  756. 

  757.     if (plugin == nullptr)

  758.         return false;

  759. 

  760.     plugin->registerToOscClient();

  761. 

  762.     EnginePluginData& pluginData(pData->plugins[id]);

  763.     pluginData.plugin      = plugin;

  764.     pluginData.insPeak[0]  = 0.0f;

  765.     pluginData.insPeak[1]  = 0.0f;

  766.     pluginData.outsPeak[0] = 0.0f;

  767.     pluginData.outsPeak[1] = 0.0f;

  768. 

  769.     if (oldPlugin != nullptr)

  770.     {

  771.         delete oldPlugin;

  772.         callback(CALLBACK_RELOAD_ALL, id, 0, 0, 0.0f, plugin->getName());

  773.     }

  774.     else

  775.     {

  776.         ++pData->curPluginCount;

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

  778.     }

  779. 

  780.     return true;

  781. }

  782. 

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

  784. {

  785.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->plugins != nullptr, "Invalid engine internal data (err #14)");

  786.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->curPluginCount != 0, "Invalid engine internal data (err #15)");

  787.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->nextAction.opcode == kEnginePostActionNull, "Invalid engine internal data (err #16)");

  788.     CARLA_SAFE_ASSERT_RETURN_ERR(id < pData->curPluginCount, "Invalid plugin Id (err #1)");

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

  790. 

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

  792. 

  793.     CARLA_SAFE_ASSERT_RETURN_ERR(plugin != nullptr, "Could not find plugin to remove");

  794.     CARLA_SAFE_ASSERT_RETURN_ERR(plugin->getId() == id, "Invalid engine internal data (err #17)");

  795. 

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

  797. 

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

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

  800. 

  801. #ifndef BUILD_BRIDGE

  802.     if (isOscControlRegistered())

  803.         oscSend_control_remove_plugin(id);

  804. #endif

  805. 

  806.     delete plugin;

  807. 

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

  809.         pData->thread.startThread();

  810. 

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

  812.     return true;

  813. }

  814. 

  815. bool CarlaEngine::removeAllPlugins()

  816. {

  817.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->plugins != nullptr, "Invalid engine internal data (err #18)");

  818.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->nextPluginId == pData->maxPluginNumber, "Invalid engine internal data (err #19)");

  819.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->nextAction.opcode == kEnginePostActionNull, "Invalid engine internal data (err #20)");

  820.     carla_debug("CarlaEngine::removeAllPlugins()");

  821. 

  822.     if (pData->curPluginCount == 0)

  823.         return true;

  824. 

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

  826. 

  827.     const bool lockWait(isRunning());

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

  829. 

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

  831.     {

  832.         EnginePluginData& pluginData(pData->plugins[i]);

  833. 

  834.         if (pluginData.plugin != nullptr)

  835.         {

  836.             delete pluginData.plugin;

  837.             pluginData.plugin = nullptr;

  838.         }

  839. 

  840.         pluginData.insPeak[0]  = 0.0f;

  841.         pluginData.insPeak[1]  = 0.0f;

  842.         pluginData.outsPeak[0] = 0.0f;

  843.         pluginData.outsPeak[1] = 0.0f;

  844.     }

  845. 

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

  847.         pData->thread.startThread();

  848. 

  849.     return true;

  850. }

  851. 

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

  853. {

  854.     CARLA_SAFE_ASSERT_RETURN_ERRN(pData->plugins != nullptr, "Invalid engine internal data (err #21)");

  855.     CARLA_SAFE_ASSERT_RETURN_ERRN(pData->curPluginCount != 0, "Invalid engine internal data (err #22)");

  856.     CARLA_SAFE_ASSERT_RETURN_ERRN(pData->nextAction.opcode == kEnginePostActionNull, "Invalid engine internal data (err #23)");

  857.     CARLA_SAFE_ASSERT_RETURN_ERRN(id < pData->curPluginCount, "Invalid plugin Id (err #2)");

  858.     CARLA_SAFE_ASSERT_RETURN_ERRN(newName != nullptr && newName[0] != '\0', "Invalid plugin name");

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

  860. 

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

  862. 

  863.     CARLA_SAFE_ASSERT_RETURN_ERRN(plugin != nullptr, "Could not find plugin to rename");

  864.     CARLA_SAFE_ASSERT_RETURN_ERRN(plugin->getId() == id, "Invalid engine internal data (err #24)");

  865. 

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

  867.     {

  868.         plugin->setName(name);

  869.         return name;

  870.     }

  871. 

  872.     setLastError("Unable to get new unique plugin name");

  873.     return nullptr;

  874. }

  875. 

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

  877. {

  878.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->plugins != nullptr, "Invalid engine internal data (err #25)");

  879.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->curPluginCount != 0, "Invalid engine internal data (err #26)");

  880.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->nextAction.opcode == kEnginePostActionNull, "Invalid engine internal data (err #27)");

  881.     CARLA_SAFE_ASSERT_RETURN_ERR(id < pData->curPluginCount, "Invalid plugin Id (err #3)");

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

  883. 

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

  885. 

  886.     CARLA_SAFE_ASSERT_RETURN_ERR(plugin != nullptr, "Could not find plugin to clone");

  887.     CARLA_SAFE_ASSERT_RETURN_ERR(plugin->getId() == id, "Invalid engine internal data (err #28)");

  888. 

  889.     char label[STR_MAX+1];

  890.     carla_zeroChar(label, STR_MAX+1);

  891.     plugin->getLabel(label);

  892. 

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

  894. 

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

  896.         return false;

  897. 

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

  899. 

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

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

  902. 

  903.     return true;

  904. }

  905. 

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

  907. {

  908.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->plugins != nullptr, "Invalid engine internal data (err #29)");

  909.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->curPluginCount != 0, "Invalid engine internal data (err #30)");

  910.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->nextAction.opcode == kEnginePostActionNull, "Invalid engine internal data (err #31)");

  911.     CARLA_SAFE_ASSERT_RETURN_ERR(id < pData->curPluginCount, "Invalid plugin Id (err #4)");

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

  913. 

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

  915. 

  916.     CARLA_SAFE_ASSERT_RETURN_ERR(plugin != nullptr, "Could not find plugin to replace");

  917.     CARLA_SAFE_ASSERT_RETURN_ERR(plugin->getId() == id, "Invalid engine internal data (err #32)");

  918. 

  919.     pData->nextPluginId = id;

  920. 

  921.     return true;

  922. }

  923. 

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

  925. {

  926.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->plugins != nullptr, "Invalid engine internal data (err #33)");

  927.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->curPluginCount >= 2, "Invalid engine internal data (err #34)");

  928.     CARLA_SAFE_ASSERT_RETURN_ERR(pData->nextAction.opcode == kEnginePostActionNull, "Invalid engine internal data (err #35)");

  929.     CARLA_SAFE_ASSERT_RETURN_ERR(idA != idB, "Invalid operation, cannot switch plugin with itself");

  930.     CARLA_SAFE_ASSERT_RETURN_ERR(idA < pData->curPluginCount, "Invalid plugin Id (err #5)");

  931.     CARLA_SAFE_ASSERT_RETURN_ERR(idB < pData->curPluginCount, "Invalid plugin Id (err #6)");

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

  933. 

  934.     CarlaPlugin* const pluginA(pData->plugins[idA].plugin);

  935.     CarlaPlugin* const pluginB(pData->plugins[idB].plugin);

  936. 

  937.     CARLA_SAFE_ASSERT_RETURN_ERR(pluginA != nullptr, "Could not find plugin to switch (err #1)");

  938.     CARLA_SAFE_ASSERT_RETURN_ERR(pluginA != nullptr, "Could not find plugin to switch (err #2)");

  939.     CARLA_SAFE_ASSERT_RETURN_ERR(pluginA->getId() == idA, "Invalid engine internal data (err #36)");

  940.     CARLA_SAFE_ASSERT_RETURN_ERR(pluginB->getId() == idB, "Invalid engine internal data (err #37)");

  941. 

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

  943. 

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

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

  946. 

  947. #ifndef BUILD_BRIDGE // TODO

  948.     //if (isOscControlRegistered())

  949.     //    oscSend_control_switch_plugins(idA, idB);

  950. #endif

  951. 

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

  953.         pData->thread.startThread();

  954. 

  955.     return true;

  956. }

  957. 

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

  959. {

  960.     CARLA_SAFE_ASSERT_RETURN_ERRN(pData->plugins != nullptr, "Invalid engine internal data (err #38)");

  961.     CARLA_SAFE_ASSERT_RETURN_ERRN(pData->curPluginCount != 0, "Invalid engine internal data (err #39)");

  962.     CARLA_SAFE_ASSERT_RETURN_ERRN(pData->nextAction.opcode == kEnginePostActionNull, "Invalid engine internal data (err #40)");

  963.     CARLA_SAFE_ASSERT_RETURN_ERRN(id < pData->curPluginCount, "Invalid plugin Id (err #7)");

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

  965. 

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

  967. }

  968. 

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

  970. {

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

  972. }

  973. 

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

  975. {

  976.     CARLA_SAFE_ASSERT_RETURN(pData->plugins != nullptr, nullptr);

  977.     CARLA_SAFE_ASSERT_RETURN(pData->maxPluginNumber != 0, nullptr);

  978.     CARLA_SAFE_ASSERT_RETURN(pData->nextAction.opcode == kEnginePostActionNull, nullptr);

  979.     CARLA_SAFE_ASSERT_RETURN(name != nullptr && name[0] != '\0', nullptr);

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

  981. 

  982.     static CarlaMutex m;

  983.     const CarlaMutex::ScopedLocker sl(m);

  984. 

  985.     static CarlaString sname;

  986.     sname = name;

  987. 

  988.     if (sname.isEmpty())

  989.     {

  990.         sname = "(No name)";

  991.         return (const char*)sname;

  992.     }

  993. 

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

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

  996. 

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

  998.     {

  999.         CARLA_SAFE_ASSERT_BREAK(pData->plugins[i].plugin != nullptr);

  1000. 

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

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

  1003.         {

  1004.             if (sname != pluginName)

  1005.                 continue;

  1006.         }

  1007. 

  1008.         // Check if string has already been modified

  1009.         {

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

  1011. 

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

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

  1014.             {

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

  1016. 

  1017.                 if (number == 9)

  1018.                 {

  1019.                     // next number is 10, 2 digits

  1020.                     sname.truncate(len-4);

  1021.                     sname += " (10)";

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

  1023.                 }

  1024.                 else

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

  1026. 

  1027.                 continue;

  1028.             }

  1029. 

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

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

  1032.             {

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

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

  1035. 

  1036.                 if (n2 == '9')

  1037.                 {

  1038.                     n2  = '0';

  1039.                     n3 += 1;

  1040.                 }

  1041.                 else

  1042.                     n2 += 1;

  1043. 

  1044.                 sname[len-2] = n2;

  1045.                 sname[len-3] = n3;

  1046. 

  1047.                 continue;

  1048.             }

  1049.         }

  1050. 

  1051.         // Modify string if not

  1052.         sname += " (2)";

  1053.     }

  1054. 

  1055.     return (const char*)sname;

  1056. }

  1057. 

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

  1059. // Project management

  1060. 

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

  1062. {

  1063.     CARLA_SAFE_ASSERT_RETURN_ERR(filename != nullptr && filename[0] != '\0', "Invalid filename (err #1)");

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

  1065. 

  1066.     using namespace juce;

  1067. 

  1068.     File file(filename);

  1069. 

  1070.     if (! file.existsAsFile())

  1071.     {

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

  1073.         return false;

  1074.     }

  1075. 

  1076.     CarlaString baseName(file.getFileNameWithoutExtension().toRawUTF8());

  1077.     CarlaString extension(file.getFileExtension().toRawUTF8()+1);

  1078.     extension.toLower();

  1079. 

  1080.     carla_stdout("load filename with extension %s", (const char*)extension);

  1081. 

  1082.     // -------------------------------------------------------------------

  1083. 

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

  1085.         return loadProject(filename);

  1086. 

  1087.     // -------------------------------------------------------------------

  1088. 

  1089.     if (extension == "gig")

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

  1091. 

  1092.     if (extension == "sf2")

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

  1094. 

  1095.     if (extension == "sfz")

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

  1097. 

  1098.     // -------------------------------------------------------------------

  1099. 

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

  1101.     {

  1102. #ifdef WANT_AUDIOFILE

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

  1104.         {

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

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

  1107.             return true;

  1108.         }

  1109.         return false;

  1110. #else

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

  1112.         return false;

  1113. #endif

  1114.     }

  1115. 

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

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

  1118.     {

  1119. #ifdef WANT_AUDIOFILE

  1120. # ifdef HAVE_FFMPEG

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

  1122.         {

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

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

  1125.             return true;

  1126.         }

  1127.         return false;

  1128. # else

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

  1130.         return false;

  1131. # endif

  1132. #else

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

  1134.         return false;

  1135. #endif

  1136.     }

  1137. 

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

  1139. 

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

  1141.     {

  1142. #ifdef WANT_MIDIFILE

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

  1144.         {

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

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

  1147.             return true;

  1148.         }

  1149.         return false;

  1150. #else

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

  1152.         return false;

  1153. #endif

  1154.     }

  1155. 

  1156.     // -------------------------------------------------------------------

  1157.     // ZynAddSubFX

  1158. 

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

  1160.     {

  1161. #ifdef WANT_ZYNADDSUBFX

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

  1163.         {

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

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

  1166.             return true;

  1167.         }

  1168.         return false;

  1169. #else

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

  1171.         return false;

  1172. #endif

  1173.     }

  1174. 

  1175.     // -------------------------------------------------------------------

  1176. 

  1177.     setLastError("Unknown file extension");

  1178.     return false;

  1179. }

  1180. 

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

  1182. {

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

  1184.         return false;

  1185. 

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

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

  1188. 

  1189.     if (strLen < suffixLen)

  1190.         return false;

  1191. 

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

  1193. }

  1194. 

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

  1196. {

  1197.     CARLA_SAFE_ASSERT_RETURN_ERR(filename != nullptr && filename[0] != '\0', "Invalid filename (err #2)");

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

  1199. 

  1200.     using namespace juce;

  1201. 

  1202.     File file(filename);

  1203. 

  1204.     XmlDocument xml(file);

  1205. 

  1206.     if (XmlElement* const xmlCheck = xml.getDocumentElement(true))

  1207.     {

  1208.         const String& tagNameTest(xmlCheck->getTagName());

  1209.         const bool    isPreset(tagNameTest.equalsIgnoreCase("carla-preset"));

  1210. 

  1211.         if (tagNameTest.equalsIgnoreCase("carla-project") || isPreset)

  1212.         {

  1213.             if (XmlElement* const xmlElem = xml.getDocumentElement(false))

  1214.             {

  1215.                 for (XmlElement* subElem = xmlElem->getFirstChildElement(); subElem != nullptr; subElem = subElem->getNextElement())

  1216.                 {

  1217.                     if (isPreset || subElem->getTagName().equalsIgnoreCase("Plugin"))

  1218.                     {

  1219.                         SaveState saveState;

  1220.                         fillSaveStateFromXmlElement(saveState, isPreset ? xmlElem : subElem);

  1221. 

  1222.                         CARLA_SAFE_ASSERT_CONTINUE(saveState.type != nullptr);

  1223. 

  1224.                         const void* extraStuff = nullptr;

  1225. 

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

  1227.                         {

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

  1229. 

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

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

  1232.                         }

  1233. 

  1234.                         // TODO - proper find&load plugins

  1235. 

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

  1237.                         {

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

  1239.                                 plugin->loadSaveState(saveState);

  1240.                         }

  1241.                     }

  1242. 

  1243.                     if (isPreset)

  1244.                         break;

  1245.                 }

  1246. 

  1247.                 delete xmlElem;

  1248.                 delete xmlCheck;

  1249.                 return true;

  1250.             }

  1251.             else

  1252.                 setLastError("Failed to parse file");

  1253.         }

  1254.         else

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

  1256. 

  1257.         delete xmlCheck;

  1258.         return false;

  1259.     }

  1260. 

  1261.     setLastError("Not a valid file");

  1262.     return false;

  1263. }

  1264. 

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

  1266. {

  1267.     CARLA_SAFE_ASSERT_RETURN_ERR(filename != nullptr && filename[0] != '\0', "Invalid filename (err #3)");

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

  1269. 

  1270.     using namespace juce;

  1271. 

  1272.     File file(filename);

  1273. 

  1274.     MemoryOutputStream out;

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

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

  1277.     out << "<CARLA-PROJECT VERSION='2.0'>\n";

  1278. 

  1279.     bool firstPlugin = true;

  1280.     char strBuf[STR_MAX+1];

  1281. 

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

  1283.     {

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

  1285. 

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

  1287.         {

  1288.             if (! firstPlugin)

  1289.                 out << "\n";

  1290. 

  1291.             strBuf[0] = '\0';

  1292. 

  1293.             plugin->getRealName(strBuf);

  1294. 

  1295.             if (strBuf[0] != '\0')

  1296.             {

  1297.                 out << " <!-- ";

  1298.                 out << xmlSafeString(strBuf, true);

  1299.                 out << " -->\n";

  1300.             }

  1301. 

  1302.             String content;

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

  1304. 

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

  1306.             out << content;

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

  1308. 

  1309.             firstPlugin = false;

  1310.         }

  1311.     }

  1312. 

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

  1314. 

  1315.     return file.replaceWithData(out.getData(), out.getDataSize());

  1316. }

  1317. 

  1318. // -----------------------------------------------------------------------

  1319. // Information (peaks)

  1320. 

  1321. // FIXME

  1322. 

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

  1324. {

  1325.     CARLA_SAFE_ASSERT_RETURN(pluginId < pData->curPluginCount, 0.0f);

  1326.     CARLA_SAFE_ASSERT_RETURN(id == 1 || id == 2, 0.0f);

  1327. 

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

  1329. }

  1330. 

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

  1332. {

  1333.     CARLA_SAFE_ASSERT_RETURN(pluginId < pData->curPluginCount, 0.0f);

  1334.     CARLA_SAFE_ASSERT_RETURN(id == 1 || id == 2, 0.0f);

  1335. 

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

  1337. }

  1338. 

  1339. // -----------------------------------------------------------------------

  1340. // Callback

  1341. 

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

  1343. {

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

  1345. 

  1346.     if (pData->callback != nullptr)

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

  1348. }

  1349. 

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

  1351. {

  1352.     CARLA_ASSERT(func != nullptr);

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

  1354. 

  1355.     pData->callback    = func;

  1356.     pData->callbackPtr = ptr;

  1357. }

  1358. 

  1359. // -----------------------------------------------------------------------

  1360. // Patchbay

  1361. 

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

  1363. {

  1364.     setLastError("Unsupported operation");

  1365.     return false;

  1366. }

  1367. 

  1368. bool CarlaEngine::patchbayDisconnect(int)

  1369. {

  1370.     setLastError("Unsupported operation");

  1371.     return false;

  1372. }

  1373. 

  1374. void CarlaEngine::patchbayRefresh()

  1375. {

  1376.     // nothing

  1377. }

  1378. 

  1379. // -----------------------------------------------------------------------

  1380. // Transport

  1381. 

  1382. void CarlaEngine::transportPlay()

  1383. {

  1384.     pData->time.playing = true;

  1385. }

  1386. 

  1387. void CarlaEngine::transportPause()

  1388. {

  1389.     pData->time.playing = false;

  1390. }

  1391. 

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

  1393. {

  1394.     pData->time.frame = frame;

  1395. }

  1396. 

  1397. // -----------------------------------------------------------------------

  1398. // Error handling

  1399. 

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

  1401. {

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

  1403. }

  1404. 

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

  1406. {

  1407.     pData->lastError = error;

  1408. }

  1409. 

  1410. void CarlaEngine::setAboutToClose()

  1411. {

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

  1413. 

  1414.     pData->aboutToClose = true;

  1415. }

  1416. 

  1417. // -----------------------------------------------------------------------

  1418. // Global options

  1419. 

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

  1421. {

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

  1423. 

  1424. #ifndef BUILD_BRIDGE

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

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

  1427. #endif

  1428. 

  1429.     switch (option)

  1430.     {

  1431.     case OPTION_PROCESS_NAME:

  1432.         break;

  1433. 

  1434.     case OPTION_PROCESS_MODE:

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

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

  1437. 

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

  1439.         break;

  1440. 

  1441.     case OPTION_TRANSPORT_MODE:

  1442.         if (value < TRANSPORT_MODE_INTERNAL || value > TRANSPORT_MODE_JACK)

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

  1444. 

  1445.         fOptions.transportMode = static_cast<TransportMode>(value);

  1446.         break;

  1447. 

  1448.     case OPTION_FORCE_STEREO:

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

  1450.         break;

  1451. 

  1452.     case OPTION_PREFER_PLUGIN_BRIDGES:

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

  1454.         break;

  1455. 

  1456.     case OPTION_PREFER_UI_BRIDGES:

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

  1458.         break;

  1459. 

  1460.     case OPTION_UIS_ALWAYS_ON_TOP:

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

  1462.         break;

  1463. 

  1464.     case OPTION_MAX_PARAMETERS:

  1465.         if (value < 1)

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

  1467. 

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

  1469.         break;

  1470. 

  1471.     case OPTION_UI_BRIDGES_TIMEOUT:

  1472.         if (value < 1)

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

  1474. 

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

  1476.         break;

  1477. 

  1478.     case OPTION_AUDIO_NUM_PERIODS:

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

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

  1481. 

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

  1483.         break;

  1484. 

  1485.     case OPTION_AUDIO_BUFFER_SIZE:

  1486.         if (value < 8)

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

  1488. 

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

  1490.         break;

  1491. 

  1492.     case OPTION_AUDIO_SAMPLE_RATE:

  1493.         if (value < 22050)

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

  1495. 

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

  1497.         break;

  1498. 

  1499.     case OPTION_AUDIO_DEVICE:

  1500.         fOptions.audioDevice = valueStr;

  1501.         break;

  1502. 

  1503.     case OPTION_PATH_RESOURCES:

  1504.         fOptions.resourceDir = valueStr;

  1505.         break;

  1506. 

  1507. #ifndef BUILD_BRIDGE

  1508.     case OPTION_PATH_BRIDGE_NATIVE:

  1509.         fOptions.bridge_native = valueStr;

  1510.         break;

  1511.     case OPTION_PATH_BRIDGE_POSIX32:

  1512.         fOptions.bridge_posix32 = valueStr;

  1513.         break;

  1514.     case OPTION_PATH_BRIDGE_POSIX64:

  1515.         fOptions.bridge_posix64 = valueStr;

  1516.         break;

  1517.     case OPTION_PATH_BRIDGE_WIN32:

  1518.         fOptions.bridge_win32 = valueStr;

  1519.         break;

  1520.     case OPTION_PATH_BRIDGE_WIN64:

  1521.         fOptions.bridge_win64 = valueStr;

  1522.         break;

  1523. #endif

  1524. 

  1525. #ifdef WANT_LV2

  1526.     case OPTION_PATH_BRIDGE_LV2_EXTERNAL:

  1527.         fOptions.bridge_lv2Extrn = valueStr;

  1528.         break;

  1529.     case OPTION_PATH_BRIDGE_LV2_GTK2:

  1530.         fOptions.bridge_lv2Gtk2 = valueStr;

  1531.         break;

  1532.     case OPTION_PATH_BRIDGE_LV2_GTK3:

  1533.         fOptions.bridge_lv2Gtk3 = valueStr;

  1534.         break;

  1535.     case OPTION_PATH_BRIDGE_LV2_QT4:

  1536.         fOptions.bridge_lv2Qt4 = valueStr;

  1537.         break;

  1538.     case OPTION_PATH_BRIDGE_LV2_QT5:

  1539.         fOptions.bridge_lv2Qt5 = valueStr;

  1540.         break;

  1541.     case OPTION_PATH_BRIDGE_LV2_COCOA:

  1542.         fOptions.bridge_lv2Cocoa = valueStr;

  1543.         break;

  1544.     case OPTION_PATH_BRIDGE_LV2_WINDOWS:

  1545.         fOptions.bridge_lv2Win = valueStr;

  1546.         break;

  1547.     case OPTION_PATH_BRIDGE_LV2_X11:

  1548.         fOptions.bridge_lv2X11 = valueStr;

  1549.         break;

  1550. #endif

  1551. 

  1552. #ifdef WANT_VST

  1553.     case OPTION_PATH_BRIDGE_VST_MAC:

  1554.         fOptions.bridge_vstMac = valueStr;

  1555.         break;

  1556.     case OPTION_PATH_BRIDGE_VST_HWND:

  1557.         fOptions.bridge_vstHWND = valueStr;

  1558.         break;

  1559.     case OPTION_PATH_BRIDGE_VST_X11:

  1560.         fOptions.bridge_vstX11 = valueStr;

  1561.         break;

  1562. #endif

  1563.     }

  1564. }

  1565. 

  1566. // -----------------------------------------------------------------------

  1567. // OSC Stuff

  1568. 

  1569. #ifdef BUILD_BRIDGE

  1570. bool CarlaEngine::isOscBridgeRegistered() const noexcept

  1571. {

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

  1573. }

  1574. #else

  1575. bool CarlaEngine::isOscControlRegistered() const noexcept

  1576. {

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

  1578. }

  1579. #endif

  1580. 

  1581. void CarlaEngine::idleOsc()

  1582. {

  1583.     pData->osc.idle();

  1584. }

  1585. 

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

  1587. {

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

  1589. }

  1590. 

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

  1592. {

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

  1594. }

  1595. 

  1596. #ifdef BUILD_BRIDGE

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

  1598. {

  1599.     pData->oscData = oscData;

  1600. }

  1601. #endif

  1602. 

  1603. // -----------------------------------------------------------------------

  1604. // Helper functions

  1605. 

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

  1607. {

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

  1609. }

  1610. 

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

  1612. {

  1613.     CARLA_SAFE_ASSERT_RETURN(id == pData->curPluginCount,);

  1614.     carla_debug("CarlaEngine::registerEnginePlugin(%i, %p)", id, plugin);

  1615. 

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

  1617. }

  1618. 

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

  1620. // Internal stuff

  1621. 

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

  1623. {

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

  1625. 

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

  1627.     {

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

  1629. 

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

  1631.             plugin->bufferSizeChanged(newBufferSize);

  1632.     }

  1633. 

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

  1635. }

  1636. 

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

  1638. {

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

  1640. 

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

  1642.     {

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

  1644. 

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

  1646.             plugin->sampleRateChanged(newSampleRate);

  1647.     }

  1648. 

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

  1650. }

  1651. 

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

  1653. {

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

  1655. 

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

  1657.     {

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

  1659. 

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

  1661.             plugin->offlineModeChanged(isOffline);

  1662.     }

  1663. }

  1664. 

  1665. void CarlaEngine::runPendingRtEvents()

  1666. {

  1667.     pData->doNextPluginAction(true);

  1668. 

  1669.     if (pData->time.playing)

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

  1671. 

  1672.     if (fOptions.transportMode == TRANSPORT_MODE_INTERNAL)

  1673.     {

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

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

  1676.     }

  1677. }

  1678. 

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

  1680. {

  1681.     EnginePluginData& pluginData(pData->plugins[pluginId]);

  1682. 

  1683.     pluginData.insPeak[0]  = inPeaks[0];

  1684.     pluginData.insPeak[1]  = inPeaks[1];

  1685.     pluginData.outsPeak[0] = outPeaks[0];

  1686.     pluginData.outsPeak[1] = outPeaks[1];

  1687. }

  1688. 

  1689. #ifndef BUILD_BRIDGE

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

  1691. {

  1692.     CARLA_SAFE_ASSERT_RETURN(pData->bufEvents.in != nullptr,);

  1693.     CARLA_SAFE_ASSERT_RETURN(pData->bufEvents.out != nullptr,);

  1694. 

  1695.     // safe copy

  1696.     float inBuf0[frames];

  1697.     float inBuf1[frames];

  1698.     float* inBuf[2] = { inBuf0, inBuf1 };

  1699. 

  1700.     // initialize audio inputs

  1701.     FloatVectorOperations::copy(inBuf0, inBufReal[0], frames);

  1702.     FloatVectorOperations::copy(inBuf1, inBufReal[1], frames);

  1703. 

  1704.     // initialize audio outputs (zero)

  1705.     FloatVectorOperations::clear(outBuf[0], frames);

  1706.     FloatVectorOperations::clear(outBuf[1], frames);

  1707. 

  1708.     // initialize event outputs (zero)

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

  1710. 

  1711.     bool processed = false;

  1712. 

  1713.     uint32_t oldAudioInCount = 0;

  1714.     uint32_t oldMidiOutCount = 0;

  1715. 

  1716.     // process plugins

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

  1718.     {

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

  1720. 

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

  1722.             continue;

  1723. 

  1724.         if (processed)

  1725.         {

  1726.             // initialize audio inputs (from previous outputs)

  1727.             FloatVectorOperations::copy(inBuf0, outBuf[0], frames);

  1728.             FloatVectorOperations::copy(inBuf1, outBuf[1], frames);

  1729. 

  1730.             // initialize audio outputs (zero)

  1731.             FloatVectorOperations::clear(outBuf[0], frames);

  1732.             FloatVectorOperations::clear(outBuf[1], frames);

  1733. 

  1734.             // if plugin has no midi out, add previous events

  1735.             if (oldMidiOutCount == 0 && pData->bufEvents.in[0].type != kEngineEventTypeNull)

  1736.             {

  1737.                 if (pData->bufEvents.out[0].type != kEngineEventTypeNull)

  1738.                 {

  1739.                     // TODO: carefully add to input, sorted events

  1740.                 }

  1741.                 // else nothing needed

  1742.             }

  1743.             else

  1744.             {

  1745.                 // initialize event inputs from previous outputs

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

  1747. 

  1748.                 // initialize event outputs (zero)

  1749.                 std::memset(pData->bufEvents.out, 0, sizeof(EngineEvent)*kEngineMaxInternalEventCount);

  1750.             }

  1751.         }

  1752. 

  1753.         oldAudioInCount = plugin->getAudioInCount();

  1754.         oldMidiOutCount = plugin->getMidiOutCount();

  1755. 

  1756.         // process

  1757.         plugin->initBuffers();

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

  1759.         plugin->unlock();

  1760. 

  1761.         // if plugin has no audio inputs, add input buffer

  1762.         if (oldAudioInCount == 0)

  1763.         {

  1764.             FloatVectorOperations::add(outBuf[0], inBuf0, frames);

  1765.             FloatVectorOperations::add(outBuf[1], inBuf1, frames);

  1766.         }

  1767. 

  1768.         // set peaks

  1769.         {

  1770.             float tmpMin, tmpMax;

  1771.             EnginePluginData& pluginData(pData->plugins[i]);

  1772. 

  1773.             FloatVectorOperations::findMinAndMax(inBuf0, frames, tmpMin, tmpMax);

  1774.             pluginData.insPeak[0] = carla_max<float>(std::abs(tmpMin), std::abs(tmpMax), 1.0f);

  1775. 

  1776.             FloatVectorOperations::findMinAndMax(inBuf1, frames, tmpMin, tmpMax);

  1777.             pluginData.insPeak[1] = carla_max<float>(std::abs(tmpMin), std::abs(tmpMax), 1.0f);

  1778. 

  1779.             FloatVectorOperations::findMinAndMax(outBuf[0], frames, tmpMin, tmpMax);

  1780.             pluginData.outsPeak[0] = carla_max<float>(std::abs(tmpMin), std::abs(tmpMax), 1.0f);

  1781. 

  1782.             FloatVectorOperations::findMinAndMax(outBuf[1], frames, tmpMin, tmpMax);

  1783.             pluginData.outsPeak[1] = carla_max<float>(std::abs(tmpMin), std::abs(tmpMax), 1.0f);

  1784.         }

  1785. 

  1786.         processed = true;

  1787.     }

  1788. }

  1789. 

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

  1791. {

  1792.     // TODO

  1793.     return;

  1794. 

  1795.     // unused, for now

  1796.     (void)inBuf;

  1797.     (void)outBuf;

  1798.     (void)bufCount;

  1799.     (void)frames;

  1800. }

  1801. #endif

  1802. 

  1803. // -----------------------------------------------------------------------

  1804. // Bridge/Controller OSC stuff

  1805. 

  1806. #ifndef BUILD_BRIDGE

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

  1808. {

  1809.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  1810.     CARLA_SAFE_ASSERT_RETURN(pluginId >= 0 && pluginId < static_cast<int32_t>(pData->maxPluginNumber),);

  1811.     CARLA_SAFE_ASSERT_RETURN(pluginName != nullptr,);

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

  1813. 

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

  1815.     {

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

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

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

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

  1820.     }

  1821. }

  1822. 

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

  1824. {

  1825.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  1826.     CARLA_SAFE_ASSERT_RETURN(pluginId >= 0 && pluginId < static_cast<int32_t>(pData->maxPluginNumber),);

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

  1828. 

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

  1830.     {

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

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

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

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

  1835.     }

  1836. }

  1837. 

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

  1839. {

  1840.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  1841.     CARLA_SAFE_ASSERT_RETURN(pluginId >= 0 && pluginId < static_cast<int32_t>(pData->curPluginCount),);

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

  1843. 

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

  1845.     {

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

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

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

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

  1850.     }

  1851. }

  1852. 

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

  1854. {

  1855.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  1856.     CARLA_SAFE_ASSERT_RETURN(pluginId >= 0 && pluginId < static_cast<int32_t>(pData->maxPluginNumber),);

  1857.     CARLA_SAFE_ASSERT_RETURN(type != PLUGIN_NONE,);

  1858.     CARLA_SAFE_ASSERT_RETURN(realName != nullptr,);

  1859.     CARLA_SAFE_ASSERT_RETURN(label != nullptr,);

  1860.     CARLA_SAFE_ASSERT_RETURN(maker != nullptr,);

  1861.     CARLA_SAFE_ASSERT_RETURN(copyright != nullptr,);

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

  1863. 

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

  1865.     {

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

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

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

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

  1870.     }

  1871. }

  1872. 

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

  1874. {

  1875.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  1876.     CARLA_SAFE_ASSERT_RETURN(pluginId >= 0 && pluginId < static_cast<int32_t>(pData->maxPluginNumber),);

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

  1878. 

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

  1880.     {

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

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

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

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

  1885.     }

  1886. }

  1887. 

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

  1889. {

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

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

  1892.     CARLA_SAFE_ASSERT_RETURN(index >= 0,);

  1893.     CARLA_SAFE_ASSERT_RETURN(type != PARAMETER_UNKNOWN,);

  1894.     CARLA_SAFE_ASSERT_RETURN(name != nullptr,);

  1895.     CARLA_SAFE_ASSERT_RETURN(label != nullptr,);

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

  1897. 

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

  1899.     {

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

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

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

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

  1904.     }

  1905. }

  1906. 

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

  1908. {

  1909.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  1910.     CARLA_SAFE_ASSERT_RETURN(pluginId >= 0 && pluginId < static_cast<int32_t>(pData->maxPluginNumber),);

  1911.     CARLA_SAFE_ASSERT_RETURN(index >= 0,);

  1912.     CARLA_SAFE_ASSERT_RETURN(min < max,);

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

  1914. 

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

  1916.     {

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

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

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

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

  1921.     }

  1922. }

  1923. 

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

  1925. {

  1926.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  1927.     CARLA_SAFE_ASSERT_RETURN(pluginId >= 0 && pluginId < static_cast<int32_t>(pData->maxPluginNumber),);

  1928.     CARLA_SAFE_ASSERT_RETURN(index >= 0,);

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

  1930. 

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

  1932.     {

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

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

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

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

  1937.     }

  1938. }

  1939. 

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

  1941. {

  1942.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  1943.     CARLA_SAFE_ASSERT_RETURN(pluginId >= 0 && pluginId < static_cast<int32_t>(pData->maxPluginNumber),);

  1944.     CARLA_SAFE_ASSERT_RETURN(index >= 0,);

  1945.     CARLA_SAFE_ASSERT_RETURN(channel >= 0 && channel < MAX_MIDI_CHANNELS,);

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

  1947. 

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

  1949.     {

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

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

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

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

  1954.     }

  1955. }

  1956. 

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

  1958. {

  1959.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  1960.     CARLA_SAFE_ASSERT_RETURN(pluginId >= 0 && pluginId < static_cast<int32_t>(pData->maxPluginNumber),);

  1961.     carla_debug("CarlaEngine::oscSend_control_set_parameter_value(%i, %i:%s, %f)", pluginId, index, (index < 0) ? InternalParametersIndex2Str(static_cast<InternalParametersIndex>(index)) : "(none)", value);

  1962. 

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

  1964.     {

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

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

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

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

  1969.     }

  1970. }

  1971. 

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

  1973. {

  1974.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  1975.     CARLA_SAFE_ASSERT_RETURN(pluginId >= 0 && pluginId < static_cast<int32_t>(pData->maxPluginNumber),);

  1976.     CARLA_SAFE_ASSERT_RETURN(index >= 0,);

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

  1978. 

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

  1980.     {

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

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

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

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

  1985.     }

  1986. }

  1987. 

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

  1989. {

  1990.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  1991.     CARLA_SAFE_ASSERT_RETURN(pluginId >= 0 && pluginId < static_cast<int32_t>(pData->maxPluginNumber),);

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

  1993. 

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

  1995.     {

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

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

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

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

  2000.     }

  2001. }

  2002. 

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

  2004. {

  2005.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  2006.     CARLA_SAFE_ASSERT_RETURN(pluginId >= 0 && pluginId < static_cast<int32_t>(pData->maxPluginNumber),);

  2007.     CARLA_SAFE_ASSERT_RETURN(count >= 0,);

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

  2009. 

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

  2011.     {

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

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

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

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

  2016.     }

  2017. }

  2018. 

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

  2020. {

  2021.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  2022.     CARLA_SAFE_ASSERT_RETURN(pluginId >= 0 && pluginId < static_cast<int32_t>(pData->maxPluginNumber),);

  2023.     CARLA_SAFE_ASSERT_RETURN(index >= 0,);

  2024.     CARLA_SAFE_ASSERT_RETURN(name != nullptr,);

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

  2026. 

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

  2028.     {

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

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

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

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

  2033.     }

  2034. }

  2035. 

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

  2037. {

  2038.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  2039.     CARLA_SAFE_ASSERT_RETURN(pluginId >= 0 && pluginId < static_cast<int32_t>(pData->maxPluginNumber),);

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

  2041. 

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

  2043.     {

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

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

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

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

  2048.     }

  2049. }

  2050. 

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

  2052. {

  2053.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  2054.     CARLA_SAFE_ASSERT_RETURN(pluginId >= 0 && pluginId < static_cast<int32_t>(pData->maxPluginNumber),);

  2055.     CARLA_SAFE_ASSERT_RETURN(count >= 0,);

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

  2057. 

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

  2059.     {

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

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

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

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

  2064.     }

  2065. }

  2066. 

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

  2068. {

  2069.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  2070.     CARLA_SAFE_ASSERT_RETURN(pluginId >= 0 && pluginId < static_cast<int32_t>(pData->maxPluginNumber),);

  2071.     CARLA_SAFE_ASSERT_RETURN(index >= 0,);

  2072.     CARLA_SAFE_ASSERT_RETURN(bank >= 0,);

  2073.     CARLA_SAFE_ASSERT_RETURN(program >= 0,);

  2074.     CARLA_SAFE_ASSERT_RETURN(name != nullptr,);

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

  2076. 

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

  2078.     {

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

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

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

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

  2083.     }

  2084. }

  2085. 

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

  2087. {

  2088.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  2089.     CARLA_SAFE_ASSERT_RETURN(pluginId >= 0 && pluginId < static_cast<int32_t>(pData->curPluginCount),);

  2090.     CARLA_SAFE_ASSERT_RETURN(channel >= 0 && channel < MAX_MIDI_CHANNELS,);

  2091.     CARLA_SAFE_ASSERT_RETURN(note >= 0 && note < MAX_MIDI_NOTE,);

  2092.     CARLA_SAFE_ASSERT_RETURN(velo > 0 && velo < MAX_MIDI_VALUE,);

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

  2094. 

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

  2096.     {

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

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

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

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

  2101.     }

  2102. }

  2103. 

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

  2105. {

  2106.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  2107.     CARLA_SAFE_ASSERT_RETURN(pluginId >= 0 && pluginId < static_cast<int32_t>(pData->curPluginCount),);

  2108.     CARLA_SAFE_ASSERT_RETURN(channel >= 0 && channel < MAX_MIDI_CHANNELS,);

  2109.     CARLA_SAFE_ASSERT_RETURN(note >= 0 && note < MAX_MIDI_NOTE,);

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

  2111. 

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

  2113.     {

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

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

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

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

  2118.     }

  2119. }

  2120. 

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

  2122. {

  2123.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  2124.     CARLA_SAFE_ASSERT_RETURN(pluginId >= 0 && pluginId < static_cast<int32_t>(pData->curPluginCount),);

  2125. 

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

  2127. 

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

  2129.     {

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

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

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

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

  2134.     }

  2135. }

  2136. 

  2137. void CarlaEngine::oscSend_control_exit()

  2138. {

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

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

  2141. 

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

  2143.     {

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

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

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

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

  2148.     }

  2149. }

  2150. #else

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

  2152. {

  2153.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  2154.     CARLA_SAFE_ASSERT_RETURN(total >= 0 && total >= ins + outs,);

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

  2156. 

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

  2158.     {

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

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

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

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

  2163.     }

  2164. }

  2165. 

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

  2167. {

  2168.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  2169.     CARLA_SAFE_ASSERT_RETURN(total >= 0 && total >= ins + outs,);

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

  2171. 

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

  2173.     {

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

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

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

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

  2178.     }

  2179. }

  2180. 

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

  2182. {

  2183.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  2184.     CARLA_SAFE_ASSERT_RETURN(total >= 0 && total >= ins + outs,);

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

  2186. 

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

  2188.     {

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

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

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

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

  2193.     }

  2194. }

  2195. 

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

  2197. {

  2198.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  2199.     CARLA_SAFE_ASSERT_RETURN(count >= 0,);

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

  2201. 

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

  2203.     {

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

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

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

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

  2208.     }

  2209. }

  2210. 

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

  2212. {

  2213.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  2214.     CARLA_SAFE_ASSERT_RETURN(count >= 0,);

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

  2216. 

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

  2218.     {

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

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

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

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

  2223.     }

  2224. }

  2225. 

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

  2227. {

  2228.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  2229.     CARLA_SAFE_ASSERT_RETURN(name != nullptr,);

  2230.     CARLA_SAFE_ASSERT_RETURN(label != nullptr,);

  2231.     CARLA_SAFE_ASSERT_RETURN(maker != nullptr,);

  2232.     CARLA_SAFE_ASSERT_RETURN(copyright != nullptr,);

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

  2234. 

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

  2236.     {

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

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

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

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

  2241.     }

  2242. }

  2243. 

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

  2245. {

  2246.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  2247.     CARLA_SAFE_ASSERT_RETURN(name != nullptr,);

  2248.     CARLA_SAFE_ASSERT_RETURN(unit != nullptr,);

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

  2250. 

  2251.     if (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_info");

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

  2257.     }

  2258. }

  2259. 

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

  2261. {

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

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

  2264. 

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

  2266.     {

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

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

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

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

  2271.     }

  2272. }

  2273. 

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

  2275. {

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

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

  2278. 

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

  2280.     {

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

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

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

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

  2285.     }

  2286. }

  2287. 

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

  2289. {

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

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

  2292. 

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

  2294.     {

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

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

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

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

  2299.     }

  2300. }

  2301. 

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

  2303. {

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

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

  2306. 

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

  2308.     {

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

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

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

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

  2313.     }

  2314. }

  2315. 

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

  2317. {

  2318.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

  2319.     CARLA_SAFE_ASSERT_RETURN(key != nullptr,);

  2320.     CARLA_SAFE_ASSERT_RETURN(value != nullptr,);

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

  2322. 

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

  2324.     {

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

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

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

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

  2329.     }

  2330. }

  2331. 

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

  2333. {

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

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

  2336. 

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

  2338.     {

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

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

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

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

  2343.     }

  2344. }

  2345. 

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

  2347. {

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

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

  2350. 

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

  2352.     {

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

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

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

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

  2357.     }

  2358. }

  2359. 

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

  2361. {

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

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

  2364. 

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

  2366.     {

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

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

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

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

  2371.     }

  2372. }

  2373. 

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

  2375. {

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

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

  2378. 

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

  2380.     {

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

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

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

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

  2385.     }

  2386. }

  2387. 

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

  2389. {

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

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

  2392. 

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

  2394.     {

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

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

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

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

  2399.     }

  2400. }

  2401. 

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

  2403. {

  2404.     CARLA_SAFE_ASSERT_RETURN(pData->oscData != nullptr,);

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

  2406. 

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

  2408.     {

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

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

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

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

  2413.     }

  2414. }

  2415. #endif

  2416. 

  2417. // -----------------------------------------------------------------------

  2418. 

  2419. #undef CARLA_SAFE_ASSERT_RETURN_ERR

  2420. 

  2421. CARLA_BACKEND_END_NAMESPACE