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

2433 lines
79KB
Raw Blame History 

  1. /*

  2.  * Carla Engine

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

  4.  *

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

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

  7.  * published by the Free Software Foundation; either version 2 of

  8.  * the License, or any later version.

  9.  *

  10.  * This program is distributed in the hope that it will be useful,

  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

  13.  * GNU General Public License for more details.

  14.  *

  15.  * For a full copy of the GNU General Public License see the doc/GPL.txt file.

  16.  */

  17. 

  18. #include "CarlaEngineInternal.hpp"

  19. #include "CarlaBackendUtils.hpp"

  20. #include "CarlaStateUtils.hpp"

  21. #include "CarlaMIDI.h"

  22. 

  23. #include <cmath>

  24. 

  25. CARLA_BACKEND_START_NAMESPACE

  26. 

  27. #if 0

  28. } // Fix editor indentation

  29. #endif

  30. 

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

  32. // Fallback data

  33. 

  34. static const EngineEvent kFallbackEngineEvent;

  35. 

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

  37. // Carla Engine port (Abstract)

  38. 

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

  40.     : fEngine(engine),

  41.       fIsInput(isInput)

  42. {

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

  44. }

  45. 

  46. CarlaEnginePort::~CarlaEnginePort()

  47. {

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

  49. }

  50. 

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

  52. // Carla Engine Audio port

  53. 

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

  55.     : CarlaEnginePort(engine, isInput),

  56.       fBuffer(nullptr)

  57. {

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

  59. }

  60. 

  61. CarlaEngineAudioPort::~CarlaEngineAudioPort()

  62. {

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

  64. }

  65. 

  66. void CarlaEngineAudioPort::initBuffer()

  67. {

  68. }

  69. 

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

  71. // Carla Engine CV port

  72. 

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

  74.     : CarlaEnginePort(engine, isInput),

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

  76. {

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

  78. }

  79. 

  80. CarlaEngineCVPort::~CarlaEngineCVPort()

  81. {

  82.     CARLA_SAFE_ASSERT_RETURN(fBuffer != nullptr,);

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

  84. 

  85.     delete[] fBuffer;

  86.     fBuffer = nullptr;

  87. }

  88. 

  89. void CarlaEngineCVPort::initBuffer()

  90. {

  91.     CARLA_SAFE_ASSERT_RETURN(fBuffer != nullptr,);

  92. 

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

  94. }

  95. 

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

  97. {

  98.     CARLA_ASSERT(! fIsInput);

  99. }

  100. 

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

  102. {

  103.     if (fBuffer != nullptr)

  104.         delete[] fBuffer;

  105. 

  106.     fBuffer = new float[bufferSize];

  107. }

  108. 

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

  110. // Carla Engine Event port

  111. 

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

  113.     : CarlaEnginePort(engine, isInput),

  114.       fBuffer(nullptr)

  115. {

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

  117. 

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

  119.         fBuffer = new EngineEvent[kEngineMaxInternalEventCount];

  120. }

  121. 

  122. CarlaEngineEventPort::~CarlaEngineEventPort()

  123. {

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

  125. 

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

  127.     {

  128.         CARLA_SAFE_ASSERT_RETURN(fBuffer != nullptr,);

  129. 

  130.         delete[] fBuffer;

  131.         fBuffer = nullptr;

  132.     }

  133. }

  134. 

  135. void CarlaEngineEventPort::initBuffer()

  136. {

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

  138.         fBuffer = fEngine.getInternalEventBuffer(fIsInput);

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

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

  141. }

  142. 

  143. uint32_t CarlaEngineEventPort::getEventCount() const

  144. {

  145.     CARLA_SAFE_ASSERT_RETURN(fIsInput, 0);

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

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

  148. 

  149.     uint32_t i=0;

  150. 

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

  152.     {

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

  154.             break;

  155.     }

  156. 

  157.     return i;

  158. }

  159. 

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

  161. {

  162.     CARLA_SAFE_ASSERT_RETURN(fIsInput, kFallbackEngineEvent);

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

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

  165.     CARLA_SAFE_ASSERT_RETURN(index < kEngineMaxInternalEventCount, kFallbackEngineEvent);

  166. 

  167.     return fBuffer[index];

  168. }

  169. 

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

  171. {

  172.     return fBuffer[index];

  173. }

  174. 

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

  176. {

  177.     CARLA_SAFE_ASSERT_RETURN(! fIsInput,);

  178.     CARLA_SAFE_ASSERT_RETURN(fBuffer != nullptr,);

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

  180.     CARLA_SAFE_ASSERT_RETURN(type != kEngineControlEventTypeNull,);

  181.     CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

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

  183. 

  184.     if (type == kEngineControlEventTypeParameter)

  185.     {

  186.         CARLA_ASSERT(! MIDI_IS_CONTROL_BANK_SELECT(param));

  187.     }

  188. 

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

  190. 

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

  192.     {

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

  194.             continue;

  195. 

  196.         fBuffer[i].type    = kEngineEventTypeControl;

  197.         fBuffer[i].time    = time;

  198.         fBuffer[i].channel = channel;

  199. 

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

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

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

  203. 

  204.         return;

  205.     }

  206. 

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

  208. }

  209. 

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

  211. {

  212.     CARLA_SAFE_ASSERT_RETURN(! fIsInput,);

  213.     CARLA_SAFE_ASSERT_RETURN(fBuffer != nullptr,);

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

  215.     CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

  216.     CARLA_SAFE_ASSERT_RETURN(data != nullptr,);

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

  218. 

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

  220.     {

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

  222.             continue;

  223. 

  224.         fBuffer[i].type    = kEngineEventTypeMidi;

  225.         fBuffer[i].time    = time;

  226.         fBuffer[i].channel = channel;

  227. 

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

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

  230. 

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

  232. 

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

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

  235. 

  236.         return;

  237.     }

  238. 

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

  240. }

  241. 

  242. // -----------------------------------------------------------------------

  243. // Carla Engine client (Abstract)

  244. 

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

  246.     : fEngine(engine),

  247.       fActive(false),

  248.       fLatency(0)

  249. {

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

  251. }

  252. 

  253. CarlaEngineClient::~CarlaEngineClient()

  254. {

  255.     CARLA_ASSERT(! fActive);

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

  257. }

  258. 

  259. void CarlaEngineClient::activate()

  260. {

  261.     CARLA_ASSERT(! fActive);

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

  263. 

  264.     fActive = true;

  265. }

  266. 

  267. void CarlaEngineClient::deactivate()

  268. {

  269.     CARLA_ASSERT(fActive);

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

  271. 

  272.     fActive = false;

  273. }

  274. 

  275. bool CarlaEngineClient::isActive() const

  276. {

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

  278. 

  279.     return fActive;

  280. }

  281. 

  282. bool CarlaEngineClient::isOk() const

  283. {

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

  285. 

  286.     return true;

  287. }

  288. 

  289. uint32_t CarlaEngineClient::getLatency() const

  290. {

  291.     return fLatency;

  292. }

  293. 

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

  295. {

  296.     fLatency = samples;

  297. }

  298. 

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

  300. {

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

  302. 

  303.     switch (portType)

  304.     {

  305.     case kEnginePortTypeNull:

  306.         break;

  307.     case kEnginePortTypeAudio:

  308.         return new CarlaEngineAudioPort(fEngine, isInput);

  309.     case kEnginePortTypeCV:

  310.         return new CarlaEngineCVPort(fEngine, isInput);

  311.     case kEnginePortTypeEvent:

  312.         return new CarlaEngineEventPort(fEngine, isInput);

  313.     case kEnginePortTypeOSC:

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

  315.     }

  316. 

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

  318.     return nullptr;

  319. }

  320. 

  321. // -----------------------------------------------------------------------

  322. // Carla Engine

  323. 

  324. CarlaEngine::CarlaEngine()

  325.     : fBufferSize(0),

  326.       fSampleRate(0.0),

  327.       pData(new CarlaEngineProtectedData(this))

  328. {

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

  330. }

  331. 

  332. CarlaEngine::~CarlaEngine()

  333. {

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

  335. 

  336.     delete pData;

  337. }

  338. 

  339. // -----------------------------------------------------------------------

  340. // Static values and calls

  341. 

  342. unsigned int CarlaEngine::getDriverCount()

  343. {

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

  345. 

  346.     unsigned int count = 1; // JACK

  347. 

  348. #ifndef BUILD_BRIDGE

  349.     count += getRtAudioApiCount();

  350.     count += getJuceApiCount();

  351. #endif

  352. 

  353.     return count;

  354. }

  355. 

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

  357. {

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

  359. 

  360.     if (index == 0)

  361.         return "JACK";

  362. 

  363. #ifndef BUILD_BRIDGE

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

  365. 

  366.     if (rtAudioIndex < getRtAudioApiCount())

  367.         return getRtAudioApiName(rtAudioIndex);

  368. 

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

  370. 

  371.     if (juceIndex < getJuceApiCount())

  372.         return getJuceApiName(juceIndex);

  373. #endif

  374. 

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

  376.     return nullptr;

  377. }

  378. 

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

  380. {

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

  382. 

  383.     if (index == 0)

  384.     {

  385.         //static const char* const strOff = "Auto-connect OFF";

  386.         //static const char* const strOn  = "Auto-connect ON";

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

  388.         return ret;

  389.     }

  390. 

  391. #ifndef BUILD_BRIDGE

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

  393. 

  394.     if (rtAudioIndex < getRtAudioApiCount())

  395.         return getRtAudioApiDeviceNames(rtAudioIndex);

  396. 

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

  398. 

  399.     if (juceIndex < getJuceApiCount())

  400.         return getJuceApiDeviceNames(juceIndex);

  401. #endif

  402. 

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

  404.     return nullptr;

  405. }

  406. 

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

  408. {

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

  410. 

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

  412.         return newJack();

  413. 

  414. #ifdef __LINUX_ALSA__

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

  416.         return newRtAudio(RTAUDIO_LINUX_ALSA);

  417. #endif

  418. #ifdef __LINUX_PULSE__

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

  420.         return newRtAudio(RTAUDIO_LINUX_PULSE);

  421. #endif

  422. #ifdef __LINUX_OSS__

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

  424.         return newRtAudio(RTAUDIO_LINUX_OSS);

  425. #endif

  426. #ifdef __UNIX_JACK__

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

  428.         return newRtAudio(RTAUDIO_UNIX_JACK);

  429. #endif

  430. #ifdef __MACOSX_CORE__

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

  432.         return newRtAudio(RTAUDIO_MACOSX_CORE);

  433. #endif

  434. #ifdef __WINDOWS_ASIO__

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

  436.         return newRtAudio(RTAUDIO_WINDOWS_ASIO);

  437. #endif

  438. #ifdef __WINDOWS_DS__

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

  440.         return newRtAudio(RTAUDIO_WINDOWS_DS);

  441. #endif

  442. 

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

  444.     return nullptr;

  445. }

  446. 

  447. // -----------------------------------------------------------------------

  448. // Maximum values

  449. 

  450. unsigned int CarlaEngine::getMaxClientNameSize() const

  451. {

  452.     return STR_MAX/2;

  453. }

  454. 

  455. unsigned int CarlaEngine::getMaxPortNameSize() const

  456. {

  457.     return STR_MAX;

  458. }

  459. 

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

  461. {

  462.     return pData->curPluginCount;

  463. }

  464. 

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

  466. {

  467.     return pData->maxPluginNumber;

  468. }

  469. 

  470. // -----------------------------------------------------------------------

  471. // Virtual, per-engine type calls

  472. 

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

  474. {

  475.     CARLA_ASSERT(fName.isEmpty());

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

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

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

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

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

  481. 

  482.     pData->aboutToClose = false;

  483.     pData->curPluginCount = 0;

  484.     pData->maxPluginNumber = 0;

  485.     pData->nextPluginId = 0;

  486. 

  487.     switch (fOptions.processMode)

  488.     {

  489.     case PROCESS_MODE_SINGLE_CLIENT:

  490.     case PROCESS_MODE_MULTIPLE_CLIENTS:

  491.         pData->maxPluginNumber = MAX_DEFAULT_PLUGINS;

  492.         break;

  493. 

  494.     case PROCESS_MODE_CONTINUOUS_RACK:

  495.         pData->maxPluginNumber = MAX_RACK_PLUGINS;

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

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

  498.         break;

  499. 

  500.     case PROCESS_MODE_PATCHBAY:

  501.         pData->maxPluginNumber = MAX_PATCHBAY_PLUGINS;

  502.         break;

  503. 

  504.     case PROCESS_MODE_BRIDGE:

  505.         pData->maxPluginNumber = 1;

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

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

  508.         break;

  509.     }

  510. 

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

  512.         return false;

  513. 

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

  515. 

  516.     fName = clientName;

  517.     fName.toBasic();

  518. 

  519.     fTimeInfo.clear();

  520. 

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

  522. 

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

  524. #ifndef BUILD_BRIDGE

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

  526. #endif

  527. 

  528.     pData->nextAction.ready();

  529.     pData->thread.startThread();

  530. 

  531.     return true;

  532. }

  533. 

  534. bool CarlaEngine::close()

  535. {

  536.     CARLA_ASSERT(fName.isNotEmpty());

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

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

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

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

  541. 

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

  543.     pData->nextAction.ready();

  544. 

  545. #ifndef BUILD_BRIDGE

  546.     oscSend_control_exit();

  547. #endif

  548.     pData->osc.close();

  549.     pData->oscData = nullptr;

  550. 

  551.     pData->aboutToClose = true;

  552.     pData->curPluginCount = 0;

  553.     pData->maxPluginNumber = 0;

  554.     pData->nextPluginId = 0;

  555. 

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

  557.     {

  558.         delete[] pData->plugins;

  559.         pData->plugins = nullptr;

  560.     }

  561. 

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

  563.     {

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

  565.         pData->bufEvents.in = nullptr;

  566.     }

  567. 

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

  569.     {

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

  571.         pData->bufEvents.out = nullptr;

  572.     }

  573. 

  574.     fName.clear();

  575. 

  576.     return true;

  577. }

  578. 

  579. void CarlaEngine::idle()

  580. {

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

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

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

  584. 

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

  586.     {

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

  588. 

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

  590.             plugin->idleGui();

  591.     }

  592. }

  593. 

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

  595. {

  596.     return new CarlaEngineClient(*this);

  597. }

  598. 

  599. // -----------------------------------------------------------------------

  600. // Plugin management

  601. 

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

  603. {

  604.     CARLA_ASSERT(btype != BINARY_NONE);

  605.     CARLA_ASSERT(ptype != PLUGIN_NONE);

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

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

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

  609. 

  610.     unsigned int id;

  611.     CarlaPlugin* oldPlugin = nullptr;

  612. 

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

  614.     {

  615.         id = pData->nextPluginId;

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

  617. 

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

  619.         CARLA_ASSERT(oldPlugin != nullptr);

  620.     }

  621.     else

  622.     {

  623.         id = pData->curPluginCount;

  624. 

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

  626.         {

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

  628.             return false;

  629.         }

  630. 

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

  632.     }

  633. 

  634.     CarlaPlugin::Initializer init = {

  635.         this,

  636.         id,

  637.         filename,

  638.         name,

  639.         label

  640.     };

  641. 

  642.     CarlaPlugin* plugin = nullptr;

  643. 

  644. #ifndef BUILD_BRIDGE

  645.     const char* bridgeBinary;

  646. 

  647.     switch (btype)

  648.     {

  649.     case BINARY_POSIX32:

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

  651.         break;

  652.     case BINARY_POSIX64:

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

  654.         break;

  655.     case BINARY_WIN32:

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

  657.         break;

  658.     case BINARY_WIN64:

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

  660.         break;

  661.     default:

  662.         bridgeBinary = nullptr;

  663.         break;

  664.     }

  665. 

  666. # ifndef Q_OS_WIN

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

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

  669. # endif

  670. 

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

  672.     {

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

  674.     }

  675.     else

  676. #endif // BUILD_BRIDGE

  677.     {

  678.         switch (ptype)

  679.         {

  680.         case PLUGIN_NONE:

  681.             break;

  682. 

  683.         case PLUGIN_INTERNAL:

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

  685.             break;

  686. 

  687.         case PLUGIN_LADSPA:

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

  689.             break;

  690. 

  691.         case PLUGIN_DSSI:

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

  693.             break;

  694. 

  695.         case PLUGIN_LV2:

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

  697.             break;

  698. 

  699.         case PLUGIN_VST:

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

  701.             break;

  702. 

  703.         case PLUGIN_AU:

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

  705.             break;

  706. 

  707.         case PLUGIN_CSOUND:

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

  709.             break;

  710. 

  711.         case PLUGIN_GIG:

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

  713.             break;

  714. 

  715.         case PLUGIN_SF2:

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

  717.             break;

  718. 

  719.         case PLUGIN_SFZ:

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

  721.             break;

  722.         }

  723.     }

  724. 

  725.     if (plugin == nullptr)

  726.         return false;

  727. 

  728.     plugin->registerToOscClient();

  729. 

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

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

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

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

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

  735. 

  736.     if (oldPlugin != nullptr)

  737.     {

  738.         delete oldPlugin;

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

  740.     }

  741.     else

  742.     {

  743.         ++pData->curPluginCount;

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

  745.     }

  746. 

  747.     return true;

  748. }

  749. 

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

  751. {

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

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

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

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

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

  757. 

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

  759.     {

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

  761.         return false;

  762.     }

  763. 

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

  765. 

  766.     if (plugin == nullptr)

  767.     {

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

  769.         return false;

  770.     }

  771. 

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

  773. 

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

  775. 

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

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

  778. 

  779. #ifndef BUILD_BRIDGE

  780.     if (isOscControlRegistered())

  781.         oscSend_control_remove_plugin(id);

  782. #endif

  783. 

  784.     delete plugin;

  785. 

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

  787.         pData->thread.startThread();

  788. 

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

  790.     return true;

  791. }

  792. 

  793. void CarlaEngine::removeAllPlugins()

  794. {

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

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

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

  798. 

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

  800.         return;

  801. 

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

  803. 

  804.     const bool lockWait(isRunning());

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

  806. 

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

  808.     {

  809.         if (CarlaPlugin* const plugin = pData->plugins[i].plugin)

  810.         {

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

  812.             delete plugin;

  813.         }

  814. 

  815.         // clear this plugin

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

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

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

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

  820.     }

  821. 

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

  823.         pData->thread.startThread();

  824. 

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

  826. }

  827. 

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

  829. {

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

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

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

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

  834.     CARLA_ASSERT(newName != nullptr);

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

  836. 

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

  838.     {

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

  840.         return nullptr;

  841.     }

  842. 

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

  844. 

  845.     if (plugin == nullptr)

  846.     {

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

  848.         return nullptr;

  849.     }

  850. 

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

  852. 

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

  854.     {

  855.         plugin->setName(name);

  856.         return name;

  857.     }

  858. 

  859.     return nullptr;

  860. }

  861. 

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

  863. {

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

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

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

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

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

  869. 

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

  871.     {

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

  873.         return false;

  874.     }

  875. 

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

  877. 

  878.     if (plugin == nullptr)

  879.     {

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

  881.         return false;

  882.     }

  883. 

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

  885. 

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

  887.     plugin->getLabel(label);

  888. 

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

  890. 

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

  892.         return false;

  893. 

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

  895. 

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

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

  898. 

  899.     return true;

  900. }

  901. 

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

  903. {

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

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

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

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

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

  909. 

  910.     if (id < pData->curPluginCount)

  911.         pData->nextPluginId = id;

  912. 

  913.     return false;

  914. }

  915. 

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

  917. {

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

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

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

  921.     CARLA_ASSERT(idA != idB);

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

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

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

  925. 

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

  927.     {

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

  929.         return false;

  930.     }

  931. 

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

  933. 

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

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

  936. 

  937. #ifndef BUILD_BRIDGE // TODO

  938.     //if (isOscControlRegistered())

  939.     //    oscSend_control_switch_plugins(idA, idB);

  940. #endif

  941. 

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

  943.         pData->thread.startThread();

  944. 

  945.     return true;

  946. }

  947. 

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

  949. {

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

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

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

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

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

  955. 

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

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

  958. 

  959.     return nullptr;

  960. }

  961. 

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

  963. {

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

  965. }

  966. 

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

  968. {

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

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

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

  972.     CARLA_ASSERT(name != nullptr);

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

  974. 

  975.     //static CarlaMutex m;

  976.     //const CarlaMutex::ScopedLocker sl(m);

  977. 

  978.     static CarlaString sname;

  979.     sname = name;

  980. 

  981.     if (sname.isEmpty())

  982.     {

  983.         sname = "(No name)";

  984.         return (const char*)sname;

  985.     }

  986. 

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

  988.         return (const char*)sname;

  989. 

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

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

  992. 

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

  994.     {

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

  996. 

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

  998.             break;

  999. 

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

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

  1002.         {

  1003.             if (sname != pluginName)

  1004.                 continue;

  1005.         }

  1006. 

  1007.         // Check if string has already been modified

  1008.         {

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

  1010. 

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

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

  1013.             {

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

  1015. 

  1016.                 if (number == 9)

  1017.                 {

  1018.                     // next number is 10, 2 digits

  1019.                     sname.truncate(len-4);

  1020.                     sname += " (10)";

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

  1022.                 }

  1023.                 else

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

  1025. 

  1026.                 continue;

  1027.             }

  1028. 

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

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

  1031.             {

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

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

  1034. 

  1035.                 if (n2 == '9')

  1036.                 {

  1037.                     n2  = '0';

  1038.                     n3 += 1;

  1039.                 }

  1040.                 else

  1041.                     n2 += 1;

  1042. 

  1043.                 sname[len-2] = n2;

  1044.                 sname[len-3] = n3;

  1045. 

  1046.                 continue;

  1047.             }

  1048.         }

  1049. 

  1050.         // Modify string if not

  1051.         sname += " (2)";

  1052.     }

  1053. 

  1054.     return (const char*)sname;

  1055. }

  1056. 

  1057. // -----------------------------------------------------------------------

  1058. // Project management

  1059. 

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

  1061. {

  1062.     CARLA_ASSERT(filename != nullptr && filename[0] != '\0');

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

  1064. 

  1065.     using namespace juce;

  1066. 

  1067.     File file(filename);

  1068. 

  1069.     if (! file.existsAsFile())

  1070.     {

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

  1072.         return false;

  1073.     }

  1074. 

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

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

  1077.     extension.toLower();

  1078. 

  1079.     carla_stdout("loadFilename with extension %s", (const char*)extension);

  1080. 

  1081.     // -------------------------------------------------------------------

  1082. 

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

  1084.         return loadProject(filename);

  1085. 

  1086.     // -------------------------------------------------------------------

  1087. 

  1088.     if (extension == "gig")

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

  1090. 

  1091.     if (extension == "sf2")

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

  1093. 

  1094.     if (extension == "sfz")

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

  1096. 

  1097.     // -------------------------------------------------------------------

  1098. 

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

  1100.     {

  1101. #ifdef WANT_AUDIOFILE

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

  1103.         {

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

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

  1106.             return true;

  1107.         }

  1108.         return false;

  1109. #else

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

  1111.         return false;

  1112. #endif

  1113.     }

  1114. 

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

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

  1117.     {

  1118. #ifdef WANT_AUDIOFILE

  1119. # ifdef HAVE_FFMPEG

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

  1121.         {

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

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

  1124.             return true;

  1125.         }

  1126.         return false;

  1127. # else

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

  1129.         return false;

  1130. # endif

  1131. #else

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

  1133.         return false;

  1134. #endif

  1135.     }

  1136. 

  1137.     // -------------------------------------------------------------------

  1138. 

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

  1140.     {

  1141. #ifdef WANT_MIDIFILE

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

  1143.         {

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

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

  1146.             return true;

  1147.         }

  1148.         return false;

  1149. #else

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

  1151.         return false;

  1152. #endif

  1153.     }

  1154. 

  1155.     // -------------------------------------------------------------------

  1156.     // ZynAddSubFX

  1157. 

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

  1159.     {

  1160. #ifdef WANT_ZYNADDSUBFX

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

  1162.         {

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

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

  1165.             return true;

  1166.         }

  1167.         return false;

  1168. #else

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

  1170.         return false;

  1171. #endif

  1172.     }

  1173. 

  1174.     // -------------------------------------------------------------------

  1175. 

  1176.     setLastError("Unknown file extension");

  1177.     return false;

  1178. }

  1179. 

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

  1181. {

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

  1183.         return false;

  1184. 

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

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

  1187. 

  1188.     if (strLen < suffixLen)

  1189.         return false;

  1190. 

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

  1192. }

  1193. 

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

  1195. {

  1196.     CARLA_ASSERT(filename != nullptr && filename[0] != '\0');

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

  1198. 

  1199.     using namespace juce;

  1200. 

  1201.     File file(filename);

  1202. 

  1203.     XmlDocument xml(file);

  1204. 

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

  1206.     {

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

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

  1209. 

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

  1211.         {

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

  1213.             {

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

  1215.                 {

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

  1217.                     {

  1218.                         SaveState saveState;

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

  1220. 

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

  1222. 

  1223.                         const void* extraStuff = nullptr;

  1224. 

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

  1226.                         {

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

  1228. 

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

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

  1231.                         }

  1232. 

  1233.                         // TODO - proper find&load plugins

  1234. 

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

  1236.                         {

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

  1238.                                 plugin->loadSaveState(saveState);

  1239.                         }

  1240.                     }

  1241. 

  1242.                     if (isPreset)

  1243.                         break;

  1244.                 }

  1245. 

  1246.                 delete xmlElem;

  1247.                 delete xmlCheck;

  1248.                 return true;

  1249.             }

  1250.             else

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

  1252.         }

  1253.         else

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

  1255. 

  1256.         delete xmlCheck;

  1257.         return false;

  1258.     }

  1259. 

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

  1261.     return false;

  1262. }

  1263. 

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

  1265. {

  1266.     CARLA_ASSERT(filename != nullptr && filename[0] != '\0');

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

  1268. 

  1269.     using namespace juce;

  1270. 

  1271.     File file(filename);

  1272. 

  1273.     MemoryOutputStream out;

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

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

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

  1277. 

  1278.     bool firstPlugin = true;

  1279.     char strBuf[STR_MAX+1];

  1280. 

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

  1282.     {

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

  1284. 

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

  1286.         {

  1287.             if (! firstPlugin)

  1288.                 out << "\n";

  1289. 

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

  1291. 

  1292.             plugin->getRealName(strBuf);

  1293. 

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

  1295.             {

  1296.                 out << " <!-- ";

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

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

  1299.             }

  1300. 

  1301.             String content;

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

  1303. 

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

  1305.             out << content;

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

  1307. 

  1308.             firstPlugin = false;

  1309.         }

  1310.     }

  1311. 

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

  1313. 

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

  1315. }

  1316. 

  1317. // -----------------------------------------------------------------------

  1318. // Information (peaks)

  1319. 

  1320. // FIXME

  1321. 

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

  1323. {

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

  1325.     CARLA_ASSERT(id-1 < 2);

  1326. 

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

  1328.         return 0.0f;

  1329. 

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

  1331. }

  1332. 

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

  1334. {

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

  1336.     CARLA_ASSERT(id-1 < 2);

  1337. 

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

  1339.         return 0.0f;

  1340. 

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

  1342. }

  1343. 

  1344. // -----------------------------------------------------------------------

  1345. // Callback

  1346. 

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

  1348. {

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

  1350. 

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

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

  1353. }

  1354. 

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

  1356. {

  1357.     CARLA_ASSERT(func != nullptr);

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

  1359. 

  1360.     pData->callback    = func;

  1361.     pData->callbackPtr = ptr;

  1362. }

  1363. 

  1364. // -----------------------------------------------------------------------

  1365. // Patchbay

  1366. 

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

  1368. {

  1369.     setLastError("Unsupported operation");

  1370.     return false;

  1371. }

  1372. 

  1373. bool CarlaEngine::patchbayDisconnect(int)

  1374. {

  1375.     setLastError("Unsupported operation");

  1376.     return false;

  1377. }

  1378. 

  1379. void CarlaEngine::patchbayRefresh()

  1380. {

  1381.     // nothing

  1382. }

  1383. 

  1384. // -----------------------------------------------------------------------

  1385. // Transport

  1386. 

  1387. void CarlaEngine::transportPlay()

  1388. {

  1389.     pData->time.playing = true;

  1390. }

  1391. 

  1392. void CarlaEngine::transportPause()

  1393. {

  1394.     pData->time.playing = false;

  1395. }

  1396. 

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

  1398. {

  1399.     pData->time.frame = frame;

  1400. }

  1401. 

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

  1403. // Error handling

  1404. 

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

  1406. {

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

  1408. }

  1409. 

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

  1411. {

  1412.     pData->lastError = error;

  1413. }

  1414. 

  1415. void CarlaEngine::setAboutToClose()

  1416. {

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

  1418.     pData->aboutToClose = true;

  1419. }

  1420. 

  1421. // -----------------------------------------------------------------------

  1422. // Global options

  1423. 

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

  1425. {

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

  1427. 

  1428. #ifndef BUILD_BRIDGE

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

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

  1431. #endif

  1432. 

  1433.     switch (option)

  1434.     {

  1435.     case OPTION_PROCESS_NAME:

  1436.         break;

  1437. 

  1438.     case OPTION_PROCESS_MODE:

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

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

  1441. 

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

  1443.         break;

  1444. 

  1445.     case OPTION_TRANSPORT_MODE:

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

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

  1448. 

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

  1450.         break;

  1451. 

  1452.     case OPTION_FORCE_STEREO:

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

  1454.         break;

  1455. 

  1456.     case OPTION_PREFER_PLUGIN_BRIDGES:

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

  1458.         break;

  1459. 

  1460.     case OPTION_PREFER_UI_BRIDGES:

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

  1462.         break;

  1463. 

  1464.     case OPTION_UIS_ALWAYS_ON_TOP:

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

  1466.         break;

  1467. 

  1468.     case OPTION_MAX_PARAMETERS:

  1469.         if (value < 1)

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

  1471. 

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

  1473.         break;

  1474. 

  1475.     case OPTION_UI_BRIDGES_TIMEOUT:

  1476.         if (value < 1)

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

  1478. 

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

  1480.         break;

  1481. 

  1482.     case OPTION_AUDIO_NUM_PERIODS:

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

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

  1485. 

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

  1487.         break;

  1488. 

  1489.     case OPTION_AUDIO_BUFFER_SIZE:

  1490.         if (value < 8)

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

  1492. 

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

  1494.         break;

  1495. 

  1496.     case OPTION_AUDIO_SAMPLE_RATE:

  1497.         if (value < 22050)

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

  1499. 

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

  1501.         break;

  1502. 

  1503.     case OPTION_AUDIO_DEVICE:

  1504.         fOptions.audioDevice = valueStr;

  1505.         break;

  1506. 

  1507.     case OPTION_PATH_RESOURCES:

  1508.         fOptions.resourceDir = valueStr;

  1509.         break;

  1510. 

  1511. #ifndef BUILD_BRIDGE

  1512.     case OPTION_PATH_BRIDGE_NATIVE:

  1513.         fOptions.bridge_native = valueStr;

  1514.         break;

  1515.     case OPTION_PATH_BRIDGE_POSIX32:

  1516.         fOptions.bridge_posix32 = valueStr;

  1517.         break;

  1518.     case OPTION_PATH_BRIDGE_POSIX64:

  1519.         fOptions.bridge_posix64 = valueStr;

  1520.         break;

  1521.     case OPTION_PATH_BRIDGE_WIN32:

  1522.         fOptions.bridge_win32 = valueStr;

  1523.         break;

  1524.     case OPTION_PATH_BRIDGE_WIN64:

  1525.         fOptions.bridge_win64 = valueStr;

  1526.         break;

  1527. #endif

  1528. 

  1529. #ifdef WANT_LV2

  1530.     case OPTION_PATH_BRIDGE_LV2_EXTERNAL:

  1531.         fOptions.bridge_lv2Extrn = valueStr;

  1532.         break;

  1533.     case OPTION_PATH_BRIDGE_LV2_GTK2:

  1534.         fOptions.bridge_lv2Gtk2 = valueStr;

  1535.         break;

  1536.     case OPTION_PATH_BRIDGE_LV2_GTK3:

  1537.         fOptions.bridge_lv2Gtk3 = valueStr;

  1538.         break;

  1539.     case OPTION_PATH_BRIDGE_LV2_QT4:

  1540.         fOptions.bridge_lv2Qt4 = valueStr;

  1541.         break;

  1542.     case OPTION_PATH_BRIDGE_LV2_QT5:

  1543.         fOptions.bridge_lv2Qt5 = valueStr;

  1544.         break;

  1545.     case OPTION_PATH_BRIDGE_LV2_COCOA:

  1546.         fOptions.bridge_lv2Cocoa = valueStr;

  1547.         break;

  1548.     case OPTION_PATH_BRIDGE_LV2_WINDOWS:

  1549.         fOptions.bridge_lv2Win = valueStr;

  1550.         break;

  1551.     case OPTION_PATH_BRIDGE_LV2_X11:

  1552.         fOptions.bridge_lv2X11 = valueStr;

  1553.         break;

  1554. #endif

  1555. 

  1556. #ifdef WANT_VST

  1557.     case OPTION_PATH_BRIDGE_VST_MAC:

  1558.         fOptions.bridge_vstMac = valueStr;

  1559.         break;

  1560.     case OPTION_PATH_BRIDGE_VST_HWND:

  1561.         fOptions.bridge_vstHWND = valueStr;

  1562.         break;

  1563.     case OPTION_PATH_BRIDGE_VST_X11:

  1564.         fOptions.bridge_vstX11 = valueStr;

  1565.         break;

  1566. #endif

  1567.     }

  1568. }

  1569. 

  1570. // -----------------------------------------------------------------------

  1571. // OSC Stuff

  1572. 

  1573. #ifdef BUILD_BRIDGE

  1574. bool CarlaEngine::isOscBridgeRegistered() const noexcept

  1575. {

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

  1577. }

  1578. #else

  1579. bool CarlaEngine::isOscControlRegistered() const noexcept

  1580. {

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

  1582. }

  1583. #endif

  1584. 

  1585. void CarlaEngine::idleOsc()

  1586. {

  1587.     pData->osc.idle();

  1588. }

  1589. 

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

  1591. {

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

  1593. }

  1594. 

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

  1596. {

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

  1598. }

  1599. 

  1600. #ifdef BUILD_BRIDGE

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

  1602. {

  1603.     pData->oscData = oscData;

  1604. }

  1605. #endif

  1606. 

  1607. // -----------------------------------------------------------------------

  1608. // protected calls

  1609. 

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

  1611. {

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

  1613. 

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

  1615.     {

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

  1617. 

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

  1619.             plugin->bufferSizeChanged(newBufferSize);

  1620.     }

  1621. 

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

  1623. }

  1624. 

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

  1626. {

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

  1628. 

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

  1630.     {

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

  1632. 

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

  1634.             plugin->sampleRateChanged(newSampleRate);

  1635.     }

  1636. 

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

  1638. }

  1639. 

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

  1641. {

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

  1643. 

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

  1645.     {

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

  1647. 

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

  1649.             plugin->offlineModeChanged(isOffline);

  1650.     }

  1651. }

  1652. 

  1653. void CarlaEngine::runPendingRtEvents()

  1654. {

  1655.     pData->doNextPluginAction(true);

  1656. 

  1657.     if (pData->time.playing)

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

  1659. 

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

  1661.     {

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

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

  1664.     }

  1665. 

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

  1667.     {

  1668.         // TODO - peak values?

  1669.     }

  1670. }

  1671. 

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

  1673. {

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

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

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

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

  1678. }

  1679. 

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

  1681. {

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

  1683. }

  1684. 

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

  1686. {

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

  1688. 

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

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

  1691. }

  1692. 

  1693. #ifndef BUILD_BRIDGE

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

  1695. {

  1696.     if (value < compare)

  1697.         value = compare;

  1698. }

  1699. 

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

  1701. {

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

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

  1704. 

  1705.     // safe copy

  1706.     float inBuf0[frames];

  1707.     float inBuf1[frames];

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

  1709. 

  1710.     // initialize inputs

  1711.     carla_copyFloat(inBuf0, inBufReal[0], frames);

  1712.     carla_copyFloat(inBuf1, inBufReal[1], frames);

  1713. 

  1714.     // initialize outputs (zero)

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

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

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

  1718. 

  1719.     bool processed = false;

  1720. 

  1721.     uint32_t oldAudioInCount = 0;

  1722.     uint32_t oldMidiOutCount = 0;

  1723. 

  1724.     // process plugins

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

  1726.     {

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

  1728. 

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

  1730.             continue;

  1731. 

  1732.         if (processed)

  1733.         {

  1734. 

  1735.             // initialize inputs (from previous outputs)

  1736.             carla_copyFloat(inBuf0, outBuf[0], frames);

  1737.             carla_copyFloat(inBuf1, outBuf[1], frames);

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

  1739. 

  1740.             // initialize outputs (zero)

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

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

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

  1744.         }

  1745. 

  1746.         oldAudioInCount = plugin->getAudioInCount();

  1747.         oldMidiOutCount = plugin->getMidiOutCount();

  1748. 

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

  1750.             //if (oldAudioInCount == 0)

  1751.             {

  1752.                 carla_addFloat(outBuf[0], inBuf0, frames);

  1753.                 carla_addFloat(outBuf[1], inBuf1, frames);

  1754.             }

  1755. 

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

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

  1758.             {

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

  1760.                 {

  1761.                     // TODO: carefully add to output, sorted events

  1762.                 }

  1763.                 else

  1764.                 {

  1765.                     // nothing in output, can be replaced directly

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

  1767.                 }

  1768.             }

  1769. 

  1770.         // process

  1771.         plugin->initBuffers();

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

  1773.         plugin->unlock();

  1774. 

  1775.         // set peaks

  1776.         {

  1777.             float inPeak1  = 0.0f;

  1778.             float inPeak2  = 0.0f;

  1779.             float outPeak1 = 0.0f;

  1780.             float outPeak2 = 0.0f;

  1781. 

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

  1783.             {

  1784.                 setValueIfHigher(inPeak1,  std::fabs(inBuf0[k]));

  1785.                 setValueIfHigher(inPeak2,  std::fabs(inBuf1[k]));

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

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

  1788.             }

  1789. 

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

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

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

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

  1794.         }

  1795. 

  1796.         processed = true;

  1797.     }

  1798. }

  1799. 

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

  1801. {

  1802.     // TODO

  1803.     return;

  1804. 

  1805.     // unused, for now

  1806.     (void)inBuf;

  1807.     (void)outBuf;

  1808.     (void)bufCount;

  1809.     (void)frames;

  1810. }

  1811. #endif

  1812. 

  1813. // -----------------------------------------------------------------------

  1814. // Carla Engine OSC stuff

  1815. 

  1816. #ifndef BUILD_BRIDGE

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

  1818. {

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

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

  1821.     CARLA_ASSERT(pluginName != nullptr);

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

  1823. 

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

  1825.     {

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

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

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

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

  1830.     }

  1831. }

  1832. 

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

  1834. {

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

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

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

  1838. 

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

  1840.     {

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

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

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

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

  1845.     }

  1846. }

  1847. 

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

  1849. {

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

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

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

  1853. 

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

  1855.     {

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

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

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

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

  1860.     }

  1861. }

  1862. 

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

  1864. {

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

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

  1867.     CARLA_ASSERT(type != PLUGIN_NONE);

  1868.     CARLA_ASSERT(realName != nullptr);

  1869.     CARLA_ASSERT(label != nullptr);

  1870.     CARLA_ASSERT(maker != nullptr);

  1871.     CARLA_ASSERT(copyright != nullptr);

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

  1873. 

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

  1875.     {

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

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

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

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

  1880.     }

  1881. }

  1882. 

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

  1884. {

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

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

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

  1888. 

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

  1890.     {

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

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

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

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

  1895.     }

  1896. }

  1897. 

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

  1899. {

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

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

  1902.     CARLA_ASSERT(index >= 0);

  1903.     CARLA_ASSERT(type != PARAMETER_UNKNOWN);

  1904.     CARLA_ASSERT(name != nullptr);

  1905.     CARLA_ASSERT(label != nullptr);

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

  1907. 

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

  1909.     {

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

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

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

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

  1914.     }

  1915. }

  1916. 

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

  1918. {

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

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

  1921.     CARLA_ASSERT(index >= 0);

  1922.     CARLA_ASSERT(min < max);

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

  1924. 

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

  1926.     {

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

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

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

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

  1931.     }

  1932. }

  1933. 

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

  1935. {

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

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

  1938.     CARLA_ASSERT(index >= 0);

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

  1940. 

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

  1942.     {

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

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

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

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

  1947.     }

  1948. }

  1949. 

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

  1951. {

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

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

  1954.     CARLA_ASSERT(index >= 0);

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

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

  1957. 

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

  1959.     {

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

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

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

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

  1964.     }

  1965. }

  1966. 

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

  1968. {

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

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

  1971. #if DEBUG

  1972.     if (index < 0)

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

  1974.     else

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

  1976. #endif

  1977. 

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

  1979.     {

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

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

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

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

  1984.     }

  1985. }

  1986. 

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

  1988. {

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

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

  1991.     CARLA_ASSERT(index >= 0);

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

  1993. 

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

  1995.     {

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

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

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

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

  2000.     }

  2001. }

  2002. 

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

  2004. {

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

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

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

  2008. 

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

  2010.     {

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

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

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

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

  2015.     }

  2016. }

  2017. 

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

  2019. {

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

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

  2022.     CARLA_ASSERT(count >= 0);

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

  2024. 

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

  2026.     {

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

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

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

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

  2031.     }

  2032. }

  2033. 

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

  2035. {

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

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

  2038.     CARLA_ASSERT(index >= 0);

  2039.     CARLA_ASSERT(name != nullptr);

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

  2041. 

  2042.     if (pData->oscData != nullptr && 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_program_name");

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

  2048.     }

  2049. }

  2050. 

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

  2052. {

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

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

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

  2056. 

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

  2058.     {

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

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

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

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

  2063.     }

  2064. }

  2065. 

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

  2067. {

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

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

  2070.     CARLA_ASSERT(count >= 0);

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

  2072. 

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

  2074.     {

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

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

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

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

  2079.     }

  2080. }

  2081. 

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

  2083. {

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

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

  2086.     CARLA_ASSERT(index >= 0);

  2087.     CARLA_ASSERT(bank >= 0);

  2088.     CARLA_ASSERT(program >= 0);

  2089.     CARLA_ASSERT(name != nullptr);

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

  2091. 

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

  2093.     {

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

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

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

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

  2098.     }

  2099. }

  2100. 

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

  2102. {

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

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

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

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

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

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

  2109. 

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

  2111.     {

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

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

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

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

  2116.     }

  2117. }

  2118. 

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

  2120. {

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

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

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

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

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

  2126. 

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

  2128.     {

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

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

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

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

  2133.     }

  2134. }

  2135. 

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

  2137. {

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

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

  2140. 

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

  2142. 

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

  2144.     {

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

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

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

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

  2149.     }

  2150. }

  2151. 

  2152. void CarlaEngine::oscSend_control_exit()

  2153. {

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

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

  2156. 

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

  2158.     {

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

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

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

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

  2163.     }

  2164. }

  2165. #else

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

  2167. {

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

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

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

  2171. 

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

  2173.     {

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

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

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

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

  2178.     }

  2179. }

  2180. 

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

  2182. {

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

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

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

  2186. 

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

  2188.     {

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

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

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

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

  2193.     }

  2194. }

  2195. 

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

  2197. {

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

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

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

  2201. 

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

  2203.     {

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

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

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

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

  2208.     }

  2209. }

  2210. 

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

  2212. {

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

  2214.     CARLA_ASSERT(count >= 0);

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

  2216. 

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

  2218.     {

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

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

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

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

  2223.     }

  2224. }

  2225. 

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

  2227. {

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

  2229.     CARLA_ASSERT(count >= 0);

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

  2231. 

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

  2233.     {

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

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

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

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

  2238.     }

  2239. }

  2240. 

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

  2242. {

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

  2244.     CARLA_ASSERT(name != nullptr);

  2245.     CARLA_ASSERT(label != nullptr);

  2246.     CARLA_ASSERT(maker != nullptr);

  2247.     CARLA_ASSERT(copyright != nullptr);

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

  2249. 

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

  2251.     {

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

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

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

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

  2256.     }

  2257. }

  2258. 

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

  2260. {

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

  2262.     CARLA_ASSERT(name != nullptr);

  2263.     CARLA_ASSERT(unit != nullptr);

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

  2265. 

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

  2267.     {

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

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

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

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

  2272.     }

  2273. }

  2274. 

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

  2276. {

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

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

  2279. 

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

  2281.     {

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

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

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

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

  2286.     }

  2287. }

  2288. 

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

  2290. {

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

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

  2293. 

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

  2295.     {

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

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

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

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

  2300.     }

  2301. }

  2302. 

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

  2304. {

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

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

  2307. 

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

  2309.     {

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

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

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

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

  2314.     }

  2315. }

  2316. 

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

  2318. {

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

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

  2321. 

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

  2323.     {

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

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

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

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

  2328.     }

  2329. }

  2330. 

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

  2332. {

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

  2334.     CARLA_ASSERT(key != nullptr);

  2335.     CARLA_ASSERT(value != nullptr);

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

  2337. 

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

  2339.     {

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

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

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

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

  2344.     }

  2345. }

  2346. 

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

  2348. {

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

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

  2351. 

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

  2353.     {

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

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

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

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

  2358.     }

  2359. }

  2360. 

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

  2362. {

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

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

  2365. 

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

  2367.     {

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

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

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

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

  2372.     }

  2373. }

  2374. 

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

  2376. {

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

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

  2379. 

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

  2381.     {

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

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

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

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

  2386.     }

  2387. }

  2388. 

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

  2390. {

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

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

  2393. 

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

  2395.     {

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

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

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

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

  2400.     }

  2401. }

  2402. 

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

  2404. {

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

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

  2407. 

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

  2409.     {

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

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

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

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

  2414.     }

  2415. }

  2416. 

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

  2418. {

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

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

  2421. 

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

  2423.     {

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

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

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

  2427.         lo_send(pData->oscData->target, targetPath, "s", chunkFile);

  2428.     }

  2429. }

  2430. #endif

  2431. 

  2432. CARLA_BACKEND_END_NAMESPACE