falkTX
/
Cadence
mirror of https://github.com/falkTX/Cadence
1
0
Fork 0
Code Releases 3 Activity
Collection of tools useful for audio production
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.
451 Commits
2 Branches
142MB
Tree: fdbab4e8da
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'fdbab4e8da'
${ noResults }
Cadence/c++/carla-backend/carla_engine.cpp

1772 lines
52KB
Raw Blame History 

  1. /*

  2.  * Carla Backend

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

  4.  *

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

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

  7.  * the Free Software Foundation; either version 2 of the License, or

  8.  * 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 COPYING file

  16.  */

  17. 

  18. #include "carla_engine.h"

  19. #include "carla_plugin.h"

  20. 

  21. CARLA_BACKEND_START_NAMESPACE

  22. 

  23. // -----------------------------------------------------------------------

  24. 

  25. unsigned short CarlaEngine::m_maxPluginNumber = 0;

  26. 

  27. CarlaEngine::CarlaEngine()

  28.     : m_checkThread(this),

  29. #ifndef BUILD_BRIDGE

  30.       m_osc(this),

  31.       m_oscData(nullptr),

  32. #endif

  33.       m_callback(nullptr),

  34. #ifdef Q_COMPILER_INITIALIZER_LISTS

  35.       m_callbackPtr(nullptr),

  36.       m_carlaPlugins{nullptr},

  37.       m_uniqueNames{nullptr},

  38.       m_insPeak{0.0},

  39.       m_outsPeak{0.0}

  40. #else

  41.       m_callbackPtr(nullptr)

  42. #endif

  43. {

  44.     qDebug("CarlaEngine::CarlaEngine()");

  45. 

  46.     type = CarlaEngineTypeNull;

  47.     name = nullptr;

  48.     bufferSize = 0;

  49.     sampleRate = 0.0;

  50.     m_maxPluginNumber = 0;

  51. 

  52. #ifndef Q_COMPILER_INITIALIZER_LISTS

  53.     for (unsigned short i=0; i < MAX_PLUGINS; i++)

  54.     {

  55.         m_carlaPlugins[i] = nullptr;

  56.         m_uniqueNames[i]  = nullptr;

  57.     }

  58. 

  59.     for (unsigned short i=0; i < MAX_PLUGINS * MAX_PEAKS; i++)

  60.     {

  61.         m_insPeak[i]  = 0.0;

  62.         m_outsPeak[i] = 0.0;

  63.     }

  64. #endif

  65. }

  66. 

  67. CarlaEngine::~CarlaEngine()

  68. {

  69.     qDebug("CarlaEngine::~CarlaEngine()");

  70. 

  71.     if (name)

  72.         free((void*)name);

  73. }

  74. 

  75. // -----------------------------------------------------------------------

  76. // Static values

  77. 

  78. int CarlaEngine::maxClientNameSize()

  79. {

  80. #ifdef CARLA_ENGINE_JACK

  81. #  ifndef BUILD_BRIDGE

  82.     if (carlaOptions.processMode != PROCESS_MODE_CONTINUOUS_RACK)

  83. #  endif

  84.         return jackbridge_client_name_size();

  85. #endif

  86.     return STR_MAX/2;

  87. }

  88. 

  89. int CarlaEngine::maxPortNameSize()

  90. {

  91. #ifdef CARLA_ENGINE_JACK

  92. #  ifndef BUILD_BRIDGE

  93.     if (carlaOptions.processMode != PROCESS_MODE_CONTINUOUS_RACK)

  94. #  endif

  95.         return jackbridge_port_name_size();

  96. #endif

  97.     return STR_MAX;

  98. }

  99. 

  100. unsigned short CarlaEngine::maxPluginNumber()

  101. {

  102.     return m_maxPluginNumber;

  103. }

  104. 

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

  106. {

  107.     qDebug("CarlaEngine::init(\"%s\")", clientName);

  108. 

  109. #ifndef BUILD_BRIDGE

  110.     m_osc.init(clientName);

  111.     m_oscData = m_osc.getControllerData();

  112. #endif

  113. 

  114.     return true;

  115. }

  116. 

  117. bool CarlaEngine::close()

  118. {

  119.     qDebug("CarlaEngine::close()");

  120. 

  121.     m_checkThread.stopNow();

  122. 

  123.     m_oscData = nullptr;

  124. #ifndef BUILD_BRIDGE

  125.     m_osc.close();

  126. #endif

  127. 

  128.     m_maxPluginNumber = 0;

  129. 

  130.     return true;

  131. }

  132. 

  133. // -----------------------------------------------------------------------

  134. // plugin management

  135. 

  136. short CarlaEngine::getNewPluginId() const

  137. {

  138.     qDebug("CarlaEngine::getNewPluginId()");

  139. 

  140.     for (unsigned short i=0; i < m_maxPluginNumber; i++)

  141.     {

  142.         if (! m_carlaPlugins[i])

  143.             return i;

  144.     }

  145. 

  146.     return -1;

  147. }

  148. 

  149. CarlaPlugin* CarlaEngine::getPlugin(const unsigned short id) const

  150. {

  151.     qDebug("CarlaEngine::getPlugin(%i/%i)", id, m_maxPluginNumber);

  152.     Q_ASSERT(m_maxPluginNumber != 0);

  153.     Q_ASSERT(id < m_maxPluginNumber);

  154. 

  155.     if (id < m_maxPluginNumber)

  156.         return m_carlaPlugins[id];

  157. 

  158.     return nullptr;

  159. }

  160. 

  161. CarlaPlugin* CarlaEngine::getPluginUnchecked(const unsigned short id) const

  162. {

  163.     Q_ASSERT(m_maxPluginNumber != 0);

  164.     Q_ASSERT(id < m_maxPluginNumber);

  165. 

  166.     return m_carlaPlugins[id];

  167. }

  168. 

  169. const char* CarlaEngine::getUniqueName(const char* const name)

  170. {

  171.     qDebug("CarlaEngine::getUniqueName(\"%s\")", name);

  172. 

  173.     QString qname(name);

  174. 

  175.     if (qname.isEmpty())

  176.         qname = "(No name)";

  177. 

  178.     qname.truncate(maxClientNameSize()-5-1); // 5 = strlen(" (10)")

  179.     qname.replace(":", "."); // ":" is used in JACK1 to split client/port names

  180. 

  181.     for (unsigned short i=0; i < m_maxPluginNumber; i++)

  182.     {

  183.         // Check if unique name already exists

  184.         if (m_uniqueNames[i] && qname == m_uniqueNames[i])

  185.         {

  186.             // Check if string has already been modified

  187.             uint len = qname.size();

  188. 

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

  190.             if (qname.at(len-4) == QChar(' ') && qname.at(len-3) == QChar('(') && qname.at(len-2).isDigit() && qname.at(len-1) == QChar(')'))

  191.             {

  192.                 int number = qname.at(len-2).toAscii()-'0';

  193. 

  194.                 if (number == 9)

  195.                     // next number is 10, 2 digits

  196.                     qname.replace(" (9)", " (10)");

  197.                 else

  198.                     qname[len-2] = QChar('0'+number+1);

  199. 

  200.                 continue;

  201.             }

  202. 

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

  204.             if (qname.at(len-5) == QChar(' ') && qname.at(len-4) == QChar('(') && qname.at(len-3).isDigit() && qname.at(len-2).isDigit() && qname.at(len-1) == QChar(')'))

  205.             {

  206.                 QChar n2 = qname.at(len-2);

  207.                 QChar n3 = qname.at(len-3);

  208. 

  209.                 if (n2 == QChar('9'))

  210.                 {

  211.                     n2 = QChar('0');

  212.                     n3 = QChar(n3.toAscii()+1);

  213.                 }

  214.                 else

  215.                     n2 = QChar(n2.toAscii()+1);

  216. 

  217.                 qname[len-2] = n2;

  218.                 qname[len-3] = n3;

  219. 

  220.                 continue;

  221.             }

  222. 

  223.             // Modify string if not

  224.             qname += " (2)";

  225.         }

  226.     }

  227. 

  228.     return strdup(qname.toUtf8().constData());

  229. }

  230. 

  231. short CarlaEngine::addPlugin(const PluginType ptype, const char* const filename, const char* const name, const char* const label, void* const extra)

  232. {

  233.     return addPlugin(BINARY_NATIVE, ptype, filename, name, label, extra);

  234. }

  235. 

  236. short CarlaEngine::addPlugin(const BinaryType btype, const PluginType ptype, const char* const filename, const char* const name, const char* const label, void* const extra)

  237. {

  238.     qDebug("CarlaEngine::addPlugin(%s, %s, \"%s\", \"%s\", \"%s\", %p)", BinaryType2str(btype), PluginType2str(ptype), filename, name, label, extra);

  239.     Q_ASSERT(btype != BINARY_NONE);

  240.     Q_ASSERT(ptype != PLUGIN_NONE);

  241.     Q_ASSERT(filename);

  242.     Q_ASSERT(label);

  243. 

  244.     if (m_maxPluginNumber == 0)

  245. #ifdef BUILD_BRIDGE

  246.         m_maxPluginNumber = MAX_PLUGINS;

  247. #else

  248.         m_maxPluginNumber = (carlaOptions.processMode == PROCESS_MODE_CONTINUOUS_RACK) ? 16 : MAX_PLUGINS;

  249. #endif

  250. 

  251.     CarlaPlugin::initializer init = {

  252.         this,

  253.         filename,

  254.         name,

  255.         label

  256.     };

  257. 

  258.     CarlaPlugin* plugin = nullptr;

  259. 

  260. #ifndef BUILD_BRIDGE

  261.     if (btype != BINARY_NATIVE /*|| true*/)

  262.     {

  263. #  ifdef CARLA_ENGINE_JACK

  264.         if (carlaOptions.processMode != CarlaBackend::PROCESS_MODE_MULTIPLE_CLIENTS)

  265.         {

  266.             setLastError("Can only use bridged plugins in JACK Multi-Client mode");

  267.             return -1;

  268.         }

  269. #  endif

  270. 

  271.         if (type != CarlaEngineTypeJack)

  272.         {

  273.             setLastError("Can only use bridged plugins with JACK backend");

  274.             return -1;

  275.         }

  276. 

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

  278.     }

  279.     else

  280. #endif

  281.     {

  282.         switch (ptype)

  283.         {

  284.         case PLUGIN_NONE:

  285.             break;

  286.         case PLUGIN_LADSPA:

  287.             plugin = CarlaPlugin::newLADSPA(init, extra);

  288.             break;

  289.         case PLUGIN_DSSI:

  290.             plugin = CarlaPlugin::newDSSI(init, extra);

  291.             break;

  292.         case PLUGIN_LV2:

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

  294.             break;

  295.         case PLUGIN_VST:

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

  297.             break;

  298. #ifdef BUILD_BRIDGE

  299.         case PLUGIN_GIG:

  300.         case PLUGIN_SF2:

  301.         case PLUGIN_SFZ:

  302.             break;

  303. #else

  304.         case PLUGIN_GIG:

  305.             plugin = CarlaPlugin::newGIG(init);

  306.             break;

  307.         case PLUGIN_SF2:

  308.             plugin = CarlaPlugin::newSF2(init);

  309.             break;

  310.         case PLUGIN_SFZ:

  311.             plugin = CarlaPlugin::newSFZ(init);

  312.             break;

  313. #endif

  314.         }

  315.     }

  316. 

  317.     if (! plugin)

  318.         return -1;

  319. 

  320.     const short id = plugin->id();

  321. 

  322.     m_carlaPlugins[id] = plugin;

  323.     m_uniqueNames[id]  = plugin->name();

  324. 

  325.     if (! m_checkThread.isRunning())

  326.         m_checkThread.startNow();

  327. 

  328.     return id;

  329. }

  330. 

  331. bool CarlaEngine::removePlugin(const unsigned short id)

  332. {

  333.     qDebug("CarlaEngine::removePlugin(%i)", id);

  334.     Q_ASSERT(m_maxPluginNumber != 0);

  335.     Q_ASSERT(id < m_maxPluginNumber);

  336. 

  337.     CarlaPlugin* const plugin = m_carlaPlugins[id];

  338. 

  339.     if (plugin /*&& plugin->id() == id*/)

  340.     {

  341.         Q_ASSERT(plugin->id() == id);

  342. 

  343.         m_checkThread.stopNow();

  344. 

  345.         processLock();

  346.         plugin->setEnabled(false);

  347.         processUnlock();

  348. 

  349.         delete plugin;

  350.         m_carlaPlugins[id] = nullptr;

  351.         m_uniqueNames[id]  = nullptr;

  352. 

  353. #ifndef BUILD_BRIDGE

  354.         if (carlaOptions.processMode == PROCESS_MODE_CONTINUOUS_RACK)

  355.         {

  356.             for (unsigned short i=id; i < m_maxPluginNumber-1; i++)

  357.             {

  358.                 m_carlaPlugins[i] = m_carlaPlugins[i+1];

  359.                 m_uniqueNames[i]  = m_uniqueNames[i+1];

  360. 

  361.                 if (m_carlaPlugins[i])

  362.                     m_carlaPlugins[i]->setId(i);

  363.             }

  364.         }

  365. #endif

  366. 

  367.         if (isRunning())

  368.             m_checkThread.startNow();

  369. 

  370.         return true;

  371.     }

  372. 

  373.     qCritical("CarlaEngine::removePlugin(%i) - could not find plugin", id);

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

  375.     return false;

  376. }

  377. 

  378. void CarlaEngine::removeAllPlugins()

  379. {

  380.     qDebug("CarlaEngine::removeAllPlugins()");

  381. 

  382.     m_checkThread.stopNow();

  383. 

  384.     for (unsigned short i=0; i < m_maxPluginNumber; i++)

  385.     {

  386.         CarlaPlugin* const plugin = m_carlaPlugins[i];

  387. 

  388.         if (plugin)

  389.         {

  390.             processLock();

  391.             plugin->setEnabled(false);

  392.             processUnlock();

  393. 

  394.             delete plugin;

  395.             m_carlaPlugins[i] = nullptr;

  396.             m_uniqueNames[i]  = nullptr;

  397.         }

  398.     }

  399. 

  400.     m_maxPluginNumber = 0;

  401. }

  402. 

  403. void CarlaEngine::idlePluginGuis()

  404. {

  405.     Q_ASSERT(m_maxPluginNumber != 0);

  406. 

  407.     for (unsigned short i=0; i < m_maxPluginNumber; i++)

  408.     {

  409.         CarlaPlugin* const plugin = m_carlaPlugins[i];

  410. 

  411.         if (plugin && plugin->enabled())

  412.             plugin->idleGui();

  413.     }

  414. }

  415. 

  416. // -----------------------------------------------------------------------

  417. // Information (base)

  418. 

  419. CarlaEngineType CarlaEngine::getType() const

  420. {

  421.     return type;

  422. }

  423. 

  424. const char* CarlaEngine::getName() const

  425. {

  426.     Q_ASSERT(name);

  427. 

  428.     return name;

  429. }

  430. 

  431. double CarlaEngine::getSampleRate() const

  432. {

  433.     //Q_ASSERT(sampleRate != 0.0);

  434. 

  435.     return sampleRate;

  436. }

  437. 

  438. uint32_t CarlaEngine::getBufferSize() const

  439. {

  440.     //Q_ASSERT(bufferSize != 0);

  441. 

  442.     return bufferSize;

  443. }

  444. 

  445. const CarlaTimeInfo* CarlaEngine::getTimeInfo() const

  446. {

  447.     return &timeInfo;

  448. }

  449. 

  450. // -----------------------------------------------------------------------

  451. // Information (audio peaks)

  452. 

  453. double CarlaEngine::getInputPeak(const unsigned short pluginId, const unsigned short id) const

  454. {

  455.     Q_ASSERT(pluginId < m_maxPluginNumber);

  456.     Q_ASSERT(id < MAX_PEAKS);

  457. 

  458.     return m_insPeak[pluginId*MAX_PEAKS + id];

  459. }

  460. 

  461. double CarlaEngine::getOutputPeak(const unsigned short pluginId, const unsigned short id) const

  462. {

  463.     Q_ASSERT(pluginId < m_maxPluginNumber);

  464.     Q_ASSERT(id < MAX_PEAKS);

  465. 

  466.     return m_outsPeak[pluginId*MAX_PEAKS + id];

  467. }

  468. 

  469. void CarlaEngine::setInputPeak(const unsigned short pluginId, const unsigned short id, double value)

  470. {

  471.     Q_ASSERT(pluginId < m_maxPluginNumber);

  472.     Q_ASSERT(id < MAX_PEAKS);

  473. 

  474.     m_insPeak[pluginId*MAX_PEAKS + id] = value;

  475. }

  476. 

  477. void CarlaEngine::setOutputPeak(const unsigned short pluginId, const unsigned short id, double value)

  478. {

  479.     Q_ASSERT(pluginId < m_maxPluginNumber);

  480.     Q_ASSERT(id < MAX_PEAKS);

  481. 

  482.     m_outsPeak[pluginId*MAX_PEAKS + id] = value;

  483. }

  484. 

  485. // -----------------------------------------------------------------------

  486. // Callback

  487. 

  488. void CarlaEngine::callback(const CallbackType action, const unsigned short pluginId, const int value1, const int value2, const double value3)

  489. {

  490.     qDebug("CarlaEngine::callback(%s, %i, %i, %i, %f)", CallbackType2str(action), pluginId, value1, value2, value3);

  491. 

  492.     if (m_callback)

  493.         m_callback(m_callbackPtr, action, pluginId, value1, value2, value3);

  494. }

  495. 

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

  497. {

  498.     qDebug("CarlaEngine::setCallback(%p, %p)", func, ptr);

  499. 

  500.     m_callback = func;

  501.     m_callbackPtr = ptr;

  502. }

  503. 

  504. // -----------------------------------------------------------------------

  505. // Mutex locks

  506. 

  507. void CarlaEngine::processLock()

  508. {

  509.     m_procLock.lock();

  510. }

  511. 

  512. void CarlaEngine::processUnlock()

  513. {

  514.     m_procLock.unlock();

  515. }

  516. 

  517. void CarlaEngine::midiLock()

  518. {

  519.     m_midiLock.lock();

  520. }

  521. 

  522. void CarlaEngine::midiUnlock()

  523. {

  524.     m_midiLock.unlock();

  525. }

  526. 

  527. // -----------------------------------------------------------------------

  528. // OSC Stuff

  529. 

  530. #ifndef BUILD_BRIDGE

  531. bool CarlaEngine::isOscControllerRegisted() const

  532. {

  533.     return m_osc.isControllerRegistered();

  534. }

  535. 

  536. const char* CarlaEngine::getOscServerPath() const

  537. {

  538.     return m_osc.getServerPath();

  539. }

  540. #else

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

  542. {

  543.     m_oscData = oscData;

  544. }

  545. #endif

  546. 

  547. // -----------------------------------------------------------------------

  548. // protected calls

  549. 

  550. void CarlaEngine::bufferSizeChanged(uint32_t newBufferSize)

  551. {

  552.     qDebug("CarlaEngine::bufferSizeChanged(%i)", newBufferSize);

  553. 

  554.     bufferSize = newBufferSize;

  555. 

  556.     for (unsigned short i=0; i < m_maxPluginNumber; i++)

  557.     {

  558.         if (m_carlaPlugins[i] && m_carlaPlugins[i]->enabled())

  559.             m_carlaPlugins[i]->bufferSizeChanged(newBufferSize);

  560.     }

  561. }

  562. 

  563. // -------------------------------------------------------------------------------------------------------------------

  564. // Carla Engine Client

  565. 

  566. CarlaEngineClient::CarlaEngineClient(const CarlaEngineType& type_, const CarlaEngineClientNativeHandle& handle_)

  567.     : type(type_),

  568.       handle(handle_)

  569. {

  570.     qDebug("CarlaEngineClient::CarlaEngineClient()");

  571.     Q_ASSERT(type != CarlaEngineTypeNull);

  572. 

  573.     m_active = false;

  574. }

  575. 

  576. CarlaEngineClient::~CarlaEngineClient()

  577. {

  578.     qDebug("CarlaEngineClient::~CarlaEngineClient()");

  579.     Q_ASSERT(! m_active);

  580. 

  581. #ifndef BUILD_BRIDGE

  582.     if (carlaOptions.processMode == PROCESS_MODE_MULTIPLE_CLIENTS)

  583. #endif

  584.     {

  585. #ifdef CARLA_ENGINE_JACK

  586.         if (handle.jackClient)

  587.             jackbridge_client_close(handle.jackClient);

  588. #endif

  589. #ifdef CARLA_ENGINE_RTAUDIO

  590.         if (handle.rtAudioPtr)

  591.             delete handle.rtAudioPtr;

  592. #endif

  593.     }

  594. }

  595. 

  596. void CarlaEngineClient::activate()

  597. {

  598.     qDebug("CarlaEngineClient::activate()");

  599.     Q_ASSERT(! m_active);

  600. 

  601. #ifndef BUILD_BRIDGE

  602.     if (carlaOptions.processMode == PROCESS_MODE_MULTIPLE_CLIENTS)

  603. #endif

  604.     {

  605.         if (! m_active)

  606.         {

  607. #ifdef CARLA_ENGINE_JACK

  608.             if (handle.jackClient)

  609.                 jackbridge_activate(handle.jackClient);

  610. #endif

  611. #ifdef CARLA_ENGINE_RTAUDIO

  612.             if (handle.rtAudioPtr)

  613.                 handle.rtAudioPtr->startStream();

  614. #endif

  615.         }

  616.     }

  617. 

  618.     m_active = true;

  619. }

  620. 

  621. void CarlaEngineClient::deactivate()

  622. {

  623.     qDebug("CarlaEngineClient::deactivate()");

  624.     Q_ASSERT(m_active);

  625. 

  626. #ifndef BUILD_BRIDGE

  627.     if (carlaOptions.processMode == PROCESS_MODE_MULTIPLE_CLIENTS)

  628. #endif

  629.     {

  630.         if (m_active)

  631.         {

  632. #ifdef CARLA_ENGINE_JACK

  633.             if (handle.jackClient)

  634.                 jackbridge_deactivate(handle.jackClient);

  635. #endif

  636. #ifdef CARLA_ENGINE_RTAUDIO

  637.             if (handle.rtAudioPtr)

  638.                 handle.rtAudioPtr->stopStream();

  639. #endif

  640.         }

  641.     }

  642. 

  643.     m_active = false;

  644. }

  645. 

  646. bool CarlaEngineClient::isActive() const

  647. {

  648.     qDebug("CarlaEngineClient::isActive()");

  649. 

  650.     return m_active;

  651. }

  652. 

  653. bool CarlaEngineClient::isOk() const

  654. {

  655.     qDebug("CarlaEngineClient::isOk()");

  656. 

  657. #ifndef BUILD_BRIDGE

  658.     if (carlaOptions.processMode != PROCESS_MODE_CONTINUOUS_RACK)

  659. #endif

  660.     {

  661. #ifdef CARLA_ENGINE_JACK

  662.         if (type == CarlaEngineTypeJack)

  663.             return bool(handle.jackClient);

  664. #endif

  665. #ifdef CARLA_ENGINE_RTAUDIO

  666.         if (type == CarlaEngineTypeRtAudio)

  667.             return bool(handle.rtAudioPtr);

  668. #endif

  669.     }

  670. 

  671.     return true;

  672. }

  673. 

  674. const CarlaEngineBasePort* CarlaEngineClient::addPort(const CarlaEnginePortType portType, const char* const name, const bool isInput)

  675. {

  676.     qDebug("CarlaEngineClient::addPort(%i, \"%s\", %s)", type, name, bool2str(isInput));

  677. 

  678.     CarlaEnginePortNativeHandle portHandle;

  679. #ifdef CARLA_ENGINE_JACK

  680.     portHandle.jackClient = handle.jackClient;

  681. #endif

  682. 

  683. #ifndef BUILD_BRIDGE

  684.     if (carlaOptions.processMode != PROCESS_MODE_CONTINUOUS_RACK)

  685. #endif

  686.     {

  687. #ifdef CARLA_ENGINE_JACK

  688.         if (type == CarlaEngineTypeJack)

  689.         {

  690.             switch (portType)

  691.             {

  692.             case CarlaEnginePortTypeAudio:

  693.                 portHandle.jackPort = jackbridge_port_register(handle.jackClient, name, JACK_DEFAULT_AUDIO_TYPE, isInput ? JackPortIsInput : JackPortIsOutput, 0);

  694.                 break;

  695.             case CarlaEnginePortTypeControl:

  696.             case CarlaEnginePortTypeMIDI:

  697.                 portHandle.jackPort = jackbridge_port_register(handle.jackClient, name, JACK_DEFAULT_MIDI_TYPE, isInput ? JackPortIsInput : JackPortIsOutput, 0);

  698.                 break;

  699.             }

  700.         }

  701. #endif

  702. 

  703. #ifdef CARLA_ENGINE_RTAUDIO

  704.         if (type == CarlaEngineTypeRtAudio)

  705.         {

  706.             // TODO

  707.         }

  708. #endif

  709.     }

  710. 

  711.     switch (portType)

  712.     {

  713.     case CarlaEnginePortTypeAudio:

  714.         return new CarlaEngineAudioPort(portHandle, isInput);

  715.     case CarlaEnginePortTypeControl:

  716.         return new CarlaEngineControlPort(portHandle, isInput);

  717.     case CarlaEnginePortTypeMIDI:

  718.         return new CarlaEngineMidiPort(portHandle, isInput);

  719.     }

  720. 

  721.     qCritical("CarlaEngineClient::addPort(%i, \"%s\", %s) - invalid type", type, name, bool2str(isInput));

  722.     return nullptr;

  723. }

  724. 

  725. // -------------------------------------------------------------------------------------------------------------------

  726. // Carla Engine Port (Base class)

  727. 

  728. CarlaEngineBasePort::CarlaEngineBasePort(const CarlaEnginePortNativeHandle& handle_, const bool isInput_)

  729.     : isInput(isInput_),

  730.       handle(handle_)

  731. {

  732.     qDebug("CarlaEngineBasePort::CarlaEngineBasePort(%s)", bool2str(isInput_));

  733. 

  734.     buffer = nullptr;

  735. }

  736. 

  737. CarlaEngineBasePort::~CarlaEngineBasePort()

  738. {

  739.     qDebug("CarlaEngineBasePort::~CarlaEngineBasePort()");

  740. 

  741. #ifndef BUILD_BRIDGE

  742.     if (carlaOptions.processMode == PROCESS_MODE_CONTINUOUS_RACK)

  743.         return;

  744. #endif

  745. 

  746. #ifdef CARLA_ENGINE_JACK

  747.     if (handle.jackClient && handle.jackPort)

  748.         jackbridge_port_unregister(handle.jackClient, handle.jackPort);

  749. #endif

  750. 

  751. #ifdef CARLA_ENGINE_RTAUDIO

  752.     // TODO

  753. #endif

  754. }

  755. 

  756. // -------------------------------------------------------------------------------------------------------------------

  757. // Carla Engine Port (Audio)

  758. 

  759. CarlaEngineAudioPort::CarlaEngineAudioPort(const CarlaEnginePortNativeHandle& handle, const bool isInput)

  760.     : CarlaEngineBasePort(handle, isInput)

  761. {

  762.     qDebug("CarlaEngineAudioPort::CarlaEngineAudioPort(%s)", bool2str(isInput));

  763. }

  764. 

  765. void CarlaEngineAudioPort::initBuffer(CarlaEngine* const /*engine*/)

  766. {

  767. }

  768. 

  769. #ifdef CARLA_ENGINE_JACK

  770. float* CarlaEngineAudioPort::getJackAudioBuffer(uint32_t nframes)

  771. {

  772. #  ifndef BUILD_BRIDGE

  773.     if (carlaOptions.processMode == PROCESS_MODE_CONTINUOUS_RACK)

  774.         return nullptr;

  775. #  endif

  776.     Q_ASSERT(handle.jackPort);

  777.     return (float*)jackbridge_port_get_buffer(handle.jackPort, nframes);

  778. }

  779. #endif

  780. 

  781. // -------------------------------------------------------------------------------------------------------------------

  782. // Carla Engine Port (Control)

  783. 

  784. CarlaEngineControlPort::CarlaEngineControlPort(const CarlaEnginePortNativeHandle& handle, const bool isInput)

  785.     : CarlaEngineBasePort(handle, isInput)

  786. {

  787.     qDebug("CarlaEngineControlPort::CarlaEngineControlPort(%s)", bool2str(isInput));

  788. }

  789. 

  790. void CarlaEngineControlPort::initBuffer(CarlaEngine* const engine)

  791. {

  792.     Q_ASSERT(engine);

  793. 

  794. #ifndef BUILD_BRIDGE

  795.     if (carlaOptions.processMode == PROCESS_MODE_CONTINUOUS_RACK)

  796.     {

  797.         buffer = isInput ? engine->rackControlEventsIn : engine->rackControlEventsOut;

  798.         return;

  799.     }

  800. #endif

  801. 

  802. #ifdef CARLA_ENGINE_JACK

  803.     if (handle.jackPort)

  804.     {

  805.         buffer = jackbridge_port_get_buffer(handle.jackPort, engine->getBufferSize());

  806. 

  807.         if (! isInput)

  808.             jackbridge_midi_clear_buffer(buffer);

  809.     }

  810. #endif

  811. 

  812. #ifdef CARLA_ENGINE_RTAUDIO

  813.     // TODO

  814. #endif

  815. }

  816. 

  817. uint32_t CarlaEngineControlPort::getEventCount()

  818. {

  819.     if (! isInput)

  820.         return 0;

  821. 

  822.     Q_ASSERT(buffer);

  823. 

  824. #ifndef BUILD_BRIDGE

  825.     if (carlaOptions.processMode == PROCESS_MODE_CONTINUOUS_RACK)

  826.     {

  827.         uint32_t count = 0;

  828.         const CarlaEngineControlEvent* const events = (CarlaEngineControlEvent*)buffer;

  829. 

  830.         for (unsigned short i=0; i < CarlaEngine::MAX_ENGINE_CONTROL_EVENTS; i++)

  831.         {

  832.             if (events[i].type != CarlaEngineEventNull)

  833.                 count++;

  834.             else

  835.                 break;

  836.         }

  837. 

  838.         return count;

  839.     }

  840. #endif

  841. 

  842. #ifdef CARLA_ENGINE_JACK

  843.     if (handle.jackPort)

  844.         return jackbridge_midi_get_event_count(buffer);

  845. #endif

  846. 

  847. #ifdef CARLA_ENGINE_RTAUDIO

  848.     // TODO

  849. #endif

  850. 

  851.     return 0;

  852. }

  853. 

  854. const CarlaEngineControlEvent* CarlaEngineControlPort::getEvent(uint32_t index)

  855. {

  856.     if (! isInput)

  857.         return nullptr;

  858. 

  859.     Q_ASSERT(buffer);

  860. 

  861. #ifndef BUILD_BRIDGE

  862.     Q_ASSERT(index < CarlaEngine::MAX_ENGINE_CONTROL_EVENTS);

  863. 

  864.     if (carlaOptions.processMode == PROCESS_MODE_CONTINUOUS_RACK)

  865.     {

  866.         const CarlaEngineControlEvent* const events = (CarlaEngineControlEvent*)buffer;

  867. 

  868.         if (index < CarlaEngine::MAX_ENGINE_CONTROL_EVENTS)

  869.             return &events[index];

  870.         return nullptr;

  871.     }

  872. #endif

  873. 

  874. #ifdef CARLA_ENGINE_JACK

  875.     if (handle.jackPort)

  876.     {

  877.         static jackbridge_midi_event_t jackEvent;

  878.         static CarlaEngineControlEvent carlaEvent;

  879. 

  880.         if (jackbridge_midi_event_get(&jackEvent, buffer, index) != 0)

  881.             return nullptr;

  882. 

  883.         memset(&carlaEvent, 0, sizeof(CarlaEngineControlEvent));

  884. 

  885.         uint8_t midiStatus  = jackEvent.buffer[0];

  886.         uint8_t midiChannel = midiStatus & 0x0F;

  887. 

  888.         carlaEvent.time    = jackEvent.time;

  889.         carlaEvent.channel = midiChannel;

  890. 

  891.         if (MIDI_IS_STATUS_CONTROL_CHANGE(midiStatus))

  892.         {

  893.             uint8_t midiControl = jackEvent.buffer[1];

  894. 

  895.             if (MIDI_IS_CONTROL_BANK_SELECT(midiControl))

  896.             {

  897.                 uint8_t midiBank = jackEvent.buffer[2];

  898.                 carlaEvent.type  = CarlaEngineEventMidiBankChange;

  899.                 carlaEvent.value = midiBank;

  900.             }

  901.             else if (midiControl == MIDI_CONTROL_ALL_SOUND_OFF)

  902.             {

  903.                 carlaEvent.type = CarlaEngineEventAllSoundOff;

  904.             }

  905.             else if (midiControl == MIDI_CONTROL_ALL_NOTES_OFF)

  906.             {

  907.                 carlaEvent.type = CarlaEngineEventAllNotesOff;

  908.             }

  909.             else

  910.             {

  911.                 uint8_t midiValue     = jackEvent.buffer[2];

  912.                 carlaEvent.type       = CarlaEngineEventControlChange;

  913.                 carlaEvent.controller = midiControl;

  914.                 carlaEvent.value      = double(midiValue)/127;

  915.             }

  916. 

  917.             return &carlaEvent;

  918.         }

  919.         else if (MIDI_IS_STATUS_PROGRAM_CHANGE(midiStatus))

  920.         {

  921.             uint8_t midiProgram = jackEvent.buffer[1];

  922.             carlaEvent.type  = CarlaEngineEventMidiProgramChange;

  923.             carlaEvent.value = midiProgram;

  924. 

  925.             return &carlaEvent;

  926.         }

  927.     }

  928. #endif

  929. 

  930. #ifdef CARLA_ENGINE_RTAUDIO

  931.     // TODO

  932. #endif

  933. 

  934.     return nullptr;

  935. }

  936. 

  937. void CarlaEngineControlPort::writeEvent(CarlaEngineControlEventType type, uint32_t time, uint8_t channel, uint8_t controller, double value)

  938. {

  939.     if (isInput)

  940.         return;

  941. 

  942.     Q_ASSERT(buffer);

  943.     Q_ASSERT(type != CarlaEngineEventNull);

  944. 

  945. #ifndef BUILD_BRIDGE

  946.     if (carlaOptions.processMode == PROCESS_MODE_CONTINUOUS_RACK)

  947.     {

  948.         CarlaEngineControlEvent* const events = (CarlaEngineControlEvent*)buffer;

  949. 

  950.         for (unsigned short i=0; i < CarlaEngine::MAX_ENGINE_CONTROL_EVENTS; i++)

  951.         {

  952.             if (events[i].type == CarlaEngineEventNull)

  953.             {

  954.                 events[i].type  = type;

  955.                 events[i].time  = time;

  956.                 events[i].value = value;

  957.                 events[i].channel    = channel;

  958.                 events[i].controller = controller;

  959.                 break;

  960.             }

  961.         }

  962. 

  963.         return;

  964.     }

  965. #endif

  966. 

  967. #ifdef CARLA_ENGINE_JACK

  968.     if (handle.jackPort)

  969.     {

  970.         if (type == CarlaEngineEventControlChange && MIDI_IS_CONTROL_BANK_SELECT(controller))

  971.             type = CarlaEngineEventMidiBankChange;

  972. 

  973.         uint8_t data[4] = { 0 };

  974. 

  975.         switch (type)

  976.         {

  977.         case CarlaEngineEventNull:

  978.             break;

  979.         case CarlaEngineEventControlChange:

  980.             data[0] = MIDI_STATUS_CONTROL_CHANGE + channel;

  981.             data[1] = controller;

  982.             data[2] = value * 127;

  983.             jackbridge_midi_event_write(buffer, time, data, 3);

  984.             break;

  985.         case CarlaEngineEventMidiBankChange:

  986.             data[0] = MIDI_STATUS_CONTROL_CHANGE + channel;

  987.             data[1] = MIDI_CONTROL_BANK_SELECT;

  988.             data[2] = value;

  989.             jackbridge_midi_event_write(buffer, time, data, 3);

  990.             break;

  991.         case CarlaEngineEventMidiProgramChange:

  992.             data[0] = MIDI_STATUS_PROGRAM_CHANGE + channel;

  993.             data[1] = value;

  994.             jackbridge_midi_event_write(buffer, time, data, 2);

  995.             break;

  996.         case CarlaEngineEventAllSoundOff:

  997.             data[0] = MIDI_STATUS_CONTROL_CHANGE + channel;

  998.             data[1] = MIDI_CONTROL_ALL_SOUND_OFF;

  999.             jackbridge_midi_event_write(buffer, time, data, 2);

  1000.             break;

  1001.         case CarlaEngineEventAllNotesOff:

  1002.             data[0] = MIDI_STATUS_CONTROL_CHANGE + channel;

  1003.             data[1] = MIDI_CONTROL_ALL_NOTES_OFF;

  1004.             jackbridge_midi_event_write(buffer, time, data, 2);

  1005.             break;

  1006.         }

  1007.     }

  1008. #endif

  1009. 

  1010. #ifdef CARLA_ENGINE_RTAUDIO

  1011.     // TODO

  1012. #endif

  1013. }

  1014. 

  1015. // -------------------------------------------------------------------------------------------------------------------

  1016. // Carla Engine Port (MIDI)

  1017. 

  1018. CarlaEngineMidiPort::CarlaEngineMidiPort(const CarlaEnginePortNativeHandle& handle, const bool isInput)

  1019.     : CarlaEngineBasePort(handle, isInput)

  1020. {

  1021.     qDebug("CarlaEngineMidiPort::CarlaEngineMidiPort(%s)", bool2str(isInput));

  1022. }

  1023. 

  1024. void CarlaEngineMidiPort::initBuffer(CarlaEngine* const engine)

  1025. {

  1026.     Q_ASSERT(engine);

  1027. 

  1028. #ifndef BUILD_BRIDGE

  1029.     if (carlaOptions.processMode == PROCESS_MODE_CONTINUOUS_RACK)

  1030.     {

  1031.         buffer = isInput ? engine->rackMidiEventsIn : engine->rackMidiEventsOut;

  1032.         return;

  1033.     }

  1034. #endif

  1035. 

  1036. #ifdef CARLA_ENGINE_JACK

  1037.     if (handle.jackPort)

  1038.     {

  1039.         buffer = jackbridge_port_get_buffer(handle.jackPort, engine->getBufferSize());

  1040. 

  1041.         if (! isInput)

  1042.             jackbridge_midi_clear_buffer(buffer);

  1043.     }

  1044. #endif

  1045. 

  1046. #ifdef CARLA_ENGINE_RTAUDIO

  1047.     // TODO

  1048. #endif

  1049. }

  1050. 

  1051. uint32_t CarlaEngineMidiPort::getEventCount()

  1052. {

  1053.     if (! isInput)

  1054.         return 0;

  1055. 

  1056.     Q_ASSERT(buffer);

  1057. 

  1058. #ifndef BUILD_BRIDGE

  1059.     if (carlaOptions.processMode == PROCESS_MODE_CONTINUOUS_RACK)

  1060.     {

  1061.         uint32_t count = 0;

  1062.         const CarlaEngineMidiEvent* const events = (CarlaEngineMidiEvent*)buffer;

  1063. 

  1064.         for (unsigned short i=0; i < CarlaEngine::MAX_ENGINE_MIDI_EVENTS; i++)

  1065.         {

  1066.             if (events[i].size > 0)

  1067.                 count++;

  1068.             else

  1069.                 break;

  1070.         }

  1071. 

  1072.         return count;

  1073.     }

  1074. #endif

  1075. 

  1076. #ifdef CARLA_ENGINE_JACK

  1077.     if (handle.jackPort)

  1078.         return jackbridge_midi_get_event_count(buffer);

  1079. #endif

  1080. 

  1081. #ifdef CARLA_ENGINE_RTAUDIO

  1082.     // TODO

  1083. #endif

  1084. 

  1085.     return 0;

  1086. }

  1087. 

  1088. const CarlaEngineMidiEvent* CarlaEngineMidiPort::getEvent(uint32_t index)

  1089. {

  1090.     if (! isInput)

  1091.         return nullptr;

  1092. 

  1093.     Q_ASSERT(buffer);

  1094. 

  1095. #ifndef BUILD_BRIDGE

  1096.     Q_ASSERT(index < CarlaEngine::MAX_ENGINE_MIDI_EVENTS);

  1097. 

  1098.     if (carlaOptions.processMode == PROCESS_MODE_CONTINUOUS_RACK)

  1099.     {

  1100.         const CarlaEngineMidiEvent* const events = (CarlaEngineMidiEvent*)buffer;

  1101. 

  1102.         if (index < CarlaEngine::MAX_ENGINE_MIDI_EVENTS)

  1103.             return &events[index];

  1104. 

  1105.         return nullptr;

  1106.     }

  1107. #endif

  1108. 

  1109. #ifdef CARLA_ENGINE_JACK

  1110.     if (handle.jackPort)

  1111.     {

  1112.         static jackbridge_midi_event_t jackEvent;

  1113.         static CarlaEngineMidiEvent carlaEvent;

  1114. 

  1115.         if (jackbridge_midi_event_get(&jackEvent, buffer, index) == 0 && jackEvent.size <= 4)

  1116.         {

  1117.             carlaEvent.time = jackEvent.time;

  1118.             carlaEvent.size = jackEvent.size;

  1119.             memcpy(carlaEvent.data, jackEvent.buffer, jackEvent.size);

  1120.             return &carlaEvent;

  1121.         }

  1122.     }

  1123. #endif

  1124. 

  1125. #ifdef CARLA_ENGINE_RTAUDIO

  1126.     // TODO

  1127. #endif

  1128. 

  1129.     return nullptr;

  1130. }

  1131. 

  1132. void CarlaEngineMidiPort::writeEvent(uint32_t time, const uint8_t* data, uint8_t size)

  1133. {

  1134.     if (isInput)

  1135.         return;

  1136. 

  1137.     Q_ASSERT(buffer);

  1138.     Q_ASSERT(data);

  1139.     Q_ASSERT(size > 0);

  1140. 

  1141. #ifndef BUILD_BRIDGE

  1142.     if (carlaOptions.processMode == PROCESS_MODE_CONTINUOUS_RACK)

  1143.     {

  1144.         if (size > 4)

  1145.             return;

  1146. 

  1147.         CarlaEngineMidiEvent* const events = (CarlaEngineMidiEvent*)buffer;

  1148. 

  1149.         for (unsigned short i=0; i < CarlaEngine::MAX_ENGINE_MIDI_EVENTS; i++)

  1150.         {

  1151.             if (events[i].size == 0)

  1152.             {

  1153.                 events[i].time = time;

  1154.                 events[i].size = size;

  1155.                 memcpy(events[i].data, data, size);

  1156.                 break;

  1157.             }

  1158.         }

  1159. 

  1160.         return;

  1161.     }

  1162. #endif

  1163. 

  1164. #ifdef CARLA_ENGINE_JACK

  1165.     if (handle.jackPort)

  1166.         jackbridge_midi_event_write(buffer, time, data, size);

  1167. #endif

  1168. 

  1169. #ifdef CARLA_ENGINE_RTAUDIO

  1170.     // TODO

  1171. #endif

  1172. }

  1173. 

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

  1175. // Carla Engine OSC stuff

  1176. 

  1177. #ifndef BUILD_BRIDGE

  1178. void CarlaEngine::osc_send_control_add_plugin(const int32_t pluginId, const char* const pluginName)

  1179. {

  1180.     qDebug("CarlaEngine::osc_send_control_add_plugin(%i, \"%s\")", pluginId, pluginName);

  1181.     Q_ASSERT(m_oscData);

  1182.     Q_ASSERT(pluginId >= 0 && pluginId < m_maxPluginNumber);

  1183.     Q_ASSERT(pluginName);

  1184. 

  1185.     if (m_oscData && m_oscData->target)

  1186.     {

  1187.         char target_path[strlen(m_oscData->path)+12];

  1188.         strcpy(target_path, m_oscData->path);

  1189.         strcat(target_path, "/add_plugin");

  1190.         lo_send(m_oscData->target, target_path, "is", pluginId, pluginName);

  1191.     }

  1192. }

  1193. 

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

  1195. {

  1196.     qDebug("CarlaEngine::osc_send_control_remove_plugin(%i)", pluginId);

  1197.     Q_ASSERT(m_oscData);

  1198. 

  1199.     if (m_oscData && m_oscData->target)

  1200.     {

  1201.         char target_path[strlen(m_oscData->path)+15];

  1202.         strcpy(target_path, m_oscData->path);

  1203.         strcat(target_path, "/remove_plugin");

  1204.         lo_send(m_oscData->target, target_path, "i", pluginId);

  1205.     }

  1206. }

  1207. 

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

  1209. {

  1210.     qDebug("CarlaEngine::osc_send_control_set_plugin_data(%i, %i, %i, %i, \"%s\", \"%s\", \"%s\", \"%s\", %li)", pluginId, type, category, hints, realName, label, maker, copyright, uniqueId);

  1211.     Q_ASSERT(m_oscData);

  1212.     Q_ASSERT(pluginId >= 0 && pluginId < m_maxPluginNumber);

  1213.     Q_ASSERT(type != PLUGIN_NONE);

  1214. 

  1215.     if (m_oscData && m_oscData->target)

  1216.     {

  1217.         char target_path[strlen(m_oscData->path)+17];

  1218.         strcpy(target_path, m_oscData->path);

  1219.         strcat(target_path, "/set_plugin_data");

  1220.         lo_send(m_oscData->target, target_path, "iiiissssh", pluginId, type, category, hints, realName, label, maker, copyright, uniqueId);

  1221.     }

  1222. }

  1223. 

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

  1225. {

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

  1227.     Q_ASSERT(m_oscData);

  1228.     Q_ASSERT(pluginId >= 0 && pluginId < m_maxPluginNumber);

  1229. 

  1230.     if (m_oscData && m_oscData->target)

  1231.     {

  1232.         char target_path[strlen(m_oscData->path)+18];

  1233.         strcpy(target_path, m_oscData->path);

  1234.         strcat(target_path, "/set_plugin_ports");

  1235.         lo_send(m_oscData->target, target_path, "iiiiiiii", pluginId, audioIns, audioOuts, midiIns, midiOuts, cIns, cOuts, cTotals);

  1236.     }

  1237. }

  1238. 

  1239. 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 double current)

  1240. {

  1241.     qDebug("CarlaEngine::osc_send_control_set_parameter_data(%i, %i, %i, %i, \"%s\", \"%s\", %g)", pluginId, index, type, hints, name, label, current);

  1242.     Q_ASSERT(m_oscData);

  1243.     Q_ASSERT(pluginId >= 0 && pluginId < m_maxPluginNumber);

  1244.     Q_ASSERT(index >= 0);

  1245.     Q_ASSERT(type != PARAMETER_UNKNOWN);

  1246. 

  1247.     if (m_oscData && m_oscData->target)

  1248.     {

  1249.         char target_path[strlen(m_oscData->path)+20];

  1250.         strcpy(target_path, m_oscData->path);

  1251.         strcat(target_path, "/set_parameter_data");

  1252.         lo_send(m_oscData->target, target_path, "iiiissd", pluginId, index, type, hints, name, label, current);

  1253.     }

  1254. }

  1255. 

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

  1257. {

  1258.     qDebug("CarlaEngine::osc_send_control_set_parameter_ranges(%i, %i, %g, %g, %g, %g, %g, %g)", pluginId, index, min, max, def, step, stepSmall, stepLarge);

  1259.     Q_ASSERT(m_oscData);

  1260.     Q_ASSERT(pluginId >= 0 && pluginId < m_maxPluginNumber);

  1261.     Q_ASSERT(index >= 0);

  1262.     Q_ASSERT(min < max);

  1263. 

  1264.     if (m_oscData && m_oscData->target)

  1265.     {

  1266.         char target_path[strlen(m_oscData->path)+22];

  1267.         strcpy(target_path, m_oscData->path);

  1268.         strcat(target_path, "/set_parameter_ranges");

  1269.         lo_send(m_oscData->target, target_path, "iidddddd", pluginId, index, min, max, def, step, stepSmall, stepLarge);

  1270.     }

  1271. }

  1272. 

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

  1274. {

  1275.     qDebug("CarlaEngine::osc_send_control_set_parameter_midi_cc(%i, %i, %i)", pluginId, index, cc);

  1276.     Q_ASSERT(m_oscData);

  1277.     Q_ASSERT(pluginId >= 0 && pluginId < m_maxPluginNumber);

  1278.     Q_ASSERT(index >= 0);

  1279. 

  1280.     if (m_oscData && m_oscData->target)

  1281.     {

  1282.         char target_path[strlen(m_oscData->path)+23];

  1283.         strcpy(target_path, m_oscData->path);

  1284.         strcat(target_path, "/set_parameter_midi_cc");

  1285.         lo_send(m_oscData->target, target_path, "iii", pluginId, index, cc);

  1286.     }

  1287. }

  1288. 

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

  1290. {

  1291.     qDebug("CarlaEngine::osc_send_control_set_parameter_midi_channel(%i, %i, %i)", pluginId, index, channel);

  1292.     Q_ASSERT(m_oscData);

  1293.     Q_ASSERT(pluginId >= 0 && pluginId < m_maxPluginNumber);

  1294.     Q_ASSERT(index >= 0);

  1295.     Q_ASSERT(channel >= 0 && channel < 16);

  1296. 

  1297.     if (m_oscData && m_oscData->target)

  1298.     {

  1299.         char target_path[strlen(m_oscData->path)+28];

  1300.         strcpy(target_path, m_oscData->path);

  1301.         strcat(target_path, "/set_parameter_midi_channel");

  1302.         lo_send(m_oscData->target, target_path, "iii", pluginId, index, channel);

  1303.     }

  1304. }

  1305. 

  1306. void CarlaEngine::osc_send_control_set_parameter_value(const int32_t pluginId, const int32_t index, const double value)

  1307. {

  1308. #if DEBUG

  1309.     if (index < -1)

  1310.         qDebug("CarlaEngine::osc_send_control_set_parameter_value(%i, %s, %g)", pluginId, InternalParametersIndex2str((InternalParametersIndex)index), value);

  1311.     else

  1312.         qDebug("CarlaEngine::osc_send_control_set_parameter_value(%i, %i, %g)", pluginId, index, value);

  1313. #endif

  1314.     Q_ASSERT(m_oscData);

  1315.     Q_ASSERT(pluginId >= 0 && pluginId < m_maxPluginNumber);

  1316. 

  1317.     if (m_oscData && m_oscData->target)

  1318.     {

  1319.         char target_path[strlen(m_oscData->path)+21];

  1320.         strcpy(target_path, m_oscData->path);

  1321.         strcat(target_path, "/set_parameter_value");

  1322.         lo_send(m_oscData->target, target_path, "iid", pluginId, index, value);

  1323.     }

  1324. }

  1325. 

  1326. void CarlaEngine::osc_send_control_set_default_value(const int32_t pluginId, const int32_t index, const double value)

  1327. {

  1328.     qDebug("CarlaEngine::osc_send_control_set_default_value(%i, %i, %g)", pluginId, index, value);

  1329.     Q_ASSERT(m_oscData);

  1330.     Q_ASSERT(pluginId >= 0 && pluginId < m_maxPluginNumber);

  1331.     Q_ASSERT(index >= 0);

  1332. 

  1333.     if (m_oscData && m_oscData->target)

  1334.     {

  1335.         char target_path[strlen(m_oscData->path)+19];

  1336.         strcpy(target_path, m_oscData->path);

  1337.         strcat(target_path, "/set_default_value");

  1338.         lo_send(m_oscData->target, target_path, "iid", pluginId, index, value);

  1339.     }

  1340. }

  1341. 

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

  1343. {

  1344.     qDebug("CarlaEngine::osc_send_control_set_program(%i, %i)", pluginId, index);

  1345.     Q_ASSERT(m_oscData);

  1346.     Q_ASSERT(pluginId >= 0 && pluginId < m_maxPluginNumber);

  1347. 

  1348.     if (m_oscData && m_oscData->target)

  1349.     {

  1350.         char target_path[strlen(m_oscData->path)+13];

  1351.         strcpy(target_path, m_oscData->path);

  1352.         strcat(target_path, "/set_program");

  1353.         lo_send(m_oscData->target, target_path, "ii", pluginId, index);

  1354.     }

  1355. }

  1356. 

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

  1358. {

  1359.     qDebug("CarlaEngine::osc_send_control_set_program_count(%i, %i)", pluginId, count);

  1360.     Q_ASSERT(m_oscData);

  1361.     Q_ASSERT(pluginId >= 0 && pluginId < m_maxPluginNumber);

  1362.     Q_ASSERT(count >= 0);

  1363. 

  1364.     if (m_oscData && m_oscData->target)

  1365.     {

  1366.         char target_path[strlen(m_oscData->path)+19];

  1367.         strcpy(target_path, m_oscData->path);

  1368.         strcat(target_path, "/set_program_count");

  1369.         lo_send(m_oscData->target, target_path, "ii", pluginId, count);

  1370.     }

  1371. }

  1372. 

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

  1374. {

  1375.     qDebug("CarlaEngine::osc_send_control_set_program_name(%i, %i, %s)", pluginId, index, name);

  1376.     Q_ASSERT(m_oscData);

  1377.     Q_ASSERT(pluginId >= 0 && pluginId < m_maxPluginNumber);

  1378.     Q_ASSERT(index >= 0);

  1379.     Q_ASSERT(name);

  1380. 

  1381.     if (m_oscData && m_oscData->target)

  1382.     {

  1383.         char target_path[strlen(m_oscData->path)+18];

  1384.         strcpy(target_path, m_oscData->path);

  1385.         strcat(target_path, "/set_program_name");

  1386.         lo_send(m_oscData->target, target_path, "iis", pluginId, index, name);

  1387.     }

  1388. }

  1389. 

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

  1391. {

  1392.     qDebug("CarlaEngine::osc_send_control_set_midi_program(%i, %i)", pluginId, index);

  1393.     Q_ASSERT(m_oscData);

  1394.     Q_ASSERT(pluginId >= 0 && pluginId < m_maxPluginNumber);

  1395. 

  1396.     if (m_oscData && m_oscData->target)

  1397.     {

  1398.         char target_path[strlen(m_oscData->path)+18];

  1399.         strcpy(target_path, m_oscData->path);

  1400.         strcat(target_path, "/set_midi_program");

  1401.         lo_send(m_oscData->target, target_path, "ii", pluginId, index);

  1402.     }

  1403. }

  1404. 

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

  1406. {

  1407.     qDebug("CarlaEngine::osc_send_control_set_midi_program_count(%i, %i)", pluginId, count);

  1408.     Q_ASSERT(m_oscData);

  1409.     Q_ASSERT(pluginId >= 0 && pluginId < m_maxPluginNumber);

  1410.     Q_ASSERT(count >= 0);

  1411. 

  1412.     if (m_oscData && m_oscData->target)

  1413.     {

  1414.         char target_path[strlen(m_oscData->path)+24];

  1415.         strcpy(target_path, m_oscData->path);

  1416.         strcat(target_path, "/set_midi_program_count");

  1417.         lo_send(m_oscData->target, target_path, "ii", pluginId, count);

  1418.     }

  1419. }

  1420. 

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

  1422. {

  1423.     qDebug("CarlaEngine::osc_send_control_set_midi_program_data(%i, %i, %i, %i, %s)", pluginId, index, bank, program, name);

  1424.     Q_ASSERT(m_oscData);

  1425.     Q_ASSERT(pluginId >= 0 && pluginId < m_maxPluginNumber);

  1426.     Q_ASSERT(index >= 0);

  1427.     Q_ASSERT(bank >= 0);

  1428.     Q_ASSERT(program >= 0);

  1429.     Q_ASSERT(name);

  1430. 

  1431.     if (m_oscData && m_oscData->target)

  1432.     {

  1433.         char target_path[strlen(m_oscData->path)+23];

  1434.         strcpy(target_path, m_oscData->path);

  1435.         strcat(target_path, "/set_midi_program_data");

  1436.         lo_send(m_oscData->target, target_path, "iiiis", pluginId, index, bank, program, name);

  1437.     }

  1438. }

  1439. 

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

  1441. {

  1442.     qDebug("CarlaEngine::osc_send_control_note_on(%i, %i, %i, %i)", pluginId, channel, note, velo);

  1443.     Q_ASSERT(m_oscData);

  1444.     Q_ASSERT(pluginId >= 0 && pluginId < m_maxPluginNumber);

  1445.     Q_ASSERT(channel >= 0 && channel < 16);

  1446.     Q_ASSERT(note >= 0 && note < 128);

  1447.     Q_ASSERT(velo > 0 && velo < 128);

  1448. 

  1449.     if (m_oscData && m_oscData->target)

  1450.     {

  1451.         char target_path[strlen(m_oscData->path)+9];

  1452.         strcpy(target_path, m_oscData->path);

  1453.         strcat(target_path, "/note_on");

  1454.         lo_send(m_oscData->target, target_path, "iiii", pluginId, channel, note, velo);

  1455.     }

  1456. }

  1457. 

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

  1459. {

  1460.     qDebug("CarlaEngine::osc_send_control_note_off(%i, %i, %i)", pluginId, channel, note);

  1461.     Q_ASSERT(m_oscData);

  1462.     Q_ASSERT(pluginId >= 0 && pluginId < m_maxPluginNumber);

  1463.     Q_ASSERT(channel >= 0 && channel < 16);

  1464.     Q_ASSERT(note >= 0 && note < 128);

  1465. 

  1466.     if (m_oscData && m_oscData->target)

  1467.     {

  1468.         char target_path[strlen(m_oscData->path)+10];

  1469.         strcpy(target_path, m_oscData->path);

  1470.         strcat(target_path, "/note_off");

  1471.         lo_send(m_oscData->target, target_path, "iii", pluginId, channel, note);

  1472.     }

  1473. }

  1474. 

  1475. void CarlaEngine::osc_send_control_set_input_peak_value(const int32_t pluginId, const int32_t portId, const double value)

  1476. {

  1477.     qDebug("CarlaEngine::osc_send_control_set_input_peak_value(%i, %i, %g)", pluginId, portId, value);

  1478.     Q_ASSERT(m_oscData);

  1479.     Q_ASSERT(pluginId >= 0 && pluginId < m_maxPluginNumber);

  1480.     Q_ASSERT(portId == 1 || portId == 2);

  1481. 

  1482.     if (m_oscData && m_oscData->target)

  1483.     {

  1484.         char target_path[strlen(m_oscData->path)+22];

  1485.         strcpy(target_path, m_oscData->path);

  1486.         strcat(target_path, "/set_input_peak_value");

  1487.         lo_send(m_oscData->target, target_path, "iid", pluginId, portId, value);

  1488.     }

  1489. }

  1490. 

  1491. void CarlaEngine::osc_send_control_set_output_peak_value(const int32_t pluginId, const int32_t portId, const double value)

  1492. {

  1493.     qDebug("CarlaEngine::osc_send_control_set_output_peak_value(%i, %i, %g)", pluginId, portId, value);

  1494.     Q_ASSERT(m_oscData);

  1495.     Q_ASSERT(pluginId >= 0 && pluginId < m_maxPluginNumber);

  1496.     Q_ASSERT(portId == 1 || portId == 2);

  1497. 

  1498.     if (m_oscData && m_oscData->target)

  1499.     {

  1500.         char target_path[strlen(m_oscData->path)+23];

  1501.         strcpy(target_path, m_oscData->path);

  1502.         strcat(target_path, "/set_output_peak_value");

  1503.         lo_send(m_oscData->target, target_path, "iid", pluginId, portId, value);

  1504.     }

  1505. }

  1506. 

  1507. void CarlaEngine::osc_send_control_exit()

  1508. {

  1509.     qDebug("CarlaEngine::osc_send_control_exit()");

  1510.     Q_ASSERT(m_oscData);

  1511. 

  1512.     if (m_oscData && m_oscData->target)

  1513.     {

  1514.         char target_path[strlen(m_oscData->path)+6];

  1515.         strcpy(target_path, m_oscData->path);

  1516.         strcat(target_path, "/exit");

  1517.         lo_send(m_oscData->target, target_path, "");

  1518.     }

  1519. }

  1520. #else

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

  1522. {

  1523.     qDebug("CarlaEngine::osc_send_bridge_audio_count(%i, %i, %i)", ins, outs, total);

  1524.     Q_ASSERT(m_oscData);

  1525.     Q_ASSERT(total >= 0 && total >= ins + outs);

  1526. 

  1527.     if (m_oscData && m_oscData->target)

  1528.     {

  1529.         char target_path[strlen(m_oscData->path)+20];

  1530.         strcpy(target_path, m_oscData->path);

  1531.         strcat(target_path, "/bridge_audio_count");

  1532.         lo_send(m_oscData->target, target_path, "iii", ins, outs, total);

  1533.     }

  1534. }

  1535. 

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

  1537. {

  1538.     qDebug("CarlaEngine::osc_send_bridge_midi_count(%i, %i, %i)", ins, outs, total);

  1539.     Q_ASSERT(m_oscData);

  1540.     Q_ASSERT(total >= 0 && total >= ins + outs);

  1541. 

  1542.     if (m_oscData && m_oscData->target)

  1543.     {

  1544.         char target_path[strlen(m_oscData->path)+19];

  1545.         strcpy(target_path, m_oscData->path);

  1546.         strcat(target_path, "/bridge_midi_count");

  1547.         lo_send(m_oscData->target, target_path, "iii", ins, outs, total);

  1548.     }

  1549. }

  1550. 

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

  1552. {

  1553.     qDebug("CarlaEngine::osc_send_bridge_parameter_count(%i, %i, %i)", ins, outs, total);

  1554.     Q_ASSERT(m_oscData);

  1555.     Q_ASSERT(total >= 0 && total >= ins + outs);

  1556. 

  1557.     if (m_oscData && m_oscData->target)

  1558.     {

  1559.         char target_path[strlen(m_oscData->path)+24];

  1560.         strcpy(target_path, m_oscData->path);

  1561.         strcat(target_path, "/bridge_parameter_count");

  1562.         lo_send(m_oscData->target, target_path, "iii", ins, outs, total);

  1563.     }

  1564. }

  1565. 

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

  1567. {

  1568.     qDebug("CarlaEngine::osc_send_bridge_program_count(%i)", count);

  1569.     Q_ASSERT(m_oscData);

  1570.     Q_ASSERT(count >= 0);

  1571. 

  1572.     if (m_oscData && m_oscData->target)

  1573.     {

  1574.         char target_path[strlen(m_oscData->path)+22];

  1575.         strcpy(target_path, m_oscData->path);

  1576.         strcat(target_path, "/bridge_program_count");

  1577.         lo_send(m_oscData->target, target_path, "i", count);

  1578.     }

  1579. }

  1580. 

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

  1582. {

  1583.     qDebug("CarlaEngine::osc_send_bridge_midi_program_count(%i)", count);

  1584.     Q_ASSERT(m_oscData);

  1585.     Q_ASSERT(count >= 0);

  1586. 

  1587.     if (m_oscData && m_oscData->target)

  1588.     {

  1589.         char target_path[strlen(m_oscData->path)+27];

  1590.         strcpy(target_path, m_oscData->path);

  1591.         strcat(target_path, "/bridge_midi_program_count");

  1592.         lo_send(m_oscData->target, target_path, "i", count);

  1593.     }

  1594. }

  1595. 

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

  1597. {

  1598.     qDebug("CarlaEngine::osc_send_bridge_plugin_info(%i, %i, \"%s\", \"%s\", \"%s\", \"%s\", %li)", category, hints, name, label, maker, copyright, uniqueId);

  1599.     Q_ASSERT(m_oscData);

  1600.     Q_ASSERT(name);

  1601.     Q_ASSERT(label);

  1602.     Q_ASSERT(maker);

  1603.     Q_ASSERT(copyright);

  1604. 

  1605.     if (m_oscData && m_oscData->target)

  1606.     {

  1607.         char target_path[strlen(m_oscData->path)+20];

  1608.         strcpy(target_path, m_oscData->path);

  1609.         strcat(target_path, "/bridge_plugin_info");

  1610.         lo_send(m_oscData->target, target_path, "iissssh", category, hints, name, label, maker, copyright, uniqueId);

  1611.     }

  1612. }

  1613. 

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

  1615. {

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

  1617.     Q_ASSERT(m_oscData);

  1618.     Q_ASSERT(name);

  1619.     Q_ASSERT(unit);

  1620. 

  1621.     if (m_oscData && m_oscData->target)

  1622.     {

  1623.         char target_path[strlen(m_oscData->path)+23];

  1624.         strcpy(target_path, m_oscData->path);

  1625.         strcat(target_path, "/bridge_parameter_info");

  1626.         lo_send(m_oscData->target, target_path, "iss", index, name, unit);

  1627.     }

  1628. }

  1629. 

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

  1631. {

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

  1633.     Q_ASSERT(m_oscData);

  1634. 

  1635.     if (m_oscData && m_oscData->target)

  1636.     {

  1637.         char target_path[strlen(m_oscData->path)+23];

  1638.         strcpy(target_path, m_oscData->path);

  1639.         strcat(target_path, "/bridge_parameter_data");

  1640.         lo_send(m_oscData->target, target_path, "iiiiii", index, type, rindex, hints, midiChannel, midiCC);

  1641.     }

  1642. }

  1643. 

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

  1645. {

  1646.     qDebug("CarlaEngine::osc_send_bridge_parameter_ranges(%i, %g, %g, %g, %g, %g, %g)", index, def, min, max, step, stepSmall, stepLarge);

  1647.     Q_ASSERT(m_oscData);

  1648. 

  1649.     if (m_oscData && m_oscData->target)

  1650.     {

  1651.         char target_path[strlen(m_oscData->path)+25];

  1652.         strcpy(target_path, m_oscData->path);

  1653.         strcat(target_path, "/bridge_parameter_ranges");

  1654.         lo_send(m_oscData->target, target_path, "idddddd", index, def, min, max, step, stepSmall, stepLarge);

  1655.     }

  1656. }

  1657. 

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

  1659. {

  1660.     qDebug("CarlaEngine::osc_send_bridge_program_info(%i, \"%s\")", index, name);

  1661.     Q_ASSERT(m_oscData);

  1662. 

  1663.     if (m_oscData && m_oscData->target)

  1664.     {

  1665.         char target_path[strlen(m_oscData->path)+21];

  1666.         strcpy(target_path, m_oscData->path);

  1667.         strcat(target_path, "/bridge_program_info");

  1668.         lo_send(m_oscData->target, target_path, "is", index, name);

  1669.     }

  1670. }

  1671. 

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

  1673. {

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

  1675.     Q_ASSERT(m_oscData);

  1676. 

  1677.     if (m_oscData && m_oscData->target)

  1678.     {

  1679.         char target_path[strlen(m_oscData->path)+26];

  1680.         strcpy(target_path, m_oscData->path);

  1681.         strcat(target_path, "/bridge_midi_program_info");

  1682.         lo_send(m_oscData->target, target_path, "iiis", index, bank, program, label);

  1683.     }

  1684. }

  1685. 

  1686. void CarlaEngine::osc_send_bridge_set_parameter_value(const int32_t index, const double value)

  1687. {

  1688.     qDebug("CarlaEngine::osc_send_bridge_set_parameter_value(%i, %g)", index, value);

  1689.     Q_ASSERT(m_oscData);

  1690. 

  1691.     if (m_oscData && m_oscData->target)

  1692.     {

  1693.         char target_path[strlen(m_oscData->path)+28];

  1694.         strcpy(target_path, m_oscData->path);

  1695.         strcat(target_path, "/bridge_set_parameter_value");

  1696.         lo_send(m_oscData->target, target_path, "id", index, value);

  1697.     }

  1698. }

  1699. 

  1700. void CarlaEngine::osc_send_bridge_set_default_value(const int32_t index, const double value)

  1701. {

  1702.     qDebug("CarlaEngine::osc_send_bridge_set_default_value(%i, %g)", index, value);

  1703.     Q_ASSERT(m_oscData);

  1704. 

  1705.     if (m_oscData && m_oscData->target)

  1706.     {

  1707.         char target_path[strlen(m_oscData->path)+26];

  1708.         strcpy(target_path, m_oscData->path);

  1709.         strcat(target_path, "/bridge_set_default_value");

  1710.         lo_send(m_oscData->target, target_path, "id", index, value);

  1711.     }

  1712. }

  1713. 

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

  1715. {

  1716.     qDebug("CarlaEngine::osc_send_bridge_set_program(%i)", index);

  1717.     Q_ASSERT(m_oscData);

  1718. 

  1719.     if (m_oscData && m_oscData->target)

  1720.     {

  1721.         char target_path[strlen(m_oscData->path)+20];

  1722.         strcpy(target_path, m_oscData->path);

  1723.         strcat(target_path, "/bridge_set_program");

  1724.         lo_send(m_oscData->target, target_path, "i", index);

  1725.     }

  1726. }

  1727. 

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

  1729. {

  1730.     qDebug("CarlaEngine::osc_send_bridge_set_midi_program(%i)", index);

  1731.     Q_ASSERT(m_oscData);

  1732. 

  1733.     if (m_oscData && m_oscData->target)

  1734.     {

  1735.         char target_path[strlen(m_oscData->path)+25];

  1736.         strcpy(target_path, m_oscData->path);

  1737.         strcat(target_path, "/bridge_set_midi_program");

  1738.         lo_send(m_oscData->target, target_path, "i", index);

  1739.     }

  1740. }

  1741. 

  1742. void CarlaEngine::osc_send_bridge_set_input_peak_value(const int32_t portId, const double value)

  1743. {

  1744.     Q_ASSERT(m_oscData);

  1745.     Q_ASSERT(portId == 1 || portId == 2);

  1746. 

  1747.     if (m_oscData && m_oscData->target)

  1748.     {

  1749.         char target_path[strlen(m_oscData->path)+28];

  1750.         strcpy(target_path, m_oscData->path);

  1751.         strcat(target_path, "/bridge_set_input_peak_value");

  1752.         lo_send(m_oscData->target, target_path, "id", portId, value);

  1753.     }

  1754. }

  1755. 

  1756. void CarlaEngine::osc_send_bridge_set_output_peak_value(const int32_t portId, const double value)

  1757. {

  1758.     Q_ASSERT(m_oscData);

  1759.     Q_ASSERT(portId == 1 || portId == 2);

  1760. 

  1761.     if (m_oscData && m_oscData->target)

  1762.     {

  1763.         char target_path[strlen(m_oscData->path)+29];

  1764.         strcpy(target_path, m_oscData->path);

  1765.         strcat(target_path, "/bridge_set_output_peak_value");

  1766.         lo_send(m_oscData->target, target_path, "id", portId, value);

  1767.     }

  1768. }

  1769. #endif

  1770. 

  1771. CARLA_BACKEND_END_NAMESPACE