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.
663 Commits
17 Branches
1.0GB
Tree: 33de508be2
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '33de508be2'
${ noResults }
Carla/source/backend/engine/CarlaEngine.cpp

2501 lines
80KB
Raw Blame History 

  1. /*

  2.  * Carla Engine

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

  4.  *

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

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

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

  8.  * the License, or any later version.

  9.  *

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

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

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

  13.  * GNU General Public License for more details.

  14.  *

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

  16.  */

  17. 

  18. #include "CarlaEngineInternal.hpp"

  19. #include "CarlaBackendUtils.hpp"

  20. #include "CarlaStateUtils.hpp"

  21. #include "CarlaMIDI.h"

  22. 

  23. #include <cmath>

  24. 

  25. #include <QtCore/QDir>

  26. #include <QtCore/QFile>

  27. #include <QtCore/QFileInfo>

  28. #include <QtCore/QTextStream>

  29. 

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

  31. // Register native engine plugin

  32. 

  33. #ifndef BUILD_BRIDGE

  34. # include "CarlaNative.h"

  35. 

  36. void carla_register_native_plugin_carla()

  37. {

  38.     CARLA_BACKEND_USE_NAMESPACE

  39.     CarlaEngine::registerNativePlugin();

  40. }

  41. #endif

  42. 

  43. // -------------------------------------------------------------------------------------------------------------------

  44. 

  45. CARLA_BACKEND_START_NAMESPACE

  46. 

  47. // -------------------------------------------------------------------------------------------------------------------

  48. // Fallback data

  49. 

  50. static const EngineEvent kFallbackEngineEvent;

  51. 

  52. #ifndef BUILD_BRIDGE

  53. // -------------------------------------------------------------------------------------------------------------------

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

  55. 

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

  57. 

  58. // -------------------------------------------------------------------------------------------------------------------

  59. // Engine Helpers

  60. 

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

  62. {

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

  64. }

  65. #endif

  66. 

  67. // -------------------------------------------------------------------------------------------------------------------

  68. // Carla Engine port (Abstract)

  69. 

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

  71.     : kIsInput(isInput),

  72.       kProcessMode(processMode)

  73. {

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

  75. }

  76. 

  77. CarlaEnginePort::~CarlaEnginePort()

  78. {

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

  80. }

  81. 

  82. // -------------------------------------------------------------------------------------------------------------------

  83. // Carla Engine Audio port

  84. 

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

  86.     : CarlaEnginePort(isInput, processMode),

  87.       fBuffer(nullptr)

  88. {

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

  90. 

  91.     if (kProcessMode == PROCESS_MODE_PATCHBAY)

  92.         fBuffer = new float[PATCHBAY_BUFFER_SIZE];

  93. }

  94. 

  95. CarlaEngineAudioPort::~CarlaEngineAudioPort()

  96. {

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

  98. 

  99.     if (kProcessMode == PROCESS_MODE_PATCHBAY)

  100.     {

  101.         CARLA_ASSERT(fBuffer != nullptr);

  102. 

  103.         if (fBuffer != nullptr)

  104.         {

  105.             delete[] fBuffer;

  106.             fBuffer = nullptr;

  107.         }

  108.     }

  109. }

  110. 

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

  112. {

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

  114.         carla_zeroFloat(fBuffer, PATCHBAY_BUFFER_SIZE);

  115. }

  116. 

  117. // -------------------------------------------------------------------------------------------------------------------

  118. // Carla Engine CV port

  119. 

  120. CarlaEngineCVPort::CarlaEngineCVPort(const bool isInput, const ProcessMode processMode, const uint32_t bufferSize)

  121.     : CarlaEnginePort(isInput, processMode),

  122.       fBuffer(new float[bufferSize]),

  123.       fBufferSize(bufferSize)

  124. {

  125.     carla_debug("CarlaEngineCVPort::CarlaEngineCVPort(%s, %s)", bool2str(isInput), ProcessMode2Str(processMode));

  126. }

  127. 

  128. CarlaEngineCVPort::~CarlaEngineCVPort()

  129. {

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

  131. 

  132.     CARLA_ASSERT(fBuffer != nullptr);

  133. 

  134.     if (fBuffer != nullptr)

  135.     {

  136.         delete[] fBuffer;

  137.         fBuffer = nullptr;

  138.     }

  139. }

  140. 

  141. void CarlaEngineCVPort::initBuffer(CarlaEngine* const engine)

  142. {

  143.     CARLA_ASSERT(engine != nullptr && engine->getBufferSize() == fBufferSize);

  144. 

  145.     if (! kIsInput)

  146.         carla_zeroFloat(fBuffer, fBufferSize);

  147. }

  148. 

  149. void CarlaEngineCVPort::writeBuffer(CarlaEngine* const engine)

  150. {

  151.     CARLA_ASSERT(! kIsInput);

  152.     CARLA_ASSERT(engine != nullptr);

  153. 

  154.     if (kIsInput)

  155.         return;

  156.     if (engine == nullptr)

  157.         return;

  158. 

  159.     CARLA_ASSERT(engine->getBufferSize() == fBufferSize);

  160. }

  161. 

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

  163. {

  164.     CARLA_ASSERT(fBuffer != nullptr);

  165. 

  166.     if (fBufferSize == bufferSize)

  167.         return;

  168. 

  169.     if (fBuffer != nullptr)

  170.         delete[] fBuffer;

  171. 

  172.     fBuffer     = new float[bufferSize];

  173.     fBufferSize = bufferSize;

  174. }

  175. 

  176. // -------------------------------------------------------------------------------------------------------------------

  177. // Carla Engine Event port

  178. 

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

  180.     : CarlaEnginePort(isInput, processMode),

  181.       pBuffer(nullptr)

  182. {

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

  184. 

  185.     if (kProcessMode == PROCESS_MODE_PATCHBAY)

  186.         pBuffer = new EngineEvent[INTERNAL_EVENT_COUNT];

  187. }

  188. 

  189. CarlaEngineEventPort::~CarlaEngineEventPort()

  190. {

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

  192. 

  193.     if (kProcessMode == PROCESS_MODE_PATCHBAY)

  194.     {

  195.         CARLA_ASSERT(pBuffer != nullptr);

  196. 

  197.         if (pBuffer != nullptr)

  198.         {

  199.             delete[] pBuffer;

  200.             pBuffer = nullptr;

  201.         }

  202.     }

  203. }

  204. 

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

  206. {

  207.     CARLA_ASSERT(engine != nullptr);

  208. 

  209.     if (engine == nullptr)

  210.         return;

  211. 

  212.     if (kProcessMode == PROCESS_MODE_CONTINUOUS_RACK || kProcessMode == PROCESS_MODE_BRIDGE)

  213.         pBuffer = engine->getInternalEventBuffer(kIsInput);

  214. 

  215.     else if (kProcessMode == PROCESS_MODE_PATCHBAY && ! kIsInput)

  216.         carla_zeroStruct<EngineEvent>(pBuffer, INTERNAL_EVENT_COUNT);

  217. }

  218. 

  219. uint32_t CarlaEngineEventPort::getEventCount() const

  220. {

  221.     CARLA_ASSERT(kIsInput);

  222.     CARLA_ASSERT(pBuffer != nullptr);

  223.     CARLA_ASSERT(kProcessMode != PROCESS_MODE_SINGLE_CLIENT && kProcessMode != PROCESS_MODE_MULTIPLE_CLIENTS);

  224. 

  225.     if (! kIsInput)

  226.         return 0;

  227.     if (pBuffer == nullptr)

  228.         return 0;

  229.     if (kProcessMode == PROCESS_MODE_SINGLE_CLIENT || kProcessMode == PROCESS_MODE_MULTIPLE_CLIENTS)

  230.         return 0;

  231. 

  232.     for (uint32_t i=0; i < INTERNAL_EVENT_COUNT; ++i)

  233.     {

  234.         if (pBuffer[i].type == kEngineEventTypeNull)

  235.             return i;

  236.     }

  237. 

  238.     // buffer full

  239.     return INTERNAL_EVENT_COUNT;

  240. }

  241. 

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

  243. {

  244.     CARLA_ASSERT(kIsInput);

  245.     CARLA_ASSERT(pBuffer != nullptr);

  246.     CARLA_ASSERT(kProcessMode != PROCESS_MODE_SINGLE_CLIENT && kProcessMode != PROCESS_MODE_MULTIPLE_CLIENTS);

  247.     CARLA_ASSERT(index < INTERNAL_EVENT_COUNT);

  248. 

  249.     if (! kIsInput)

  250.         return kFallbackEngineEvent;

  251.     if (pBuffer == nullptr)

  252.         return kFallbackEngineEvent;

  253.     if (kProcessMode == PROCESS_MODE_SINGLE_CLIENT || kProcessMode == PROCESS_MODE_MULTIPLE_CLIENTS)

  254.         return kFallbackEngineEvent;

  255.     if (index >= INTERNAL_EVENT_COUNT)

  256.         return kFallbackEngineEvent;

  257. 

  258.     return pBuffer[index];

  259. }

  260. 

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

  262. {

  263.     CARLA_ASSERT(! kIsInput);

  264.     CARLA_ASSERT(pBuffer != nullptr);

  265.     CARLA_ASSERT(kProcessMode != PROCESS_MODE_SINGLE_CLIENT && kProcessMode != PROCESS_MODE_MULTIPLE_CLIENTS);

  266.     CARLA_ASSERT(type != kEngineControlEventTypeNull);

  267.     CARLA_ASSERT(channel < MAX_MIDI_CHANNELS);

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

  269. 

  270.     if (kIsInput)

  271.         return;

  272.     if (pBuffer == nullptr)

  273.         return;

  274.     if (kProcessMode == PROCESS_MODE_SINGLE_CLIENT || kProcessMode == PROCESS_MODE_MULTIPLE_CLIENTS)

  275.         return;

  276.     if (type == kEngineControlEventTypeNull)

  277.         return;

  278.     if (channel >= MAX_MIDI_CHANNELS)

  279.         return;

  280.     if (type == kEngineControlEventTypeParameter)

  281.     {

  282.         CARLA_ASSERT(! MIDI_IS_CONTROL_BANK_SELECT(param));

  283.     }

  284. 

  285.     for (uint32_t i=0; i < INTERNAL_EVENT_COUNT; ++i)

  286.     {

  287.         if (pBuffer[i].type != kEngineEventTypeNull)

  288.             continue;

  289. 

  290.         pBuffer[i].type    = kEngineEventTypeControl;

  291.         pBuffer[i].time    = time;

  292.         pBuffer[i].channel = channel;

  293. 

  294.         pBuffer[i].ctrl.type  = type;

  295.         pBuffer[i].ctrl.param = param;

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

  297.         return;

  298.     }

  299. 

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

  301. }

  302. 

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

  304. {

  305.     CARLA_ASSERT(! kIsInput);

  306.     CARLA_ASSERT(pBuffer != nullptr);

  307.     CARLA_ASSERT(kProcessMode != PROCESS_MODE_SINGLE_CLIENT && kProcessMode != PROCESS_MODE_MULTIPLE_CLIENTS);

  308.     CARLA_ASSERT(channel < MAX_MIDI_CHANNELS);

  309.     CARLA_ASSERT(data != nullptr);

  310.     CARLA_ASSERT(size != 0 && size <= 4);

  311. 

  312.     if (kIsInput)

  313.         return;

  314.     if (pBuffer == nullptr)

  315.         return;

  316.     if (kProcessMode == PROCESS_MODE_SINGLE_CLIENT || kProcessMode == PROCESS_MODE_MULTIPLE_CLIENTS)

  317.         return;

  318.     if (channel >= MAX_MIDI_CHANNELS)

  319.         return;

  320.     if (data == nullptr)

  321.         return;

  322.     if (size == 0 || size > 4)

  323.         return;

  324. 

  325.     for (uint32_t i=0; i < INTERNAL_EVENT_COUNT; ++i)

  326.     {

  327.         if (pBuffer[i].type != kEngineEventTypeNull)

  328.             continue;

  329. 

  330.         pBuffer[i].type    = kEngineEventTypeMidi;

  331.         pBuffer[i].time    = time;

  332.         pBuffer[i].channel = channel;

  333. 

  334.         pBuffer[i].midi.port = port;

  335.         pBuffer[i].midi.size = size;

  336. 

  337.         carla_copy<uint8_t>(pBuffer[i].midi.data, data, size);

  338. 

  339.         // strip MIDI channel from 1st byte

  340.         pBuffer[i].midi.data[0] = MIDI_GET_STATUS_FROM_DATA(pBuffer[i].midi.data);

  341.         return;

  342.     }

  343. 

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

  345. }

  346. 

  347. // -------------------------------------------------------------------------------------------------------------------

  348. // Carla Engine client (Abstract)

  349. 

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

  351.     : kEngine(engine),

  352.       fActive(false),

  353.       fLatency(0)

  354. {

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

  356. }

  357. 

  358. CarlaEngineClient::~CarlaEngineClient()

  359. {

  360.     CARLA_ASSERT(! fActive);

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

  362. }

  363. 

  364. void CarlaEngineClient::activate()

  365. {

  366.     CARLA_ASSERT(! fActive);

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

  368. 

  369.     fActive = true;

  370. }

  371. 

  372. void CarlaEngineClient::deactivate()

  373. {

  374.     CARLA_ASSERT(fActive);

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

  376. 

  377.     fActive = false;

  378. }

  379. 

  380. bool CarlaEngineClient::isActive() const

  381. {

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

  383. 

  384.     return fActive;

  385. }

  386. 

  387. bool CarlaEngineClient::isOk() const

  388. {

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

  390. 

  391.     return true;

  392. }

  393. 

  394. uint32_t CarlaEngineClient::getLatency() const

  395. {

  396.     return fLatency;

  397. }

  398. 

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

  400. {

  401.     fLatency = samples;

  402. }

  403. 

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

  405. {

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

  407. 

  408.     switch (portType)

  409.     {

  410.     case kEnginePortTypeNull:

  411.         break;

  412.     case kEnginePortTypeAudio:

  413.         return new CarlaEngineAudioPort(isInput, kEngine.getProccessMode());

  414.     case kEnginePortTypeCV:

  415.         return new CarlaEngineCVPort(isInput, kEngine.getProccessMode(), kEngine.getBufferSize());

  416.     case kEnginePortTypeEvent:

  417.         return new CarlaEngineEventPort(isInput, kEngine.getProccessMode());

  418.     }

  419. 

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

  421.     return nullptr;

  422. }

  423. 

  424. // -------------------------------------------------------------------------------------------------------------------

  425. // Carla Engine

  426. 

  427. CarlaEngine::CarlaEngine()

  428.     : fBufferSize(0),

  429.       fSampleRate(0.0),

  430.       kData(new CarlaEngineProtectedData(this))

  431. {

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

  433. }

  434. 

  435. CarlaEngine::~CarlaEngine()

  436. {

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

  438. 

  439.     delete kData;

  440. }

  441. 

  442. // -----------------------------------------------------------------------

  443. // Helpers

  444. 

  445. // returned value must be deleted

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

  447. {

  448.     QString guiFilename;

  449.     QString pluginDir(filename);

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

  451. 

  452.     QString shortName(QFileInfo(pluginDir).baseName());

  453. 

  454.     QString checkLabel(label);

  455.     QString checkSName(shortName);

  456. 

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

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

  459. 

  460.     QStringList guiFiles(QDir(pluginDir).entryList());

  461. 

  462.     foreach (const QString& gui, guiFiles)

  463.     {

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

  465.         {

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

  467.             guiFilename = finalname.absoluteFilePath();

  468.             break;

  469.         }

  470.     }

  471. 

  472.     if (guiFilename.isEmpty())

  473.         return nullptr;

  474. 

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

  476. }

  477. 

  478. // -----------------------------------------------------------------------

  479. // Static values and calls

  480. 

  481. unsigned int CarlaEngine::getDriverCount()

  482. {

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

  484. 

  485.     unsigned int count = 1; // JACK

  486. 

  487. #ifdef WANT_RTAUDIO

  488.     count += getRtAudioApiCount();

  489. #endif

  490. 

  491.     return count;

  492. }

  493. 

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

  495. {

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

  497. 

  498.     if (index == 0)

  499.         return "JACK";

  500. 

  501. #ifdef WANT_RTAUDIO

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

  503. 

  504.     if (rtIndex < getRtAudioApiCount())

  505.         return getRtAudioApiName(rtIndex);

  506. #endif

  507. 

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

  509.     return nullptr;

  510. }

  511. 

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

  513. {

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

  515. 

  516.     if (index == 0)

  517.         return nullptr;

  518. 

  519. #ifdef WANT_RTAUDIO

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

  521. 

  522.     if (rtIndex < getRtAudioApiCount())

  523.         return getRtAudioApiDeviceNames(rtIndex);

  524. #endif

  525. 

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

  527.     return nullptr;

  528. }

  529. 

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

  531. {

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

  533. 

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

  535.         return newJack();

  536. 

  537. #ifdef WANT_RTAUDIO

  538. # ifdef __LINUX_ALSA__

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

  540.         return newRtAudio(RTAUDIO_LINUX_ALSA);

  541. # endif

  542. # ifdef __LINUX_PULSE__

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

  544.         return newRtAudio(RTAUDIO_LINUX_PULSE);

  545. # endif

  546. # ifdef __LINUX_OSS__

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

  548.         return newRtAudio(RTAUDIO_LINUX_OSS);

  549. # endif

  550. # ifdef __UNIX_JACK__

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

  552.         return newRtAudio(RTAUDIO_UNIX_JACK);

  553. # endif

  554. # ifdef __MACOSX_CORE__

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

  556.         return newRtAudio(RTAUDIO_MACOSX_CORE);

  557. # endif

  558. # ifdef __WINDOWS_ASIO__

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

  560.         return newRtAudio(RTAUDIO_WINDOWS_ASIO);

  561. # endif

  562. # ifdef __WINDOWS_DS__

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

  564.         return newRtAudio(RTAUDIO_WINDOWS_DS);

  565. # endif

  566. #endif

  567. 

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

  569.     return nullptr;

  570. }

  571. 

  572. // -----------------------------------------------------------------------

  573. // Maximum values

  574. 

  575. unsigned int CarlaEngine::maxClientNameSize() const

  576. {

  577.     return STR_MAX/2;

  578. }

  579. 

  580. unsigned int CarlaEngine::maxPortNameSize() const

  581. {

  582.     return STR_MAX;

  583. }

  584. 

  585. unsigned int CarlaEngine::currentPluginCount() const

  586. {

  587.     return kData->curPluginCount;

  588. }

  589. 

  590. unsigned int CarlaEngine::maxPluginNumber() const

  591. {

  592.     return kData->maxPluginNumber;

  593. }

  594. 

  595. // -----------------------------------------------------------------------

  596. // Virtual, per-engine type calls

  597. 

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

  599. {

  600.     CARLA_ASSERT(fName.isEmpty());

  601.     CARLA_ASSERT(kData->oscData == nullptr);

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

  603.     CARLA_ASSERT(kData->bufEvents.in  == nullptr);

  604.     CARLA_ASSERT(kData->bufEvents.out == nullptr);

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

  606. 

  607.     kData->aboutToClose = false;

  608.     kData->curPluginCount = 0;

  609.     kData->maxPluginNumber = 0;

  610.     kData->nextPluginId = 0;

  611. 

  612.     switch (fOptions.processMode)

  613.     {

  614.     case PROCESS_MODE_SINGLE_CLIENT:

  615.     case PROCESS_MODE_MULTIPLE_CLIENTS:

  616.         kData->maxPluginNumber = MAX_DEFAULT_PLUGINS;

  617.         break;

  618. 

  619.     case PROCESS_MODE_CONTINUOUS_RACK:

  620.         kData->maxPluginNumber = MAX_RACK_PLUGINS;

  621.         kData->bufEvents.in  = new EngineEvent[INTERNAL_EVENT_COUNT];

  622.         kData->bufEvents.out = new EngineEvent[INTERNAL_EVENT_COUNT];

  623.         break;

  624. 

  625.     case PROCESS_MODE_PATCHBAY:

  626.         kData->maxPluginNumber = MAX_PATCHBAY_PLUGINS;

  627.         break;

  628. 

  629.     case PROCESS_MODE_BRIDGE:

  630.         kData->maxPluginNumber = 1;

  631.         kData->bufEvents.in  = new EngineEvent[INTERNAL_EVENT_COUNT];

  632.         kData->bufEvents.out = new EngineEvent[INTERNAL_EVENT_COUNT];

  633.         break;

  634.     }

  635. 

  636.     if (kData->maxPluginNumber == 0)

  637.         return false;

  638. 

  639.     kData->nextPluginId = kData->maxPluginNumber;

  640. 

  641.     fName = clientName;

  642.     fName.toBasic();

  643. 

  644.     fTimeInfo.clear();

  645. 

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

  647. 

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

  649. #ifndef BUILD_BRIDGE

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

  651. #endif

  652. 

  653.     if (type() != kEngineTypePlugin)

  654.         carla_setprocname(clientName);

  655. 

  656.     kData->nextAction.ready();

  657.     kData->thread.startNow();

  658. 

  659.     return true;

  660. }

  661. 

  662. bool CarlaEngine::close()

  663. {

  664.     CARLA_ASSERT(fName.isNotEmpty());

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

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

  667.     CARLA_ASSERT(kData->nextAction.opcode == kEnginePostActionNull);

  668.     CARLA_ASSERT(kData->nextPluginId == kData->maxPluginNumber);

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

  670. 

  671.     kData->thread.stopNow();

  672.     kData->nextAction.ready();

  673. 

  674. #ifndef BUILD_BRIDGE

  675.     osc_send_control_exit();

  676. #endif

  677.     kData->osc.close();

  678.     kData->oscData = nullptr;

  679. 

  680.     kData->aboutToClose = true;

  681.     kData->curPluginCount = 0;

  682.     kData->maxPluginNumber = 0;

  683.     kData->nextPluginId = 0;

  684. 

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

  686.     {

  687.         delete[] kData->plugins;

  688.         kData->plugins = nullptr;

  689.     }

  690. 

  691.     if (kData->bufEvents.in != nullptr)

  692.     {

  693.         delete[] kData->bufEvents.in;

  694.         kData->bufEvents.in = nullptr;

  695.     }

  696. 

  697.     if (kData->bufEvents.out != nullptr)

  698.     {

  699.         delete[] kData->bufEvents.out;

  700.         kData->bufEvents.out = nullptr;

  701.     }

  702. 

  703.     fName.clear();

  704. 

  705.     return true;

  706. }

  707. 

  708. void CarlaEngine::idle()

  709. {

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

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

  712.     CARLA_ASSERT(kData->nextPluginId == kData->maxPluginNumber);     // TESTING, remove later

  713. 

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

  715.     {

  716.         CarlaPlugin* const plugin(kData->plugins[i].plugin);

  717. 

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

  719.             plugin->idleGui();

  720.     }

  721. }

  722. 

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

  724. {

  725.     return new CarlaEngineClient(*this);

  726. }

  727. 

  728. // -----------------------------------------------------------------------

  729. // Plugin management

  730. 

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

  732. {

  733.     CARLA_ASSERT(btype != BINARY_NONE);

  734.     CARLA_ASSERT(ptype != PLUGIN_NONE);

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

  736.     CARLA_ASSERT(kData->nextAction.opcode == kEnginePostActionNull);

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

  738. 

  739.     unsigned int id;

  740. 

  741.     if (kData->nextPluginId < kData->curPluginCount)

  742.     {

  743.         id = kData->nextPluginId;

  744.         kData->nextPluginId = kData->maxPluginNumber;

  745.         CARLA_ASSERT(kData->plugins[id].plugin != nullptr);

  746.     }

  747.     else

  748.     {

  749.         id = kData->curPluginCount;

  750. 

  751.         if (id == kData->maxPluginNumber)

  752.         {

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

  754.             return false;

  755.         }

  756. 

  757.         CARLA_ASSERT(kData->plugins[id].plugin == nullptr);

  758.     }

  759. 

  760.     CarlaPlugin::Initializer init = {

  761.         this,

  762.         id,

  763.         filename,

  764.         name,

  765.         label

  766.     };

  767. 

  768.     CarlaPlugin* plugin = nullptr;

  769. 

  770. #ifndef BUILD_BRIDGE

  771.     const char* bridgeBinary;

  772. 

  773.     switch (btype)

  774.     {

  775.     case BINARY_POSIX32:

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

  777.         break;

  778.     case BINARY_POSIX64:

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

  780.         break;

  781.     case BINARY_WIN32:

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

  783.         break;

  784.     case BINARY_WIN64:

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

  786.         break;

  787.     default:

  788.         bridgeBinary = nullptr;

  789.         break;

  790.     }

  791. 

  792. # ifndef Q_OS_WIN

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

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

  795. # endif

  796. 

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

  798.     {

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

  800.     }

  801.     else

  802. #endif // BUILD_BRIDGE

  803.     {

  804.         switch (ptype)

  805.         {

  806.         case PLUGIN_NONE:

  807.             break;

  808. 

  809.         case PLUGIN_INTERNAL:

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

  811.             break;

  812. 

  813.         case PLUGIN_LADSPA:

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

  815.             break;

  816. 

  817.         case PLUGIN_DSSI:

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

  819.             break;

  820. 

  821.         case PLUGIN_LV2:

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

  823.             break;

  824. 

  825.         case PLUGIN_VST:

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

  827.             break;

  828. 

  829.         case PLUGIN_VST3:

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

  831.             break;

  832. 

  833.         case PLUGIN_GIG:

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

  835.             break;

  836. 

  837.         case PLUGIN_SF2:

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

  839.             break;

  840. 

  841.         case PLUGIN_SFZ:

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

  843.             break;

  844.         }

  845.     }

  846. 

  847.     if (plugin == nullptr)

  848.         return false;

  849. 

  850.     plugin->registerToOscClient();

  851. 

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

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

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

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

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

  857. 

  858.     ++kData->curPluginCount;

  859. 

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

  861.     return true;

  862. }

  863. 

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

  865. {

  866.     CARLA_ASSERT(kData->curPluginCount != 0);

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

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

  869.     CARLA_ASSERT(kData->nextAction.opcode == kEnginePostActionNull);

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

  871. 

  872.     if (kData->plugins == nullptr || kData->curPluginCount == 0)

  873.     {

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

  875.         return false;

  876.     }

  877. 

  878.     CarlaPlugin* const plugin(kData->plugins[id].plugin);

  879. 

  880.     if (plugin == nullptr)

  881.     {

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

  883.         return false;

  884.     }

  885. 

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

  887. 

  888.     kData->thread.stopNow();

  889. 

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

  891.     const CarlaEngineProtectedData::ScopedPluginAction spa(kData, kEnginePostActionRemovePlugin, id, 0, lockWait);

  892. 

  893. #ifndef BUILD_BRIDGE

  894.     if (isOscControlRegistered())

  895.         osc_send_control_remove_plugin(id);

  896. #endif

  897. 

  898.     delete plugin;

  899. 

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

  901.         kData->thread.startNow();

  902. 

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

  904.     return true;

  905. }

  906. 

  907. void CarlaEngine::removeAllPlugins()

  908. {

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

  910.     CARLA_ASSERT(kData->nextAction.opcode == kEnginePostActionNull);

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

  912. 

  913.     if (kData->plugins == nullptr || kData->curPluginCount == 0)

  914.         return;

  915. 

  916.     kData->thread.stopNow();

  917. 

  918.     const bool lockWait(isRunning());

  919.     const CarlaEngineProtectedData::ScopedPluginAction spa(kData, kEnginePostActionZeroCount, 0, 0, lockWait);

  920. 

  921.     for (unsigned int i=0; i < kData->maxPluginNumber; ++i)

  922.     {

  923.         CarlaPlugin* const plugin(kData->plugins[i].plugin);

  924. 

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

  926. 

  927.         if (plugin != nullptr)

  928.             delete plugin;

  929. 

  930.         // clear this plugin

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

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

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

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

  935.     }

  936. 

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

  938.         kData->thread.startNow();

  939. 

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

  941. }

  942. 

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

  944. {

  945.     CARLA_ASSERT(kData->curPluginCount != 0);

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

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

  948.     CARLA_ASSERT(kData->nextAction.opcode == kEnginePostActionNull);

  949.     CARLA_ASSERT(newName != nullptr);

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

  951. 

  952.     if (kData->plugins == nullptr || kData->curPluginCount == 0)

  953.     {

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

  955.         return nullptr;

  956.     }

  957. 

  958.     CarlaPlugin* const plugin(kData->plugins[id].plugin);

  959. 

  960.     if (plugin == nullptr)

  961.     {

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

  963.         return nullptr;

  964.     }

  965. 

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

  967. 

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

  969.     {

  970.         plugin->setName(name);

  971.         return name;

  972.     }

  973. 

  974.     return nullptr;

  975. }

  976. 

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

  978. {

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

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

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

  982.     CARLA_ASSERT(kData->nextAction.opcode == kEnginePostActionNull);

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

  984. 

  985.     if (kData->plugins == nullptr || kData->curPluginCount == 0)

  986.     {

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

  988.         return false;

  989.     }

  990. 

  991.     CarlaPlugin* const plugin(kData->plugins[id].plugin);

  992. 

  993.     if (plugin == nullptr)

  994.     {

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

  996.         return false;

  997.     }

  998. 

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

  1000. 

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

  1002.     plugin->getLabel(label);

  1003. 

  1004.     BinaryType binaryType = BINARY_NATIVE;

  1005. 

  1006. #ifndef BUILD_BRIDGE

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

  1008.         binaryType = CarlaPluginGetBridgeBinaryType(plugin);

  1009. #endif

  1010. 

  1011.     const unsigned int pluginCountBefore(kData->curPluginCount);

  1012. 

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

  1014.         return false;

  1015. 

  1016.     CARLA_ASSERT(pluginCountBefore+1 == kData->curPluginCount);

  1017. 

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

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

  1020. 

  1021.     return true;

  1022. }

  1023. 

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

  1025. {

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

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

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

  1029.     CARLA_ASSERT(kData->nextAction.opcode == kEnginePostActionNull);

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

  1031. 

  1032.     if (id < kData->curPluginCount)

  1033.         kData->nextPluginId = id;

  1034. 

  1035.     return false;

  1036. }

  1037. 

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

  1039. {

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

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

  1042.     CARLA_ASSERT(kData->nextAction.opcode == kEnginePostActionNull);

  1043.     CARLA_ASSERT(idA != idB);

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

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

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

  1047. 

  1048.     if (kData->plugins == nullptr || kData->curPluginCount == 0)

  1049.     {

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

  1051.         return false;

  1052.     }

  1053. 

  1054.     kData->thread.stopNow();

  1055. 

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

  1057.     const CarlaEngineProtectedData::ScopedPluginAction spa(kData, kEnginePostActionSwitchPlugins, idA, idB, lockWait);

  1058. 

  1059. #ifndef BUILD_BRIDGE // TODO

  1060.     //if (isOscControlRegistered())

  1061.     //    osc_send_control_switch_plugins(idA, idB);

  1062. #endif

  1063. 

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

  1065.         kData->thread.startNow();

  1066. 

  1067.     return true;

  1068. }

  1069. 

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

  1071. {

  1072.     CARLA_ASSERT(kData->curPluginCount != 0);

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

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

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

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

  1077. 

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

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

  1080. 

  1081.     return nullptr;

  1082. }

  1083. 

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

  1085. {

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

  1087. }

  1088. 

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

  1090. {

  1091.     CARLA_ASSERT(kData->maxPluginNumber != 0);

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

  1093.     CARLA_ASSERT(kData->nextAction.opcode == kEnginePostActionNull);

  1094.     CARLA_ASSERT(name != nullptr);

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

  1096. 

  1097.     static CarlaString sname;

  1098.     sname = name;

  1099. 

  1100.     if (sname.isEmpty())

  1101.     {

  1102.         sname = "(No name)";

  1103.         return (const char*)sname;

  1104.     }

  1105. 

  1106.     if (kData->plugins == nullptr || kData->maxPluginNumber == 0)

  1107.         return (const char*)sname;

  1108. 

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

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

  1111. 

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

  1113.     {

  1114.         CARLA_ASSERT(kData->plugins[i].plugin != nullptr);

  1115. 

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

  1117.             break;

  1118. 

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

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

  1121.         {

  1122.             if (sname != pluginName)

  1123.                 continue;

  1124.         }

  1125. 

  1126.         // Check if string has already been modified

  1127.         {

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

  1129. 

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

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

  1132.             {

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

  1134. 

  1135.                 if (number == 9)

  1136.                 {

  1137.                     // next number is 10, 2 digits

  1138.                     sname.truncate(len-4);

  1139.                     sname += " (10)";

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

  1141.                 }

  1142.                 else

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

  1144. 

  1145.                 continue;

  1146.             }

  1147. 

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

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

  1150.             {

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

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

  1153. 

  1154.                 if (n2 == '9')

  1155.                 {

  1156.                     n2  = '0';

  1157.                     n3 += 1;

  1158.                 }

  1159.                 else

  1160.                     n2 += 1;

  1161. 

  1162.                 sname[len-2] = n2;

  1163.                 sname[len-3] = n3;

  1164. 

  1165.                 continue;

  1166.             }

  1167.         }

  1168. 

  1169.         // Modify string if not

  1170.         sname += " (2)";

  1171.     }

  1172. 

  1173.     return (const char*)sname;

  1174. }

  1175. 

  1176. // -----------------------------------------------------------------------

  1177. // Project management

  1178. 

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

  1180. {

  1181.     CARLA_ASSERT(filename != nullptr);

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

  1183. 

  1184.     QFileInfo fileInfo(filename);

  1185. 

  1186.     if (! fileInfo.exists())

  1187.     {

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

  1189.         return false;

  1190.     }

  1191. 

  1192.     if (! fileInfo.isFile())

  1193.     {

  1194.         setLastError("Not a file");

  1195.         return false;

  1196.     }

  1197. 

  1198.     if (! fileInfo.isReadable())

  1199.     {

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

  1201.         return false;

  1202.     }

  1203. 

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

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

  1206. 

  1207.     // -------------------------------------------------------------------

  1208. 

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

  1210.         return loadProject(filename);

  1211. 

  1212.     // -------------------------------------------------------------------

  1213. 

  1214.     if (extension == "gig")

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

  1216. 

  1217.     if (extension == "sf2")

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

  1219. 

  1220.     if (extension == "sfz")

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

  1222. 

  1223.     // -------------------------------------------------------------------

  1224. 

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

  1226.     {

  1227. #ifdef WANT_AUDIOFILE

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

  1229.         {

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

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

  1232.             return true;

  1233.         }

  1234.         return false;

  1235. #else

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

  1237.         return false;

  1238. #endif

  1239.     }

  1240. 

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

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

  1243.     {

  1244. #ifdef WANT_AUDIOFILE

  1245. # ifdef HAVE_FFMPEG

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

  1247.         {

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

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

  1250.             return true;

  1251.         }

  1252.         return false;

  1253. # else

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

  1255.         return false;

  1256. # endif

  1257. #else

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

  1259.         return false;

  1260. #endif

  1261.     }

  1262. 

  1263.     // -------------------------------------------------------------------

  1264. 

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

  1266.     {

  1267. #ifdef WANT_MIDIFILE

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

  1269.         {

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

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

  1272.             return true;

  1273.         }

  1274.         return false;

  1275. #else

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

  1277.         return false;

  1278. #endif

  1279.     }

  1280. 

  1281.     // -------------------------------------------------------------------

  1282.     // ZynAddSubFX

  1283. 

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

  1285.     {

  1286. #ifdef WANT_ZYNADDSUBFX

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

  1288.         {

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

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

  1291.             return true;

  1292.         }

  1293.         return false;

  1294. #else

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

  1296.         return false;

  1297. #endif

  1298.     }

  1299. 

  1300.     // -------------------------------------------------------------------

  1301. 

  1302.     setLastError("Unknown file extension");

  1303.     return false;

  1304. }

  1305. 

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

  1307. {

  1308.     CARLA_ASSERT(filename != nullptr);

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

  1310. 

  1311.     QFile file(filename);

  1312. 

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

  1314.         return false;

  1315. 

  1316.     QDomDocument xml;

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

  1318.     file.close();

  1319. 

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

  1321. 

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

  1323.     {

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

  1325.         return false;

  1326.     }

  1327. 

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

  1329. 

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

  1331. 

  1332.     while (! node.isNull())

  1333.     {

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

  1335.         {

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

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

  1338. 

  1339.             if (saveState.type == nullptr)

  1340.                 continue;

  1341. 

  1342.             const void* extraStuff = nullptr;

  1343. 

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

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

  1346. 

  1347.             // TODO - proper find&load plugins

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

  1349.             {

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

  1351.                     plugin->loadSaveState(saveState);

  1352.             }

  1353.         }

  1354. 

  1355.         if (isPreset)

  1356.             break;

  1357. 

  1358.         node = node.nextSibling();

  1359.     }

  1360. 

  1361.     return true;

  1362. }

  1363. 

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

  1365. {

  1366.     CARLA_ASSERT(filename != nullptr);

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

  1368. 

  1369.     QFile file(filename);

  1370. 

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

  1372.         return false;

  1373. 

  1374.     QTextStream out(&file);

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

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

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

  1378. 

  1379.     bool firstPlugin = true;

  1380.     char strBuf[STR_MAX+1];

  1381. 

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

  1383.     {

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

  1385. 

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

  1387.         {

  1388.             if (! firstPlugin)

  1389.                 out << "\n";

  1390. 

  1391.             plugin->getRealName(strBuf);

  1392. 

  1393.             if (*strBuf != 0)

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

  1395. 

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

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

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

  1399. 

  1400.             firstPlugin = false;

  1401.         }

  1402.     }

  1403. 

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

  1405. 

  1406.     file.close();

  1407.     return true;

  1408. }

  1409. 

  1410. // -----------------------------------------------------------------------

  1411. // Information (peaks)

  1412. 

  1413. // FIXME

  1414. 

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

  1416. {

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

  1418.     CARLA_ASSERT(id-1 < 2);

  1419. 

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

  1421.         return 0.0f;

  1422. 

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

  1424. }

  1425. 

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

  1427. {

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

  1429.     CARLA_ASSERT(id-1 < 2);

  1430. 

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

  1432.         return 0.0f;

  1433. 

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

  1435. }

  1436. 

  1437. // -----------------------------------------------------------------------

  1438. // Callback

  1439. 

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

  1441. {

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

  1443. 

  1444.     if (kData->callback)

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

  1446. }

  1447. 

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

  1449. {

  1450.     CARLA_ASSERT(func != nullptr);

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

  1452. 

  1453.     kData->callback    = func;

  1454.     kData->callbackPtr = ptr;

  1455. }

  1456. 

  1457. // -----------------------------------------------------------------------

  1458. // Patchbay

  1459. 

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

  1461. {

  1462.     setLastError("Unsupported operation");

  1463.     return false;

  1464. }

  1465. 

  1466. bool CarlaEngine::patchbayDisconnect(int)

  1467. {

  1468.     setLastError("Unsupported operation");

  1469.     return false;

  1470. }

  1471. 

  1472. void CarlaEngine::patchbayRefresh()

  1473. {

  1474.     // nothing

  1475. }

  1476. 

  1477. // -----------------------------------------------------------------------

  1478. // Transport

  1479. 

  1480. void CarlaEngine::transportPlay()

  1481. {

  1482.     kData->time.playing = true;

  1483. }

  1484. 

  1485. void CarlaEngine::transportPause()

  1486. {

  1487.     kData->time.playing = false;

  1488. }

  1489. 

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

  1491. {

  1492.     kData->time.frame = frame;

  1493. }

  1494. 

  1495. // -----------------------------------------------------------------------

  1496. // Error handling

  1497. 

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

  1499. {

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

  1501. }

  1502. 

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

  1504. {

  1505.     kData->lastError = error;

  1506. }

  1507. 

  1508. void CarlaEngine::setAboutToClose()

  1509. {

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

  1511.     kData->aboutToClose = true;

  1512. }

  1513. 

  1514. // -----------------------------------------------------------------------

  1515. // Global options

  1516. 

  1517. #define CARLA_ENGINE_SET_OPTION_RUNNING_CHECK \

  1518.     if (isRunning()) \

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

  1520. 

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

  1522. {

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

  1524. 

  1525.     switch (option)

  1526.     {

  1527.     case OPTION_PROCESS_NAME:

  1528.         carla_setprocname(valueStr);

  1529.         break;

  1530. 

  1531.     case OPTION_PROCESS_MODE:

  1532.         CARLA_ENGINE_SET_OPTION_RUNNING_CHECK

  1533. 

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

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

  1536. 

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

  1538.         break;

  1539. 

  1540.     case OPTION_TRANSPORT_MODE:

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

  1542. #if 0

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

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

  1545. 

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

  1547. #endif

  1548.         break;

  1549. 

  1550.     case OPTION_MAX_PARAMETERS:

  1551.         CARLA_ENGINE_SET_OPTION_RUNNING_CHECK

  1552. 

  1553.         if (value < 0)

  1554.             return; // TODO error here

  1555. 

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

  1557.         break;

  1558. 

  1559.     case OPTION_FORCE_STEREO:

  1560.         CARLA_ENGINE_SET_OPTION_RUNNING_CHECK

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

  1562.         break;

  1563. 

  1564. #ifdef WANT_DSSI

  1565.     case OPTION_USE_DSSI_VST_CHUNKS:

  1566.         CARLA_ENGINE_SET_OPTION_RUNNING_CHECK

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

  1568.         break;

  1569. #endif

  1570. 

  1571.     case OPTION_PREFER_PLUGIN_BRIDGES:

  1572.         CARLA_ENGINE_SET_OPTION_RUNNING_CHECK

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

  1574.         break;

  1575. 

  1576.     case OPTION_PREFER_UI_BRIDGES:

  1577.         CARLA_ENGINE_SET_OPTION_RUNNING_CHECK

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

  1579.         break;

  1580. 

  1581.     case OPTION_OSC_UI_TIMEOUT:

  1582.         CARLA_ENGINE_SET_OPTION_RUNNING_CHECK

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

  1584.         break;

  1585. 

  1586.     case OPTION_JACK_AUTOCONNECT:

  1587.         CARLA_ENGINE_SET_OPTION_RUNNING_CHECK

  1588.         fOptions.jackAutoConnect = (value != 0);

  1589.         break;

  1590. 

  1591.     case OPTION_JACK_TIMEMASTER:

  1592.         CARLA_ENGINE_SET_OPTION_RUNNING_CHECK

  1593.         fOptions.jackTimeMaster = (value != 0);

  1594.         break;

  1595. 

  1596. #ifdef WANT_RTAUDIO

  1597.     case OPTION_RTAUDIO_BUFFER_SIZE:

  1598.         CARLA_ENGINE_SET_OPTION_RUNNING_CHECK

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

  1600.         break;

  1601. 

  1602.     case OPTION_RTAUDIO_SAMPLE_RATE:

  1603.         CARLA_ENGINE_SET_OPTION_RUNNING_CHECK

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

  1605.         break;

  1606. 

  1607.     case OPTION_RTAUDIO_DEVICE:

  1608.         CARLA_ENGINE_SET_OPTION_RUNNING_CHECK

  1609.         fOptions.rtaudioDevice = valueStr;

  1610.         break;

  1611. #endif

  1612. 

  1613.     case OPTION_PATH_RESOURCES:

  1614.         fOptions.resourceDir = valueStr;

  1615.         break;

  1616. 

  1617. #ifndef BUILD_BRIDGE

  1618.     case OPTION_PATH_BRIDGE_NATIVE:

  1619.         fOptions.bridge_native = valueStr;

  1620.         break;

  1621.     case OPTION_PATH_BRIDGE_POSIX32:

  1622.         fOptions.bridge_posix32 = valueStr;

  1623.         break;

  1624.     case OPTION_PATH_BRIDGE_POSIX64:

  1625.         fOptions.bridge_posix64 = valueStr;

  1626.         break;

  1627.     case OPTION_PATH_BRIDGE_WIN32:

  1628.         fOptions.bridge_win32 = valueStr;

  1629.         break;

  1630.     case OPTION_PATH_BRIDGE_WIN64:

  1631.         fOptions.bridge_win64 = valueStr;

  1632.         break;

  1633. #endif

  1634. 

  1635. #ifdef WANT_LV2

  1636.     case OPTION_PATH_BRIDGE_LV2_GTK2:

  1637.         fOptions.bridge_lv2Gtk2 = valueStr;

  1638.         break;

  1639.     case OPTION_PATH_BRIDGE_LV2_GTK3:

  1640.         fOptions.bridge_lv2Gtk3 = valueStr;

  1641.         break;

  1642.     case OPTION_PATH_BRIDGE_LV2_QT4:

  1643.         fOptions.bridge_lv2Qt4 = valueStr;

  1644.         break;

  1645.     case OPTION_PATH_BRIDGE_LV2_QT5:

  1646.         fOptions.bridge_lv2Qt5 = valueStr;

  1647.         break;

  1648.     case OPTION_PATH_BRIDGE_LV2_COCOA:

  1649.         fOptions.bridge_lv2Cocoa = valueStr;

  1650.         break;

  1651.     case OPTION_PATH_BRIDGE_LV2_WINDOWS:

  1652.         fOptions.bridge_lv2Win = valueStr;

  1653.         break;

  1654.     case OPTION_PATH_BRIDGE_LV2_X11:

  1655.         fOptions.bridge_lv2X11 = valueStr;

  1656.         break;

  1657. #endif

  1658. 

  1659. #ifdef WANT_VST

  1660.     case OPTION_PATH_BRIDGE_VST_COCOA:

  1661.         fOptions.bridge_vstCocoa = valueStr;

  1662.         break;

  1663.     case OPTION_PATH_BRIDGE_VST_HWND:

  1664.         fOptions.bridge_vstHWND = valueStr;

  1665.         break;

  1666.     case OPTION_PATH_BRIDGE_VST_X11:

  1667.         fOptions.bridge_vstX11 = valueStr;

  1668.         break;

  1669. #endif

  1670.     }

  1671. }

  1672. 

  1673. // -----------------------------------------------------------------------

  1674. // OSC Stuff

  1675. 

  1676. #ifdef BUILD_BRIDGE

  1677. bool CarlaEngine::isOscBridgeRegistered() const

  1678. {

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

  1680. }

  1681. #else

  1682. bool CarlaEngine::isOscControlRegistered() const

  1683. {

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

  1685. }

  1686. #endif

  1687. 

  1688. void CarlaEngine::idleOsc()

  1689. {

  1690.     kData->osc.idle();

  1691. }

  1692. 

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

  1694. {

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

  1696. }

  1697. 

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

  1699. {

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

  1701. }

  1702. 

  1703. #ifdef BUILD_BRIDGE

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

  1705. {

  1706.     kData->oscData = oscData;

  1707. }

  1708. #endif

  1709. 

  1710. // -----------------------------------------------------------------------

  1711. // protected calls

  1712. 

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

  1714. {

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

  1716. 

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

  1718.     {

  1719.         CarlaPlugin* const plugin(kData->plugins[i].plugin);

  1720. 

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

  1722.             plugin->bufferSizeChanged(newBufferSize);

  1723.     }

  1724. 

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

  1726. }

  1727. 

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

  1729. {

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

  1731. 

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

  1733.     {

  1734.         CarlaPlugin* const plugin(kData->plugins[i].plugin);

  1735. 

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

  1737.             plugin->sampleRateChanged(newSampleRate);

  1738.     }

  1739. 

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

  1741. }

  1742. 

  1743. void CarlaEngine::proccessPendingEvents()

  1744. {

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

  1746. 

  1747.     kData->doNextPluginAction(true);

  1748. 

  1749.     if (kData->time.playing)

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

  1751. 

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

  1753.     {

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

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

  1756.     }

  1757. 

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

  1759.     {

  1760.         // TODO - peak values?

  1761.     }

  1762. }

  1763. 

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

  1765. {

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

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

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

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

  1770. }

  1771. 

  1772. EngineEvent* CarlaEngine::getInternalEventBuffer(const bool isInput) const

  1773. {

  1774.     return isInput ? kData->bufEvents.in : kData->bufEvents.out;

  1775. }

  1776. 

  1777. #ifndef BUILD_BRIDGE

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

  1779. {

  1780.     if (value < compare)

  1781.         value = compare;

  1782. }

  1783. 

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

  1785. {

  1786.     CARLA_ASSERT(kData->bufEvents.in != nullptr);

  1787.     CARLA_ASSERT(kData->bufEvents.out != nullptr);

  1788. 

  1789.     // initialize outputs (zero)

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

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

  1792.     carla_zeroMem(kData->bufEvents.out, sizeof(EngineEvent)*INTERNAL_EVENT_COUNT);

  1793. 

  1794.     bool processed = false;

  1795. 

  1796.     // process plugins

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

  1798.     {

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

  1800. 

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

  1802.             continue;

  1803. 

  1804.         if (processed)

  1805.         {

  1806.             // initialize inputs (from previous outputs)

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

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

  1809.             std::memcpy(kData->bufEvents.in, kData->bufEvents.out, sizeof(EngineEvent)*INTERNAL_EVENT_COUNT);

  1810. 

  1811.             // initialize outputs (zero)

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

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

  1814.             carla_zeroMem(kData->bufEvents.out, sizeof(EngineEvent)*INTERNAL_EVENT_COUNT);

  1815.         }

  1816. 

  1817.         // process

  1818.         plugin->initBuffers();

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

  1820.         plugin->unlock();

  1821. 

  1822. #if 0

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

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

  1825.         {

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

  1827.             {

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

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

  1830.             }

  1831.         }

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

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

  1834.         {

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

  1836.             {

  1837. 

  1838.             }

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

  1840.         }

  1841. #endif

  1842. 

  1843.         // set peaks

  1844.         {

  1845.             float inPeak1  = 0.0f;

  1846.             float inPeak2  = 0.0f;

  1847.             float outPeak1 = 0.0f;

  1848.             float outPeak2 = 0.0f;

  1849. 

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

  1851.             {

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

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

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

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

  1856.             }

  1857. 

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

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

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

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

  1862.         }

  1863. 

  1864.         processed = true;

  1865.     }

  1866. }

  1867. 

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

  1869. {

  1870.     // TODO

  1871.     return;

  1872. 

  1873.     // unused, for now

  1874.     (void)inBuf;

  1875.     (void)outBuf;

  1876.     (void)bufCount;

  1877.     (void)frames;

  1878. }

  1879. #endif

  1880. 

  1881. // -------------------------------------------------------------------------------------------------------------------

  1882. // Carla Engine OSC stuff

  1883. 

  1884. #ifndef BUILD_BRIDGE

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

  1886. {

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

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

  1889.     CARLA_ASSERT(pluginName != nullptr);

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

  1891. 

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

  1893.     {

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

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

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

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

  1898.     }

  1899. }

  1900. 

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

  1902. {

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

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

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

  1906. 

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

  1908.     {

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

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

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

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

  1913.     }

  1914. }

  1915. 

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

  1917. {

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

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

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

  1921. 

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

  1923.     {

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

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

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

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

  1928.     }

  1929. }

  1930. 

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

  1932. {

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

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

  1935.     CARLA_ASSERT(type != PLUGIN_NONE);

  1936.     CARLA_ASSERT(realName != nullptr);

  1937.     CARLA_ASSERT(label != nullptr);

  1938.     CARLA_ASSERT(maker != nullptr);

  1939.     CARLA_ASSERT(copyright != nullptr);

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

  1941. 

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

  1943.     {

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

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

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

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

  1948.     }

  1949. }

  1950. 

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

  1952. {

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

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

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

  1956. 

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

  1958.     {

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

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

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

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

  1963.     }

  1964. }

  1965. 

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

  1967. {

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

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

  1970.     CARLA_ASSERT(index >= 0);

  1971.     CARLA_ASSERT(type != PARAMETER_UNKNOWN);

  1972.     CARLA_ASSERT(name != nullptr);

  1973.     CARLA_ASSERT(label != nullptr);

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

  1975. 

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

  1977.     {

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

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

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

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

  1982.     }

  1983. }

  1984. 

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

  1986. {

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

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

  1989.     CARLA_ASSERT(index >= 0);

  1990.     CARLA_ASSERT(min < max);

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

  1992. 

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

  1994.     {

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

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

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

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

  1999.     }

  2000. }

  2001. 

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

  2003. {

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

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

  2006.     CARLA_ASSERT(index >= 0);

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

  2008. 

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

  2010.     {

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

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

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

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

  2015.     }

  2016. }

  2017. 

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

  2019. {

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

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

  2022.     CARLA_ASSERT(index >= 0);

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

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

  2025. 

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

  2027.     {

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

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

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

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

  2032.     }

  2033. }

  2034. 

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

  2036. {

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

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

  2039. #if DEBUG

  2040.     if (index < 0)

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

  2042.     else

  2043.         carla_debug("CarlaEngine::osc_send_control_set_parameter_value(%i, %i, %f)", pluginId, index, value);

  2044. #endif

  2045. 

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

  2047.     {

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

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

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

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

  2052.     }

  2053. }

  2054. 

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

  2056. {

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

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

  2059.     CARLA_ASSERT(index >= 0);

  2060.     carla_debug("CarlaEngine::osc_send_control_set_default_value(%i, %i, %f)", pluginId, index, value);

  2061. 

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

  2063.     {

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

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

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

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

  2068.     }

  2069. }

  2070. 

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

  2072. {

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

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

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

  2076. 

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

  2078.     {

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

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

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

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

  2083.     }

  2084. }

  2085. 

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

  2087. {

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

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

  2090.     CARLA_ASSERT(count >= 0);

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

  2092. 

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

  2094.     {

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

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

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

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

  2099.     }

  2100. }

  2101. 

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

  2103. {

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

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

  2106.     CARLA_ASSERT(index >= 0);

  2107.     CARLA_ASSERT(name != nullptr);

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

  2109. 

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

  2111.     {

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

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

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

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

  2116.     }

  2117. }

  2118. 

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

  2120. {

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

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

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

  2124. 

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

  2126.     {

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

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

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

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

  2131.     }

  2132. }

  2133. 

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

  2135. {

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

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

  2138.     CARLA_ASSERT(count >= 0);

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

  2140. 

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

  2142.     {

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

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

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

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

  2147.     }

  2148. }

  2149. 

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

  2151. {

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

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

  2154.     CARLA_ASSERT(index >= 0);

  2155.     CARLA_ASSERT(bank >= 0);

  2156.     CARLA_ASSERT(program >= 0);

  2157.     CARLA_ASSERT(name != nullptr);

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

  2159. 

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

  2161.     {

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

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

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

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

  2166.     }

  2167. }

  2168. 

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

  2170. {

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

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

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

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

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

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

  2177. 

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

  2179.     {

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

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

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

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

  2184.     }

  2185. }

  2186. 

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

  2188. {

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

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

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

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

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

  2194. 

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

  2196.     {

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

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

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

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

  2201.     }

  2202. }

  2203. 

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

  2205. {

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

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

  2208. 

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

  2210. 

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

  2212.     {

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

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

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

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

  2217.     }

  2218. }

  2219. 

  2220. void CarlaEngine::osc_send_control_exit()

  2221. {

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

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

  2224. 

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

  2226.     {

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

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

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

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

  2231.     }

  2232. }

  2233. #else

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

  2235. {

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

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

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

  2239. 

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

  2241.     {

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

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

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

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

  2246.     }

  2247. }

  2248. 

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

  2250. {

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

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

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

  2254. 

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

  2256.     {

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

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

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

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

  2261.     }

  2262. }

  2263. 

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

  2265. {

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

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

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

  2269. 

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

  2271.     {

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

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

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

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

  2276.     }

  2277. }

  2278. 

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

  2280. {

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

  2282.     CARLA_ASSERT(count >= 0);

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

  2284. 

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

  2286.     {

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

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

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

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

  2291.     }

  2292. }

  2293. 

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

  2295. {

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

  2297.     CARLA_ASSERT(count >= 0);

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

  2299. 

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

  2301.     {

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

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

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

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

  2306.     }

  2307. }

  2308. 

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

  2310. {

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

  2312.     CARLA_ASSERT(name != nullptr);

  2313.     CARLA_ASSERT(label != nullptr);

  2314.     CARLA_ASSERT(maker != nullptr);

  2315.     CARLA_ASSERT(copyright != nullptr);

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

  2317. 

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

  2319.     {

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

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

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

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

  2324.     }

  2325. }

  2326. 

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

  2328. {

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

  2330.     CARLA_ASSERT(name != nullptr);

  2331.     CARLA_ASSERT(unit != nullptr);

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

  2333. 

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

  2335.     {

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

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

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

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

  2340.     }

  2341. }

  2342. 

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

  2344. {

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

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

  2347. 

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

  2349.     {

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

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

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

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

  2354.     }

  2355. }

  2356. 

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

  2358. {

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

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

  2361. 

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

  2363.     {

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

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

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

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

  2368.     }

  2369. }

  2370. 

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

  2372. {

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

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

  2375. 

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

  2377.     {

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

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

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

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

  2382.     }

  2383. }

  2384. 

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

  2386. {

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

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

  2389. 

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

  2391.     {

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

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

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

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

  2396.     }

  2397. }

  2398. 

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

  2400. {

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

  2402.     CARLA_ASSERT(key != nullptr);

  2403.     CARLA_ASSERT(value != nullptr);

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

  2405. 

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

  2407.     {

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

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

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

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

  2412.     }

  2413. }

  2414. 

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

  2416. {

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

  2418.     carla_debug("CarlaEngine::osc_send_bridge_set_parameter_value(%i, %f)", index, value);

  2419. 

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

  2421.     {

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

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

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

  2425.         lo_send(kData->oscData->target, targetPath, "if", index, value);

  2426.     }

  2427. }

  2428. 

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

  2430. {

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

  2432.     carla_debug("CarlaEngine::osc_send_bridge_set_default_value(%i, %f)", index, value);

  2433. 

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

  2435.     {

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

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

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

  2439.         lo_send(kData->oscData->target, targetPath, "if", index, value);

  2440.     }

  2441. }

  2442. 

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

  2444. {

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

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

  2447. 

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

  2449.     {

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

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

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

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

  2454.     }

  2455. }

  2456. 

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

  2458. {

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

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

  2461. 

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

  2463.     {

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

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

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

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

  2468.     }

  2469. }

  2470. 

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

  2472. {

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

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

  2475. 

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

  2477.     {

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

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

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

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

  2482.     }

  2483. }

  2484. 

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

  2486. {

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

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

  2489. 

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

  2491.     {

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

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

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

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

  2496.     }

  2497. }

  2498. #endif

  2499. 

  2500. CARLA_BACKEND_END_NAMESPACE