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

2518 lines
79KB
Raw Blame History 

  1. /*

  2.  * Carla Engine

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

  4.  *

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

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

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

  8.  * the License, or any later version.

  9.  *

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

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

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

  13.  * GNU General Public License for more details.

  14.  *

  15.  * For a full copy of the GNU General Public License see the 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.             delete[] fBuffer;

  105.     }

  106. }

  107. 

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

  109. {

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

  111.         carla_zeroFloat(fBuffer, PATCHBAY_BUFFER_SIZE);

  112. }

  113. 

  114. // -------------------------------------------------------------------------------------------------------------------

  115. // Carla Engine Event port

  116. 

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

  118.     : CarlaEnginePort(isInput, processMode),

  119.       fBuffer(nullptr)

  120. {

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

  122. 

  123.     if (kProcessMode == PROCESS_MODE_PATCHBAY)

  124.         fBuffer = new EngineEvent[INTERNAL_EVENT_COUNT];

  125. }

  126. 

  127. CarlaEngineEventPort::~CarlaEngineEventPort()

  128. {

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

  130. 

  131.     if (kProcessMode == PROCESS_MODE_PATCHBAY)

  132.     {

  133.         CARLA_ASSERT(fBuffer != nullptr);

  134. 

  135.         if (fBuffer != nullptr)

  136.             delete[] fBuffer;

  137.     }

  138. }

  139. 

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

  141. {

  142.     CARLA_ASSERT(engine != nullptr);

  143. 

  144.     if (engine == nullptr)

  145.     {

  146.         fBuffer = nullptr;

  147.         return;

  148.     }

  149. 

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

  151.     {

  152.         fBuffer = engine->getInternalEventBuffer(kIsInput);

  153.         return;

  154.     }

  155. 

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

  157.         carla_zeroStruct<EngineEvent>(fBuffer, INTERNAL_EVENT_COUNT);

  158. }

  159. 

  160. uint32_t CarlaEngineEventPort::getEventCount() const

  161. {

  162.     CARLA_ASSERT(kIsInput);

  163.     CARLA_ASSERT(fBuffer != nullptr);

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

  165. 

  166.     if (! kIsInput)

  167.         return 0;

  168.     if (fBuffer == nullptr)

  169.         return 0;

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

  171.         return 0;

  172. 

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

  174.     {

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

  176.             return i;

  177.     }

  178. 

  179.     CARLA_ASSERT(false); // should never happen

  180.     return 0;

  181. }

  182. 

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

  184. {

  185.     CARLA_ASSERT(kIsInput);

  186.     CARLA_ASSERT(fBuffer != nullptr);

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

  188.     CARLA_ASSERT(index < INTERNAL_EVENT_COUNT);

  189. 

  190.     if (! kIsInput)

  191.         return kFallbackEngineEvent;

  192.     if (fBuffer == nullptr)

  193.         return kFallbackEngineEvent;

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

  195.         return kFallbackEngineEvent;

  196.     if (index >= INTERNAL_EVENT_COUNT)

  197.         return kFallbackEngineEvent;

  198. 

  199.     return fBuffer[index];

  200. }

  201. 

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

  203. {

  204.     CARLA_ASSERT(! kIsInput);

  205.     CARLA_ASSERT(fBuffer != nullptr);

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

  207.     CARLA_ASSERT(type != kEngineControlEventTypeNull);

  208.     CARLA_ASSERT(channel < MAX_MIDI_CHANNELS);

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

  210. 

  211.     if (kIsInput)

  212.         return;

  213.     if (fBuffer == nullptr)

  214.         return;

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

  216.         return;

  217.     if (type == kEngineControlEventTypeNull)

  218.         return;

  219.     if (channel >= MAX_MIDI_CHANNELS)

  220.         return;

  221.     if (type == kEngineControlEventTypeParameter)

  222.     {

  223.         CARLA_ASSERT(! MIDI_IS_CONTROL_BANK_SELECT(param));

  224.     }

  225. 

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

  227.     {

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

  229.             continue;

  230. 

  231.         fBuffer[i].type    = kEngineEventTypeControl;

  232.         fBuffer[i].time    = time;

  233.         fBuffer[i].channel = channel;

  234. 

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

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

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

  238.         return;

  239.     }

  240. 

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

  242. }

  243. 

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

  245. {

  246.     CARLA_ASSERT(! kIsInput);

  247.     CARLA_ASSERT(fBuffer != nullptr);

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

  249.     CARLA_ASSERT(channel < MAX_MIDI_CHANNELS);

  250.     CARLA_ASSERT(data != nullptr);

  251.     CARLA_ASSERT(size > 0);

  252. 

  253.     if (kIsInput)

  254.         return;

  255.     if (fBuffer == nullptr)

  256.         return;

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

  258.         return;

  259.     if (channel >= MAX_MIDI_CHANNELS)

  260.         return;

  261.     if (data == nullptr)

  262.         return;

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

  264.         return;

  265. 

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

  267.     {

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

  269.             continue;

  270. 

  271.         fBuffer[i].type    = kEngineEventTypeMidi;

  272.         fBuffer[i].time    = time;

  273.         fBuffer[i].channel = channel;

  274. 

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

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

  277. 

  278.         carla_copy<uint8_t>(fBuffer[i].midi.data, data, size);

  279. 

  280.         // strip MIDI channel from 1st byte

  281.         fBuffer[i].midi.data[0] = MIDI_GET_STATUS_FROM_DATA(fBuffer[i].midi.data);

  282.         return;

  283.     }

  284. 

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

  286. }

  287. 

  288. // -------------------------------------------------------------------------------------------------------------------

  289. // Carla Engine client (Abstract)

  290. 

  291. CarlaEngineClient::CarlaEngineClient(const EngineType engineType, const ProcessMode processMode)

  292.     : kEngineType(engineType),

  293.       kProcessMode(processMode),

  294.       fActive(false),

  295.       fLatency(0)

  296. {

  297.     CARLA_ASSERT(engineType != kEngineTypeNull);

  298.     carla_debug("CarlaEngineClient::CarlaEngineClient(%s, %s)", EngineType2Str(engineType), ProcessMode2Str(processMode));

  299. }

  300. 

  301. CarlaEngineClient::~CarlaEngineClient()

  302. {

  303.     CARLA_ASSERT(! fActive);

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

  305. }

  306. 

  307. void CarlaEngineClient::activate()

  308. {

  309.     CARLA_ASSERT(! fActive);

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

  311. 

  312.     fActive = true;

  313. }

  314. 

  315. void CarlaEngineClient::deactivate()

  316. {

  317.     CARLA_ASSERT(fActive);

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

  319. 

  320.     fActive = false;

  321. }

  322. 

  323. bool CarlaEngineClient::isActive() const

  324. {

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

  326. 

  327.     return fActive;

  328. }

  329. 

  330. bool CarlaEngineClient::isOk() const

  331. {

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

  333. 

  334.     return true;

  335. }

  336. 

  337. uint32_t CarlaEngineClient::getLatency() const

  338. {

  339.     return fLatency;

  340. }

  341. 

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

  343. {

  344.     fLatency = samples;

  345. }

  346. 

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

  348. {

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

  350. 

  351.     switch (portType)

  352.     {

  353.     case kEnginePortTypeNull:

  354.         break;

  355.     case kEnginePortTypeAudio:

  356.         return new CarlaEngineAudioPort(isInput, kProcessMode);

  357.     case kEnginePortTypeEvent:

  358.         return new CarlaEngineEventPort(isInput, kProcessMode);

  359.     }

  360. 

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

  362.     return nullptr;

  363. }

  364. 

  365. // -------------------------------------------------------------------------------------------------------------------

  366. // Carla Engine

  367. 

  368. CarlaEngine::CarlaEngine()

  369.     : fBufferSize(0),

  370.       fSampleRate(0.0),

  371.       kData(new CarlaEngineProtectedData(this))

  372. {

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

  374. }

  375. 

  376. CarlaEngine::~CarlaEngine()

  377. {

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

  379. 

  380.     delete kData;

  381. }

  382. 

  383. // -----------------------------------------------------------------------

  384. // Helpers

  385. 

  386. void doPluginIdle(CarlaEngineProtectedData* const kData, const bool unlock)

  387. {

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

  389. 

  390.     kData->nextAction.opcode = kEnginePostActionNull;

  391. 

  392.     if (unlock)

  393.         kData->nextAction.mutex.unlock();

  394. }

  395. 

  396. void doPluginRemove(CarlaEngineProtectedData* const kData, const bool unlock)

  397. {

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

  399.     kData->curPluginCount--;

  400. 

  401.     const unsigned int id = kData->nextAction.pluginId;

  402. 

  403.     // reset current plugin

  404.     kData->plugins[id].plugin = nullptr;

  405. 

  406.     CarlaPlugin* plugin;

  407. 

  408.     // move all plugins 1 spot backwards

  409.     for (unsigned int i=id; i < kData->curPluginCount; ++i)

  410.     {

  411.         plugin = kData->plugins[i+1].plugin;

  412. 

  413.         CARLA_ASSERT(plugin != nullptr);

  414. 

  415.         if (plugin == nullptr)

  416.             break;

  417. 

  418.         plugin->setId(i);

  419. 

  420.         kData->plugins[i].plugin      = plugin;

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

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

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

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

  425.     }

  426. 

  427.     kData->nextAction.opcode = kEnginePostActionNull;

  428. 

  429.     if (unlock)

  430.         kData->nextAction.mutex.unlock();

  431. }

  432. 

  433. void doPluginsSwitch(CarlaEngineProtectedData* const kData, const bool unlock)

  434. {

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

  436. 

  437.     const unsigned int idA = kData->nextAction.pluginId;

  438.     const unsigned int idB = kData->nextAction.value;

  439. 

  440.     CarlaPlugin* const tmp = kData->plugins[idA].plugin;

  441.     kData->plugins[idA].plugin = kData->plugins[idB].plugin;

  442.     kData->plugins[idB].plugin = tmp;

  443. 

  444.     kData->nextAction.opcode = kEnginePostActionNull;

  445. 

  446.     if (unlock)

  447.         kData->nextAction.mutex.unlock();

  448. }

  449. 

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

  451. {

  452.     QString guiFilename;

  453.     guiFilename.clear();

  454. 

  455.     QString pluginDir(filename);

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

  457. 

  458.     QString shortName = QFileInfo(pluginDir).baseName();

  459. 

  460.     QString checkLabel = QString(label);

  461.     QString checkSName = shortName;

  462. 

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

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

  465. 

  466.     QStringList guiFiles = QDir(pluginDir).entryList();

  467. 

  468.     foreach (const QString& gui, guiFiles)

  469.     {

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

  471.         {

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

  473.             guiFilename = finalname.absoluteFilePath();

  474.             break;

  475.         }

  476.     }

  477. 

  478.     if (guiFilename.isEmpty())

  479.         return nullptr;

  480. 

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

  482. }

  483. 

  484. // -----------------------------------------------------------------------

  485. // Static values and calls

  486. 

  487. unsigned int CarlaEngine::getDriverCount()

  488. {

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

  490. 

  491.     unsigned int count = 1; // JACK

  492. 

  493. #ifdef WANT_RTAUDIO

  494.     count += getRtAudioApiCount();

  495. #endif

  496. 

  497.     return count;

  498. }

  499. 

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

  501. {

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

  503. 

  504.     if (index == 0)

  505.         return "JACK";

  506.     else

  507.         index -= 1;

  508. 

  509. #ifdef WANT_RTAUDIO

  510.     if (index < getRtAudioApiCount())

  511.         return getRtAudioApiName(index);

  512. #endif

  513. 

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

  515.     return nullptr;

  516. }

  517. 

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

  519. {

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

  521. 

  522.     if (index == 0)

  523.         return nullptr;

  524.     else

  525.         index -= 1;

  526. 

  527. #ifdef WANT_RTAUDIO

  528.     if (index < getRtAudioApiCount())

  529.         return getRtAudioApiDeviceNames(index);

  530. #endif

  531. 

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

  533.     return nullptr;

  534. }

  535. 

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

  537. {

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

  539. 

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

  541.         return newJack();

  542. 

  543. #ifdef WANT_RTAUDIO

  544. # ifdef __LINUX_ALSA__

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

  546.         return newRtAudio(RTAUDIO_LINUX_ALSA);

  547. # endif

  548. # ifdef __LINUX_PULSE__

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

  550.         return newRtAudio(RTAUDIO_LINUX_PULSE);

  551. # endif

  552. # ifdef __LINUX_OSS__

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

  554.         return newRtAudio(RTAUDIO_LINUX_OSS);

  555. # endif

  556. # ifdef __UNIX_JACK__

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

  558.         return newRtAudio(RTAUDIO_UNIX_JACK);

  559. # endif

  560. # ifdef __MACOSX_CORE__

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

  562.         return newRtAudio(RTAUDIO_MACOSX_CORE);

  563. # endif

  564. # ifdef __WINDOWS_ASIO__

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

  566.         return newRtAudio(RTAUDIO_WINDOWS_ASIO);

  567. # endif

  568. # ifdef __WINDOWS_DS__

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

  570.         return newRtAudio(RTAUDIO_WINDOWS_DS);

  571. # endif

  572. #endif

  573. 

  574.     return nullptr;

  575. }

  576. 

  577. // -----------------------------------------------------------------------

  578. // Maximum values

  579. 

  580. unsigned int CarlaEngine::maxClientNameSize() const

  581. {

  582.     return STR_MAX/2;

  583. }

  584. 

  585. unsigned int CarlaEngine::maxPortNameSize() const

  586. {

  587.     return STR_MAX;

  588. }

  589. 

  590. unsigned int CarlaEngine::currentPluginCount() const

  591. {

  592.     return kData->curPluginCount;

  593. }

  594. 

  595. unsigned int CarlaEngine::maxPluginNumber() const

  596. {

  597.     return kData->maxPluginNumber;

  598. }

  599. 

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

  601. // Virtual, per-engine type calls

  602. 

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

  604. {

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

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

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

  608. 

  609.     CARLA_ASSERT(kData->bufEvent.in  == nullptr);

  610.     CARLA_ASSERT(kData->bufEvent.out == nullptr);

  611. 

  612.     fName = clientName;

  613.     fName.toBasic();

  614. 

  615.     fTimeInfo.clear();

  616. 

  617.     kData->aboutToClose = false;

  618.     kData->curPluginCount = 0;

  619.     kData->maxPluginNumber = 0;

  620. 

  621.     switch (fOptions.processMode)

  622.     {

  623.     case PROCESS_MODE_SINGLE_CLIENT:

  624.     case PROCESS_MODE_MULTIPLE_CLIENTS:

  625.         kData->maxPluginNumber = MAX_DEFAULT_PLUGINS;

  626.         break;

  627. 

  628.     case PROCESS_MODE_CONTINUOUS_RACK:

  629.         kData->maxPluginNumber = MAX_RACK_PLUGINS;

  630.         kData->bufEvent.in  = new EngineEvent[INTERNAL_EVENT_COUNT];

  631.         kData->bufEvent.out = new EngineEvent[INTERNAL_EVENT_COUNT];

  632.         break;

  633. 

  634.     case PROCESS_MODE_PATCHBAY:

  635.         kData->maxPluginNumber = MAX_PATCHBAY_PLUGINS;

  636.         break;

  637. 

  638.     case PROCESS_MODE_BRIDGE:

  639.         kData->maxPluginNumber = 1;

  640.         kData->bufEvent.in  = new EngineEvent[INTERNAL_EVENT_COUNT];

  641.         kData->bufEvent.out = new EngineEvent[INTERNAL_EVENT_COUNT];

  642.         break;

  643.     }

  644. 

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

  646. 

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

  648. 

  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(kData->plugins != nullptr);

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

  666. 

  667.     kData->thread.stopNow();

  668.     kData->nextAction.ready();

  669. 

  670. #ifndef BUILD_BRIDGE

  671.     osc_send_control_exit();

  672. #endif

  673.     kData->osc.close();

  674. 

  675.     kData->oscData = nullptr;

  676. 

  677.     kData->aboutToClose = true;

  678.     kData->curPluginCount = 0;

  679.     kData->maxPluginNumber = 0;

  680. 

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

  682.     {

  683.         delete[] kData->plugins;

  684.         kData->plugins = nullptr;

  685.     }

  686. 

  687.     if (kData->bufEvent.in != nullptr)

  688.     {

  689.         delete[] kData->bufEvent.in;

  690.         kData->bufEvent.in = nullptr;

  691.     }

  692. 

  693.     if (kData->bufEvent.out != nullptr)

  694.     {

  695.         delete[] kData->bufEvent.out;

  696.         kData->bufEvent.out = nullptr;

  697.     }

  698. 

  699.     fName.clear();

  700. 

  701.     return true;

  702. }

  703. 

  704. void CarlaEngine::idle()

  705. {

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

  707. 

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

  709.     {

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

  711. 

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

  713.             plugin->idleGui();

  714.     }

  715. }

  716. 

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

  718. {

  719.     return new CarlaEngineClient(type(), fOptions.processMode);

  720. }

  721. 

  722. // -----------------------------------------------------------------------

  723. // Plugin management

  724. 

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

  726. {

  727.     CARLA_ASSERT(btype != BINARY_NONE);

  728.     CARLA_ASSERT(ptype != PLUGIN_NONE);

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

  730. 

  731.     if (kData->curPluginCount == kData->maxPluginNumber)

  732.     {

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

  734.         return false;

  735.     }

  736. 

  737.     const unsigned int id = kData->curPluginCount;

  738. 

  739.     CarlaPlugin::Initializer init = {

  740.         this,

  741.         id,

  742.         filename,

  743.         name,

  744.         label

  745.     };

  746. 

  747.     CarlaPlugin* plugin = nullptr;

  748. 

  749. #ifndef BUILD_BRIDGE

  750.     const char* bridgeBinary;

  751. 

  752.     switch (btype)

  753.     {

  754.     case BINARY_POSIX32:

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

  756.         break;

  757.     case BINARY_POSIX64:

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

  759.         break;

  760.     case BINARY_WIN32:

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

  762.         break;

  763.     case BINARY_WIN64:

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

  765.         break;

  766.     default:

  767.         bridgeBinary = nullptr;

  768.         break;

  769.     }

  770. 

  771. #ifndef Q_OS_WIN

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

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

  774. #endif

  775. 

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

  777.     {

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

  779.     }

  780.     else

  781. #endif // BUILD_BRIDGE

  782.     {

  783.         switch (ptype)

  784.         {

  785.         case PLUGIN_NONE:

  786.             break;

  787. 

  788.         case PLUGIN_INTERNAL:

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

  790.             break;

  791. 

  792.         case PLUGIN_LADSPA:

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

  794.             break;

  795. 

  796.         case PLUGIN_DSSI:

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

  798.             break;

  799. 

  800.         case PLUGIN_LV2:

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

  802.             break;

  803. 

  804.         case PLUGIN_VST:

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

  806.             break;

  807. 

  808.         case PLUGIN_VST3:

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

  810.             break;

  811. 

  812.         case PLUGIN_GIG:

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

  814.             break;

  815. 

  816.         case PLUGIN_SF2:

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

  818.             break;

  819. 

  820.         case PLUGIN_SFZ:

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

  822.             break;

  823.         }

  824.     }

  825. 

  826.     if (plugin == nullptr)

  827.         return false;

  828. 

  829.     plugin->registerToOscClient();

  830. 

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

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

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

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

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

  836. 

  837.     kData->curPluginCount += 1;

  838. 

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

  840.     return true;

  841. }

  842. 

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

  844. {

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

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

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

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

  849. 

  850.     if (kData->plugins == nullptr)

  851.     {

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

  853.         return false;

  854.     }

  855. 

  856.     CarlaPlugin* const plugin = kData->plugins[id].plugin;

  857. 

  858.     if (plugin == nullptr)

  859.     {

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

  861.         return false;

  862.     }

  863. 

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

  865. 

  866.     kData->thread.stopNow();

  867. 

  868.     kData->nextAction.pluginId = id;

  869.     kData->nextAction.opcode   = kEnginePostActionRemovePlugin;

  870. 

  871.     kData->nextAction.mutex.lock();

  872. 

  873.     if (isRunning())

  874.     {

  875.         carla_stderr("CarlaEngine::removePlugin(%i) - remove blocking START", id);

  876.         // block wait for unlock on proccessing side

  877.         kData->nextAction.mutex.lock();

  878.         carla_stderr("CarlaEngine::removePlugin(%i) - remove blocking DONE", id);

  879.     }

  880.     else

  881.     {

  882.         doPluginRemove(kData, false);

  883.     }

  884. 

  885. #ifndef BUILD_BRIDGE

  886.     if (isOscControlRegistered())

  887.         osc_send_control_remove_plugin(id);

  888. #endif

  889. 

  890.     delete plugin;

  891. 

  892.     kData->nextAction.mutex.unlock();

  893. 

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

  895.         kData->thread.startNow();

  896. 

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

  898.     return true;

  899. }

  900. 

  901. void CarlaEngine::removeAllPlugins()

  902. {

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

  904. 

  905.     kData->thread.stopNow();

  906. 

  907.     if (kData->curPluginCount > 0)

  908.     {

  909.         const unsigned int oldCount = kData->curPluginCount;

  910. 

  911.         kData->curPluginCount = 0;

  912. 

  913.         for (unsigned int i=0; i < oldCount; ++i)

  914.         {

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

  916. 

  917.             CARLA_ASSERT(plugin != nullptr);

  918. 

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

  920. 

  921.             if (plugin != nullptr)

  922.                 delete plugin;

  923. 

  924.             // clear this plugin

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

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

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

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

  929.         }

  930.     }

  931. 

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

  933.         kData->thread.startNow();

  934. 

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

  936. }

  937. 

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

  939. {

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

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

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

  943.     CARLA_ASSERT(newName != nullptr);

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

  945. 

  946.     if (kData->plugins == nullptr)

  947.     {

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

  949.         return nullptr;

  950.     }

  951. 

  952.     CarlaPlugin* const plugin = kData->plugins[id].plugin;

  953. 

  954.     if (plugin == nullptr)

  955.     {

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

  957.         return nullptr;

  958.     }

  959. 

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

  961. 

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

  963.     {

  964.         plugin->setName(name);

  965. 

  966.         return name;

  967.     }

  968. 

  969.     return nullptr;

  970. }

  971. 

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

  973. {

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

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

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

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

  978. 

  979.     if (kData->plugins == nullptr)

  980.     {

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

  982.         return false;

  983.     }

  984. 

  985.     CarlaPlugin* const plugin = kData->plugins[id].plugin;

  986. 

  987.     if (plugin == nullptr)

  988.     {

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

  990.         return false;

  991.     }

  992. 

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

  994. 

  995.     const SaveState& saveState(plugin->getSaveState());

  996. 

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

  998.     plugin->getLabel(label);

  999. 

  1000.     BinaryType binaryType = BINARY_NATIVE;

  1001. 

  1002. #ifndef BUILD_BRIDGE

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

  1004.         binaryType = CarlaPluginGetBridgeBinaryType(plugin);

  1005. #endif

  1006. 

  1007.     const unsigned int pluginsBefore(kData->curPluginCount);

  1008. 

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

  1010.         return false;

  1011. 

  1012.     CARLA_ASSERT(pluginsBefore+1 == kData->curPluginCount);

  1013. 

  1014.     CarlaPlugin* const newPlugin = kData->plugins[kData->curPluginCount-1].plugin;

  1015. 

  1016.     CARLA_ASSERT(newPlugin != nullptr);

  1017. 

  1018.     newPlugin->loadSaveState(saveState);

  1019. 

  1020.     return true;

  1021. }

  1022. 

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

  1024. {

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

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

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

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

  1029. 

  1030.     setLastError("Not implemented yet");

  1031.     return false;

  1032. }

  1033. 

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

  1035. {

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

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

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

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

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

  1041. 

  1042.     if (kData->plugins == nullptr)

  1043.     {

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

  1045.         return false;

  1046.     }

  1047. 

  1048.     kData->thread.stopNow();

  1049. 

  1050.     kData->nextAction.pluginId = idA;

  1051.     kData->nextAction.value    = idB;

  1052.     kData->nextAction.opcode   = kEnginePostActionSwitchPlugins;

  1053. 

  1054.     kData->nextAction.mutex.lock();

  1055. 

  1056.     if (isRunning())

  1057.     {

  1058.         carla_stderr("CarlaEngine::switchPlugins(%i, %i) - switch blocking START", idA, idB);

  1059.         // block wait for unlock on proccessing side

  1060.         kData->nextAction.mutex.lock();

  1061.         carla_stderr("CarlaEngine::switchPlugins(%i, %i) - switch blocking DONE", idA, idB);

  1062.     }

  1063.     else

  1064.     {

  1065.         doPluginsSwitch(kData, false);

  1066.     }

  1067. 

  1068. #ifndef BUILD_BRIDGE // TODO

  1069.     //if (isOscControlRegistered())

  1070.     //    osc_send_control_remove_plugin(id);

  1071. #endif

  1072. 

  1073.     kData->nextAction.mutex.unlock();

  1074. 

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

  1076.         kData->thread.startNow();

  1077. 

  1078.     return true;

  1079. }

  1080. 

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

  1082. {

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

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

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

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

  1087. 

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

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

  1090. 

  1091.     return nullptr;

  1092. }

  1093. 

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

  1095. {

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

  1097. }

  1098. 

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

  1100. {

  1101.     CARLA_ASSERT(kData->maxPluginNumber > 0);

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

  1103.     CARLA_ASSERT(name != nullptr);

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

  1105. 

  1106.     static CarlaString sname;

  1107.     sname = name;

  1108. 

  1109.     if (sname.isEmpty() || kData->plugins == nullptr)

  1110.     {

  1111.         sname = "(No name)";

  1112.         return (const char*)sname;

  1113.     }

  1114. 

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

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

  1117. 

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

  1119.     {

  1120.         CARLA_ASSERT(kData->plugins[i].plugin);

  1121. 

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

  1123.             continue;

  1124. 

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

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

  1127.         {

  1128.             if (sname != pluginName)

  1129.                 continue;

  1130.         }

  1131. 

  1132.         // Check if string has already been modified

  1133.         {

  1134.             const size_t len = sname.length();

  1135. 

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

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

  1138.             {

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

  1140. 

  1141.                 if (number == 9)

  1142.                 {

  1143.                     // next number is 10, 2 digits

  1144.                     sname.truncate(len-4);

  1145.                     sname += " (10)";

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

  1147.                 }

  1148.                 else

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

  1150. 

  1151.                 continue;

  1152.             }

  1153. 

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

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

  1156.             {

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

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

  1159. 

  1160.                 if (n2 == '9')

  1161.                 {

  1162.                     n2  = '0';

  1163.                     n3 += 1;

  1164.                 }

  1165.                 else

  1166.                     n2 += 1;

  1167. 

  1168.                 sname[len-2] = n2;

  1169.                 sname[len-3] = n3;

  1170. 

  1171.                 continue;

  1172.             }

  1173.         }

  1174. 

  1175.         // Modify string if not

  1176.         sname += " (2)";

  1177.     }

  1178. 

  1179.     return (const char*)sname;

  1180. }

  1181. 

  1182. // -----------------------------------------------------------------------

  1183. // Project management

  1184. 

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

  1186. {

  1187.     CARLA_ASSERT(filename != nullptr);

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

  1189. 

  1190.     QFileInfo fileInfo(filename);

  1191. 

  1192.     if (! fileInfo.exists())

  1193.     {

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

  1195.         return false;

  1196.     }

  1197. 

  1198.     if (! fileInfo.isFile())

  1199.     {

  1200.         setLastError("Not a file");

  1201.         return false;

  1202.     }

  1203. 

  1204.     if (! fileInfo.isReadable())

  1205.     {

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

  1207.         return false;

  1208.     }

  1209. 

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

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

  1212. 

  1213.     // -------------------------------------------------------------------

  1214. 

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

  1216.         return loadProject(filename);

  1217. 

  1218.     // -------------------------------------------------------------------

  1219. 

  1220.     if (extension == "gig")

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

  1222. 

  1223.     if (extension == "sf2")

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

  1225. 

  1226.     if (extension == "sfz")

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

  1228. 

  1229.     // -------------------------------------------------------------------

  1230. 

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

  1232.     {

  1233. #ifdef WANT_AUDIOFILE

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

  1235.         {

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

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

  1238.             return true;

  1239.         }

  1240.         return false;

  1241. #else

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

  1243.         return false;

  1244. #endif

  1245.     }

  1246. 

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

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

  1249.     {

  1250. #ifdef WANT_AUDIOFILE

  1251. # ifdef HAVE_FFMPEG

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

  1253.         {

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

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

  1256.             return true;

  1257.         }

  1258.         return false;

  1259. # else

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

  1261.         return false;

  1262. # endif

  1263. #else

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

  1265.         return false;

  1266. #endif

  1267.     }

  1268. 

  1269.     // -------------------------------------------------------------------

  1270. 

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

  1272.     {

  1273. #ifdef WANT_MIDIFILE

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

  1275.         {

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

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

  1278.             return true;

  1279.         }

  1280.         return false;

  1281. #else

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

  1283.         return false;

  1284. #endif

  1285.     }

  1286. 

  1287.     // -------------------------------------------------------------------

  1288.     // ZynAddSubFX

  1289. 

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

  1291.     {

  1292. #ifdef WANT_ZYNADDSUBFX

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

  1294.         {

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

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

  1297.             return true;

  1298.         }

  1299.         return false;

  1300. #else

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

  1302.         return false;

  1303. #endif

  1304.     }

  1305. 

  1306.     // -------------------------------------------------------------------

  1307. 

  1308.     setLastError("Unknown file extension");

  1309.     return false;

  1310. }

  1311. 

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

  1313. {

  1314.     CARLA_ASSERT(filename != nullptr);

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

  1316. 

  1317.     QFile file(filename);

  1318. 

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

  1320.         return false;

  1321. 

  1322.     QDomDocument xml;

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

  1324.     file.close();

  1325. 

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

  1327. 

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

  1329.     {

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

  1331.         return false;

  1332.     }

  1333. 

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

  1335. 

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

  1337. 

  1338.     while (! node.isNull())

  1339.     {

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

  1341.         {

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

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

  1344. 

  1345.             if (saveState.type == nullptr)

  1346.                 continue;

  1347. 

  1348.             const void* extraStuff = nullptr;

  1349. 

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

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

  1352. 

  1353.             // TODO - proper find&load plugins

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

  1355.             {

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

  1357.                     plugin->loadSaveState(saveState);

  1358.             }

  1359.         }

  1360. 

  1361.         if (isPreset)

  1362.             break;

  1363. 

  1364.         node = node.nextSibling();

  1365.     }

  1366. 

  1367.     return true;

  1368. }

  1369. 

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

  1371. {

  1372.     CARLA_ASSERT(filename != nullptr);

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

  1374. 

  1375.     QFile file(filename);

  1376. 

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

  1378.         return false;

  1379. 

  1380.     QTextStream out(&file);

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

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

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

  1384. 

  1385.     bool firstPlugin = true;

  1386.     char strBuf[STR_MAX+1];

  1387. 

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

  1389.     {

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

  1391. 

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

  1393.         {

  1394.             if (! firstPlugin)

  1395.                 out << "\n";

  1396. 

  1397.             plugin->getRealName(strBuf);

  1398. 

  1399.             if (*strBuf != 0)

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

  1401. 

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

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

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

  1405. 

  1406.             firstPlugin = false;

  1407.         }

  1408.     }

  1409. 

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

  1411. 

  1412.     file.close();

  1413.     return true;

  1414. }

  1415. 

  1416. // -----------------------------------------------------------------------

  1417. // Information (peaks)

  1418. 

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

  1420. {

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

  1422.     CARLA_ASSERT(id-1 < MAX_PEAKS);

  1423. 

  1424.     if (id == 0 || id > MAX_PEAKS)

  1425.         return 0.0f;

  1426. 

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

  1428. }

  1429. 

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

  1431. {

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

  1433.     CARLA_ASSERT(id-1 < MAX_PEAKS);

  1434. 

  1435.     if (id == 0 || id > MAX_PEAKS)

  1436.         return 0.0f;

  1437. 

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

  1439. }

  1440. 

  1441. // -----------------------------------------------------------------------

  1442. // Callback

  1443. 

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

  1445. {

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

  1447. 

  1448.     if (kData->callback)

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

  1450. }

  1451. 

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

  1453. {

  1454.     CARLA_ASSERT(func != nullptr);

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

  1456. 

  1457.     kData->callback    = func;

  1458.     kData->callbackPtr = ptr;

  1459. }

  1460. 

  1461. // -----------------------------------------------------------------------

  1462. // Patchbay

  1463. 

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

  1465. {

  1466.     setLastError("Unsupported operation");

  1467.     return false;

  1468. }

  1469. 

  1470. bool CarlaEngine::patchbayDisconnect(int)

  1471. {

  1472.     setLastError("Unsupported operation");

  1473.     return false;

  1474. }

  1475. 

  1476. void CarlaEngine::patchbayRefresh()

  1477. {

  1478.     // nothing

  1479. }

  1480. 

  1481. // -----------------------------------------------------------------------

  1482. // Transport

  1483. 

  1484. void CarlaEngine::transportPlay()

  1485. {

  1486.     kData->time.playing = true;

  1487. }

  1488. 

  1489. void CarlaEngine::transportPause()

  1490. {

  1491.     kData->time.playing = false;

  1492. }

  1493. 

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

  1495. {

  1496.     kData->time.frame = frame;

  1497. }

  1498. 

  1499. // -----------------------------------------------------------------------

  1500. // Error handling

  1501. 

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

  1503. {

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

  1505. }

  1506. 

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

  1508. {

  1509.     kData->lastError = error;

  1510. }

  1511. 

  1512. void CarlaEngine::setAboutToClose()

  1513. {

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

  1515.     kData->aboutToClose = true;

  1516. }

  1517. 

  1518. // -----------------------------------------------------------------------

  1519. // Global options

  1520. 

  1521. #define CARLA_ENGINE_SET_OPTION_RUNNING_CHECK \

  1522.     if (isRunning()) \

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

  1524. 

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

  1526. {

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

  1528. 

  1529.     switch (option)

  1530.     {

  1531.     case OPTION_PROCESS_NAME:

  1532.         carla_setprocname(valueStr);

  1533.         break;

  1534. 

  1535.     case OPTION_PROCESS_MODE:

  1536.         CARLA_ENGINE_SET_OPTION_RUNNING_CHECK

  1537. 

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

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

  1540. 

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

  1542.         break;

  1543. 

  1544.     case OPTION_TRANSPORT_MODE:

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

  1546. #if 0

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

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

  1549. 

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

  1551. #endif

  1552.         break;

  1553. 

  1554.     case OPTION_MAX_PARAMETERS:

  1555.         CARLA_ENGINE_SET_OPTION_RUNNING_CHECK

  1556. 

  1557.         if (value < 0)

  1558.             return; // TODO error here

  1559. 

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

  1561.         break;

  1562. 

  1563.     case OPTION_FORCE_STEREO:

  1564.         CARLA_ENGINE_SET_OPTION_RUNNING_CHECK

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

  1566.         break;

  1567. 

  1568. #ifdef WANT_DSSI

  1569.     case OPTION_USE_DSSI_VST_CHUNKS:

  1570.         CARLA_ENGINE_SET_OPTION_RUNNING_CHECK

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

  1572.         break;

  1573. #endif

  1574. 

  1575.     case OPTION_PREFER_PLUGIN_BRIDGES:

  1576.         CARLA_ENGINE_SET_OPTION_RUNNING_CHECK

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

  1578.         break;

  1579. 

  1580.     case OPTION_PREFER_UI_BRIDGES:

  1581.         CARLA_ENGINE_SET_OPTION_RUNNING_CHECK

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

  1583.         break;

  1584. 

  1585.     case OPTION_OSC_UI_TIMEOUT:

  1586.         CARLA_ENGINE_SET_OPTION_RUNNING_CHECK

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

  1588.         break;

  1589. 

  1590.     case OPTION_JACK_AUTOCONNECT:

  1591.         CARLA_ENGINE_SET_OPTION_RUNNING_CHECK

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

  1593.         break;

  1594. 

  1595.     case OPTION_JACK_TIMEMASTER:

  1596.         CARLA_ENGINE_SET_OPTION_RUNNING_CHECK

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

  1598.         break;

  1599. 

  1600. #ifdef WANT_RTAUDIO

  1601.     case OPTION_RTAUDIO_BUFFER_SIZE:

  1602.         CARLA_ENGINE_SET_OPTION_RUNNING_CHECK

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

  1604.         break;

  1605. 

  1606.     case OPTION_RTAUDIO_SAMPLE_RATE:

  1607.         CARLA_ENGINE_SET_OPTION_RUNNING_CHECK

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

  1609.         break;

  1610. 

  1611.     case OPTION_RTAUDIO_DEVICE:

  1612.         CARLA_ENGINE_SET_OPTION_RUNNING_CHECK

  1613.         fOptions.rtaudioDevice = valueStr;

  1614.         break;

  1615. #endif

  1616. 

  1617.     case OPTION_PATH_RESOURCES:

  1618.         fOptions.resourceDir = valueStr;

  1619.         break;

  1620. 

  1621. #ifndef BUILD_BRIDGE

  1622.     case OPTION_PATH_BRIDGE_NATIVE:

  1623.         fOptions.bridge_native = valueStr;

  1624.         break;

  1625.     case OPTION_PATH_BRIDGE_POSIX32:

  1626.         fOptions.bridge_posix32 = valueStr;

  1627.         break;

  1628.     case OPTION_PATH_BRIDGE_POSIX64:

  1629.         fOptions.bridge_posix64 = valueStr;

  1630.         break;

  1631.     case OPTION_PATH_BRIDGE_WIN32:

  1632.         fOptions.bridge_win32 = valueStr;

  1633.         break;

  1634.     case OPTION_PATH_BRIDGE_WIN64:

  1635.         fOptions.bridge_win64 = valueStr;

  1636.         break;

  1637. #endif

  1638. 

  1639. #ifdef WANT_LV2

  1640.     case OPTION_PATH_BRIDGE_LV2_GTK2:

  1641.         fOptions.bridge_lv2Gtk2 = valueStr;

  1642.         break;

  1643.     case OPTION_PATH_BRIDGE_LV2_GTK3:

  1644.         fOptions.bridge_lv2Gtk3 = valueStr;

  1645.         break;

  1646.     case OPTION_PATH_BRIDGE_LV2_QT4:

  1647.         fOptions.bridge_lv2Qt4 = valueStr;

  1648.         break;

  1649.     case OPTION_PATH_BRIDGE_LV2_QT5:

  1650.         fOptions.bridge_lv2Qt5 = valueStr;

  1651.         break;

  1652.     case OPTION_PATH_BRIDGE_LV2_COCOA:

  1653.         fOptions.bridge_lv2Cocoa = valueStr;

  1654.         break;

  1655.     case OPTION_PATH_BRIDGE_LV2_WINDOWS:

  1656.         fOptions.bridge_lv2Win = valueStr;

  1657.         break;

  1658.     case OPTION_PATH_BRIDGE_LV2_X11:

  1659.         fOptions.bridge_lv2X11 = valueStr;

  1660.         break;

  1661. #endif

  1662. 

  1663. #ifdef WANT_VST

  1664.     case OPTION_PATH_BRIDGE_VST_COCOA:

  1665.         fOptions.bridge_vstCocoa = valueStr;

  1666.         break;

  1667.     case OPTION_PATH_BRIDGE_VST_HWND:

  1668.         fOptions.bridge_vstHWND = valueStr;

  1669.         break;

  1670.     case OPTION_PATH_BRIDGE_VST_X11:

  1671.         fOptions.bridge_vstX11 = valueStr;

  1672.         break;

  1673. #endif

  1674.     }

  1675. }

  1676. 

  1677. // -----------------------------------------------------------------------

  1678. // OSC Stuff

  1679. 

  1680. #ifdef BUILD_BRIDGE

  1681. bool CarlaEngine::isOscBridgeRegistered() const

  1682. {

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

  1684. }

  1685. #else

  1686. bool CarlaEngine::isOscControlRegistered() const

  1687. {

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

  1689. }

  1690. #endif

  1691. 

  1692. void CarlaEngine::idleOsc()

  1693. {

  1694.     kData->osc.idle();

  1695. }

  1696. 

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

  1698. {

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

  1700. }

  1701. 

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

  1703. {

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

  1705. }

  1706. 

  1707. #ifdef BUILD_BRIDGE

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

  1709. {

  1710.     kData->oscData = oscData;

  1711. }

  1712. #endif

  1713. 

  1714. // -----------------------------------------------------------------------

  1715. // protected calls

  1716. 

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

  1718. {

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

  1720. 

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

  1722.     {

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

  1724. 

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

  1726.             plugin->bufferSizeChanged(newBufferSize);

  1727.     }

  1728. 

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

  1730. }

  1731. 

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

  1733. {

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

  1735. 

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

  1737.     {

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

  1739. 

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

  1741.             plugin->sampleRateChanged(newSampleRate);

  1742.     }

  1743. 

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

  1745. }

  1746. 

  1747. void CarlaEngine::proccessPendingEvents()

  1748. {

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

  1750. 

  1751.     switch (kData->nextAction.opcode)

  1752.     {

  1753.     case kEnginePostActionNull:

  1754.         break;

  1755.     case kEnginePostActionIdle:

  1756.         doPluginIdle(kData, true);

  1757.         break;

  1758.     case kEnginePostActionRemovePlugin:

  1759.         doPluginRemove(kData, true);

  1760.         break;

  1761.     case kEnginePostActionSwitchPlugins:

  1762.         doPluginsSwitch(kData, true);

  1763.         break;

  1764.     }

  1765. 

  1766.     if (kData->time.playing)

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

  1768. 

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

  1770.     {

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

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

  1773.     }

  1774. 

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

  1776.     {

  1777.         // TODO - peak values?

  1778.     }

  1779. }

  1780. 

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

  1782. {

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

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

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

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

  1787. }

  1788. 

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

  1790. {

  1791.     return isInput ? kData->bufEvent.in : kData->bufEvent.out;

  1792. }

  1793. 

  1794. #ifndef BUILD_BRIDGE

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

  1796. {

  1797.     if (value < compare)

  1798.         value = compare;

  1799. }

  1800. 

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

  1802. {

  1803.     CARLA_ASSERT(kData->bufEvent.in != nullptr);

  1804.     CARLA_ASSERT(kData->bufEvent.out != nullptr);

  1805. 

  1806.     // initialize outputs (zero)

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

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

  1809.     carla_zeroMem(kData->bufEvent.out, sizeof(EngineEvent)*INTERNAL_EVENT_COUNT);

  1810. 

  1811.     bool processed = false;

  1812. 

  1813.     // process plugins

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

  1815.     {

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

  1817. 

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

  1819.             continue;

  1820. 

  1821.         if (processed)

  1822.         {

  1823.             // initialize inputs (from previous outputs)

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

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

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

  1827. 

  1828.             // initialize outputs (zero)

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

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

  1831.             carla_zeroMem(kData->bufEvent.out, sizeof(EngineEvent)*INTERNAL_EVENT_COUNT);

  1832.         }

  1833. 

  1834.         // process

  1835.         plugin->initBuffers();

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

  1837.         plugin->unlock();

  1838. 

  1839. #if 0

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

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

  1842.         {

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

  1844.             {

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

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

  1847.             }

  1848.         }

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

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

  1851.         {

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

  1853.             {

  1854. 

  1855.             }

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

  1857.         }

  1858. #endif

  1859. 

  1860.         // set peaks

  1861.         {

  1862.             float inPeak1  = 0.0f;

  1863.             float inPeak2  = 0.0f;

  1864.             float outPeak1 = 0.0f;

  1865.             float outPeak2 = 0.0f;

  1866. 

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

  1868.             {

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

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

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

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

  1873.             }

  1874. 

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

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

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

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

  1879.         }

  1880. 

  1881.         processed = true;

  1882.     }

  1883. }

  1884. 

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

  1886. {

  1887.     // TODO

  1888.     return;

  1889. 

  1890.     // unused, for now

  1891.     (void)inBuf;

  1892.     (void)outBuf;

  1893.     (void)bufCount;

  1894.     (void)frames;

  1895. }

  1896. #endif

  1897. 

  1898. // -------------------------------------------------------------------------------------------------------------------

  1899. // Carla Engine OSC stuff

  1900. 

  1901. #ifndef BUILD_BRIDGE

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

  1903. {

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

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

  1906.     CARLA_ASSERT(pluginName != nullptr);

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

  1908. 

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

  1910.     {

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

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

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

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

  1915.     }

  1916. }

  1917. 

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

  1919. {

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

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

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

  1923. 

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

  1925.     {

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

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

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

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

  1930.     }

  1931. }

  1932. 

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

  1934. {

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

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

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

  1938. 

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

  1940.     {

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

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

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

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

  1945.     }

  1946. }

  1947. 

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

  1949. {

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

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

  1952.     CARLA_ASSERT(type != PLUGIN_NONE);

  1953.     CARLA_ASSERT(realName != nullptr);

  1954.     CARLA_ASSERT(label != nullptr);

  1955.     CARLA_ASSERT(maker != nullptr);

  1956.     CARLA_ASSERT(copyright != nullptr);

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

  1958. 

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

  1960.     {

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

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

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

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

  1965.     }

  1966. }

  1967. 

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

  1969. {

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

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

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

  1973. 

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

  1975.     {

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

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

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

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

  1980.     }

  1981. }

  1982. 

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

  1984. {

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

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

  1987.     CARLA_ASSERT(index >= 0);

  1988.     CARLA_ASSERT(type != PARAMETER_UNKNOWN);

  1989.     CARLA_ASSERT(name != nullptr);

  1990.     CARLA_ASSERT(label != nullptr);

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

  1992. 

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

  1994.     {

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

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

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

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

  1999.     }

  2000. }

  2001. 

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

  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_ASSERT(min < max);

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

  2009. 

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

  2011.     {

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

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

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

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

  2016.     }

  2017. }

  2018. 

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

  2020. {

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

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

  2023.     CARLA_ASSERT(index >= 0);

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

  2025. 

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

  2027.     {

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

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

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

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

  2032.     }

  2033. }

  2034. 

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

  2036. {

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

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

  2039.     CARLA_ASSERT(index >= 0);

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

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

  2042. 

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

  2044.     {

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

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

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

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

  2049.     }

  2050. }

  2051. 

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

  2053. {

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

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

  2056. #if DEBUG

  2057.     if (index < 0)

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

  2059.     else

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

  2061. #endif

  2062. 

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

  2064.     {

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

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

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

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

  2069.     }

  2070. }

  2071. 

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

  2073. {

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

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

  2076.     CARLA_ASSERT(index >= 0);

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

  2078. 

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

  2080.     {

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

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

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

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

  2085.     }

  2086. }

  2087. 

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

  2089. {

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

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

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

  2093. 

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

  2095.     {

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

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

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

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

  2100.     }

  2101. }

  2102. 

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

  2104. {

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

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

  2107.     CARLA_ASSERT(count >= 0);

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

  2109. 

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

  2111.     {

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

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

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

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

  2116.     }

  2117. }

  2118. 

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

  2120. {

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

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

  2123.     CARLA_ASSERT(index >= 0);

  2124.     CARLA_ASSERT(name != nullptr);

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

  2126. 

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

  2128.     {

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

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

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

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

  2133.     }

  2134. }

  2135. 

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

  2137. {

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

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

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

  2141. 

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

  2143.     {

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

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

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

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

  2148.     }

  2149. }

  2150. 

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

  2152. {

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

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

  2155.     CARLA_ASSERT(count >= 0);

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

  2157. 

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

  2159.     {

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

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

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

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

  2164.     }

  2165. }

  2166. 

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

  2168. {

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

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

  2171.     CARLA_ASSERT(index >= 0);

  2172.     CARLA_ASSERT(bank >= 0);

  2173.     CARLA_ASSERT(program >= 0);

  2174.     CARLA_ASSERT(name != nullptr);

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

  2176. 

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

  2178.     {

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

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

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

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

  2183.     }

  2184. }

  2185. 

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

  2187. {

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

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

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

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

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

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

  2194. 

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

  2196.     {

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

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

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

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

  2201.     }

  2202. }

  2203. 

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

  2205. {

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

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

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

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

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

  2211. 

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

  2213.     {

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

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

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

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

  2218.     }

  2219. }

  2220. 

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

  2222. {

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

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

  2225. 

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

  2227. 

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

  2229.     {

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

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

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

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

  2234.     }

  2235. }

  2236. 

  2237. void CarlaEngine::osc_send_control_exit()

  2238. {

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

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

  2241. 

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

  2243.     {

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

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

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

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

  2248.     }

  2249. }

  2250. #else

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

  2252. {

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

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

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

  2256. 

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

  2258.     {

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

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

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

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

  2263.     }

  2264. }

  2265. 

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

  2267. {

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

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

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

  2271. 

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

  2273.     {

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

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

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

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

  2278.     }

  2279. }

  2280. 

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

  2282. {

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

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

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

  2286. 

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

  2288.     {

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

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

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

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

  2293.     }

  2294. }

  2295. 

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

  2297. {

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

  2299.     CARLA_ASSERT(count >= 0);

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

  2301. 

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

  2303.     {

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

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

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

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

  2308.     }

  2309. }

  2310. 

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

  2312. {

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

  2314.     CARLA_ASSERT(count >= 0);

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

  2316. 

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

  2318.     {

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

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

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

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

  2323.     }

  2324. }

  2325. 

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

  2327. {

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

  2329.     CARLA_ASSERT(name != nullptr);

  2330.     CARLA_ASSERT(label != nullptr);

  2331.     CARLA_ASSERT(maker != nullptr);

  2332.     CARLA_ASSERT(copyright != nullptr);

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

  2334. 

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

  2336.     {

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

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

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

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

  2341.     }

  2342. }

  2343. 

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

  2345. {

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

  2347.     CARLA_ASSERT(name != nullptr);

  2348.     CARLA_ASSERT(unit != nullptr);

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

  2350. 

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

  2352.     {

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

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

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

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

  2357.     }

  2358. }

  2359. 

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

  2361. {

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

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

  2364. 

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

  2366.     {

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

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

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

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

  2371.     }

  2372. }

  2373. 

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

  2375. {

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

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

  2378. 

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

  2380.     {

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

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

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

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

  2385.     }

  2386. }

  2387. 

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

  2389. {

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

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

  2392. 

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

  2394.     {

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

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

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

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

  2399.     }

  2400. }

  2401. 

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

  2403. {

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

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

  2406. 

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

  2408.     {

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

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

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

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

  2413.     }

  2414. }

  2415. 

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

  2417. {

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

  2419.     CARLA_ASSERT(key != nullptr);

  2420.     CARLA_ASSERT(value != nullptr);

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

  2422. 

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

  2424.     {

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

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

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

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

  2429.     }

  2430. }

  2431. 

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

  2433. {

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

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

  2436. 

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

  2438.     {

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

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

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

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

  2443.     }

  2444. }

  2445. 

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

  2447. {

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

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

  2450. 

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

  2452.     {

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

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

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

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

  2457.     }

  2458. }

  2459. 

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

  2461. {

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

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

  2464. 

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

  2466.     {

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

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

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

  2470.         lo_send(kData->oscData->target, targetPath, "i", index);

  2471.     }

  2472. }

  2473. 

  2474. void CarlaEngine::osc_send_bridge_set_midi_program(const int32_t index)

  2475. {

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

  2477.     carla_debug("CarlaEngine::osc_send_bridge_set_midi_program(%i)", index);

  2478. 

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

  2480.     {

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

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

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

  2484.         lo_send(kData->oscData->target, targetPath, "i", index);

  2485.     }

  2486. }

  2487. 

  2488. void CarlaEngine::osc_send_bridge_set_custom_data(const char* const type, const char* const key, const char* const value)

  2489. {

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

  2491.     carla_debug("CarlaEngine::osc_send_bridge_set_custom_data(\"%s\", \"%s\", \"%s\")", type, key, value);

  2492. 

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

  2494.     {

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

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

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

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

  2499.     }

  2500. }

  2501. 

  2502. void CarlaEngine::osc_send_bridge_set_chunk_data(const char* const chunkFile)

  2503. {

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

  2505.     carla_debug("CarlaEngine::osc_send_bridge_set_chunk_data(\"%s\")", chunkFile);

  2506. 

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

  2508.     {

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

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

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

  2512.         lo_send(kData->oscData->target, targetPath, "s", chunkFile);

  2513.     }

  2514. }

  2515. #endif

  2516. 

  2517. CARLA_BACKEND_END_NAMESPACE