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

1565 lines
43KB
Raw Blame History 

  1. /*

  2.  * Carla Plugin

  3.  * Copyright (C) 2011-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 "CarlaPluginInternal.hpp"

  19. #include "CarlaLibUtils.hpp"

  20. #include "CarlaStateUtils.hpp"

  21. #include "CarlaMIDI.h"

  22. 

  23. //#include <QtGui/QtEvents>

  24. 

  25. // TODO - save&load options

  26. 

  27. CARLA_BACKEND_START_NAMESPACE

  28. 

  29. // -------------------------------------------------------------------

  30. // fallback data

  31. 

  32. static const ParameterData    kParameterDataNull;

  33. static const ParameterRanges  kParameterRangesNull;

  34. static const MidiProgramData  kMidiProgramDataNull;

  35. static const CustomData       kCustomDataNull;

  36. 

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

  38. // Helpers

  39. 

  40. CarlaEngine* CarlaPluginGetEngine(CarlaPlugin* const plugin)

  41. {

  42.     return CarlaPluginProtectedData::getEngine(plugin);

  43. }

  44. 

  45. CarlaEngineAudioPort* CarlaPluginGetAudioInPort(CarlaPlugin* const plugin, uint32_t index)

  46. {

  47.     return CarlaPluginProtectedData::getAudioInPort(plugin, index);

  48. }

  49. 

  50. CarlaEngineAudioPort* CarlaPluginGetAudioOutPort(CarlaPlugin* const plugin, uint32_t index)

  51. {

  52.     return CarlaPluginProtectedData::getAudioOutPort(plugin, index);

  53. }

  54. 

  55. // -------------------------------------------------------------------

  56. // Constructor and destructor

  57. 

  58. CarlaPlugin::CarlaPlugin(CarlaEngine* const engine, const unsigned int id)

  59.     : fId(id),

  60.       fHints(0x0),

  61.       fOptions(0x0),

  62.       fEnabled(false),

  63.       kData(new CarlaPluginProtectedData(engine))

  64. {

  65.     CARLA_ASSERT(kData != nullptr);

  66.     CARLA_ASSERT(engine != nullptr);

  67.     CARLA_ASSERT(id < engine->maxPluginNumber());

  68.     qDebug("CarlaPlugin::CarlaPlugin(%p, %i)", engine, id);

  69. 

  70.     switch (engine->getProccessMode())

  71.     {

  72.     case PROCESS_MODE_SINGLE_CLIENT:

  73.     case PROCESS_MODE_MULTIPLE_CLIENTS:

  74.         kData->ctrlInChannel = 0;

  75.         break;

  76. 

  77.     case PROCESS_MODE_CONTINUOUS_RACK:

  78.         CARLA_ASSERT(id < MAX_RACK_PLUGINS && id < MAX_MIDI_CHANNELS);

  79. 

  80.         if (id < MAX_RACK_PLUGINS && id < MAX_MIDI_CHANNELS)

  81.             kData->ctrlInChannel = id;

  82. 

  83.         break;

  84. 

  85.     case PROCESS_MODE_PATCHBAY:

  86.     case PROCESS_MODE_BRIDGE:

  87.         break;

  88.     }

  89. }

  90. 

  91. CarlaPlugin::~CarlaPlugin()

  92. {

  93.     qDebug("CarlaPlugin::~CarlaPlugin()");

  94. 

  95.     // Remove client and ports

  96.     if (kData->client != nullptr)

  97.     {

  98.         if (kData->client->isActive())

  99.             kData->client->deactivate();

  100. 

  101.         // can't call virtual functions in destructor

  102.         CarlaPlugin::deleteBuffers();

  103. 

  104.         delete kData->client;

  105.     }

  106. 

  107.     if (kData->latencyBuffers != nullptr)

  108.     {

  109.         for (uint32_t i=0; i < kData->audioIn.count; i++)

  110.             delete[] kData->latencyBuffers[i];

  111. 

  112.         delete[] kData->latencyBuffers;

  113.     }

  114. 

  115.     kData->prog.clear();

  116.     kData->midiprog.clear();

  117.     kData->custom.clear();

  118. 

  119.     libClose();

  120. 

  121.     delete kData;

  122. }

  123. 

  124. // -------------------------------------------------------------------

  125. // Information (base)

  126. 

  127. uint32_t CarlaPlugin::latency() const

  128. {

  129.     return kData->latency;

  130. }

  131. 

  132. // -------------------------------------------------------------------

  133. // Information (count)

  134. 

  135. uint32_t CarlaPlugin::audioInCount() const

  136. {

  137.     return kData->audioIn.count;

  138. }

  139. 

  140. uint32_t CarlaPlugin::audioOutCount() const

  141. {

  142.     return kData->audioOut.count;

  143. }

  144. 

  145. uint32_t CarlaPlugin::midiInCount() const

  146. {

  147.     return (kData->extraHints & PLUGIN_HINT_HAS_MIDI_IN) ? 1 : 0;

  148. }

  149. 

  150. uint32_t CarlaPlugin::midiOutCount() const

  151. {

  152.     return (kData->extraHints & PLUGIN_HINT_HAS_MIDI_OUT) ? 1 : 0;

  153. }

  154. 

  155. uint32_t CarlaPlugin::parameterCount() const

  156. {

  157.     return kData->param.count;

  158. }

  159. 

  160. uint32_t CarlaPlugin::parameterScalePointCount(const uint32_t parameterId) const

  161. {

  162.     CARLA_ASSERT(parameterId < kData->param.count);

  163.     return 0;

  164. 

  165.     // unused

  166.     Q_UNUSED(parameterId);

  167. }

  168. 

  169. uint32_t CarlaPlugin::programCount() const

  170. {

  171.     return kData->prog.count;

  172. }

  173. 

  174. uint32_t CarlaPlugin::midiProgramCount() const

  175. {

  176.     return kData->midiprog.count;

  177. }

  178. 

  179. uint32_t CarlaPlugin::customDataCount() const

  180. {

  181.     return kData->custom.count();

  182. }

  183. 

  184. // -------------------------------------------------------------------

  185. // Information (current data)

  186. 

  187. int32_t CarlaPlugin::currentProgram() const

  188. {

  189.     return kData->prog.current;

  190. }

  191. 

  192. int32_t CarlaPlugin::currentMidiProgram() const

  193. {

  194.     return kData->midiprog.current;

  195. }

  196. 

  197. const ParameterData& CarlaPlugin::parameterData(const uint32_t parameterId) const

  198. {

  199.     CARLA_ASSERT(parameterId < kData->param.count);

  200. 

  201.     return (parameterId < kData->param.count) ? kData->param.data[parameterId] : kParameterDataNull;

  202. }

  203. 

  204. const ParameterRanges& CarlaPlugin::parameterRanges(const uint32_t parameterId) const

  205. {

  206.     CARLA_ASSERT(parameterId < kData->param.count);

  207. 

  208.     return (parameterId < kData->param.count) ? kData->param.ranges[parameterId] : kParameterRangesNull;

  209. }

  210. 

  211. bool CarlaPlugin::parameterIsOutput(const uint32_t parameterId) const

  212. {

  213.     CARLA_ASSERT(parameterId < kData->param.count);

  214. 

  215.     return (parameterId < kData->param.count) ? (kData->param.data[parameterId].type == PARAMETER_OUTPUT) : false;

  216. }

  217. 

  218. const MidiProgramData& CarlaPlugin::midiProgramData(const uint32_t index) const

  219. {

  220.     CARLA_ASSERT(index < kData->midiprog.count);

  221. 

  222.     return (index < kData->midiprog.count) ? kData->midiprog.data[index] : kMidiProgramDataNull;

  223. }

  224. 

  225. const CustomData& CarlaPlugin::customData(const size_t index) const

  226. {

  227.     CARLA_ASSERT(index < kData->custom.count());

  228. 

  229.     return (index < kData->custom.count()) ? kData->custom.getAt(index) : kCustomDataNull;

  230. }

  231. 

  232. int32_t CarlaPlugin::chunkData(void** const dataPtr)

  233. {

  234.     CARLA_ASSERT(dataPtr != nullptr);

  235.     return 0;

  236. 

  237.     // unused

  238.     Q_UNUSED(dataPtr);

  239. }

  240. 

  241. // -------------------------------------------------------------------

  242. // Information (per-plugin data)

  243. 

  244. float CarlaPlugin::getParameterValue(const uint32_t parameterId)

  245. {

  246.     CARLA_ASSERT(parameterId < parameterCount());

  247.     return 0.0f;

  248. 

  249.     // unused

  250.     Q_UNUSED(parameterId);

  251. }

  252. 

  253. float CarlaPlugin::getParameterScalePointValue(const uint32_t parameterId, const uint32_t scalePointId)

  254. {

  255.     CARLA_ASSERT(parameterId < parameterCount());

  256.     CARLA_ASSERT(scalePointId < parameterScalePointCount(parameterId));

  257.     return 0.0f;

  258. 

  259.     // unused

  260.     Q_UNUSED(parameterId);

  261.     Q_UNUSED(scalePointId);

  262. }

  263. 

  264. void CarlaPlugin::getLabel(char* const strBuf)

  265. {

  266.     *strBuf = 0;

  267. }

  268. 

  269. void CarlaPlugin::getMaker(char* const strBuf)

  270. {

  271.     *strBuf = 0;

  272. }

  273. 

  274. void CarlaPlugin::getCopyright(char* const strBuf)

  275. {

  276.     *strBuf = 0;

  277. }

  278. 

  279. void CarlaPlugin::getRealName(char* const strBuf)

  280. {

  281.     *strBuf = 0;

  282. }

  283. 

  284. void CarlaPlugin::getParameterName(const uint32_t parameterId, char* const strBuf)

  285. {

  286.     CARLA_ASSERT(parameterId < parameterCount());

  287.     *strBuf = 0;

  288.     return;

  289. 

  290.     // unused

  291.     Q_UNUSED(parameterId);

  292. }

  293. 

  294. void CarlaPlugin::getParameterSymbol(const uint32_t parameterId, char* const strBuf)

  295. {

  296.     CARLA_ASSERT(parameterId < parameterCount());

  297.     *strBuf = 0;

  298.     return;

  299. 

  300.     // unused

  301.     Q_UNUSED(parameterId);

  302. }

  303. 

  304. void CarlaPlugin::getParameterText(const uint32_t parameterId, char* const strBuf)

  305. {

  306.     CARLA_ASSERT(parameterId < parameterCount());

  307.     *strBuf = 0;

  308.     return;

  309. 

  310.     // unused

  311.     Q_UNUSED(parameterId);

  312. }

  313. 

  314. void CarlaPlugin::getParameterUnit(const uint32_t parameterId, char* const strBuf)

  315. {

  316.     CARLA_ASSERT(parameterId < parameterCount());

  317.     *strBuf = 0;

  318.     return;

  319. 

  320.     // unused

  321.     Q_UNUSED(parameterId);

  322. }

  323. 

  324. void CarlaPlugin::getParameterScalePointLabel(const uint32_t parameterId, const uint32_t scalePointId, char* const strBuf)

  325. {

  326.     CARLA_ASSERT(parameterId < parameterCount());

  327.     CARLA_ASSERT(scalePointId < parameterScalePointCount(parameterId));

  328.     *strBuf = 0;

  329.     return;

  330. 

  331.     // unused

  332.     Q_UNUSED(parameterId);

  333.     Q_UNUSED(scalePointId);

  334. }

  335. 

  336. void CarlaPlugin::getProgramName(const uint32_t index, char* const strBuf)

  337. {

  338.     CARLA_ASSERT(index < kData->prog.count);

  339.     CARLA_ASSERT(kData->prog.names[index] != nullptr);

  340. 

  341.     if (index < kData->prog.count && kData->prog.names[index])

  342.         std::strncpy(strBuf, kData->prog.names[index], STR_MAX);

  343.     else

  344.         *strBuf = 0;

  345. }

  346. 

  347. void CarlaPlugin::getMidiProgramName(const uint32_t index, char* const strBuf)

  348. {

  349.     CARLA_ASSERT(index < kData->midiprog.count);

  350.     CARLA_ASSERT(kData->midiprog.data[index].name != nullptr);

  351. 

  352.     if (index < kData->midiprog.count && kData->midiprog.data[index].name)

  353.         std::strncpy(strBuf, kData->midiprog.data[index].name, STR_MAX);

  354.     else

  355.         *strBuf = 0;

  356. }

  357. 

  358. void CarlaPlugin::getParameterCountInfo(uint32_t* const ins, uint32_t* const outs, uint32_t* const total)

  359. {

  360.     CARLA_ASSERT(ins != nullptr);

  361.     CARLA_ASSERT(outs != nullptr);

  362.     CARLA_ASSERT(total != nullptr);

  363. 

  364.     if (ins == nullptr || outs == nullptr || total == nullptr)

  365.         return;

  366. 

  367.     *ins   = 0;

  368.     *outs  = 0;

  369.     *total = kData->param.count;

  370. 

  371.     for (uint32_t i=0; i < kData->param.count; i++)

  372.     {

  373.         if (kData->param.data[i].type == PARAMETER_INPUT)

  374.             *ins += 1;

  375.         else if (kData->param.data[i].type == PARAMETER_OUTPUT)

  376.             *outs += 1;

  377.     }

  378. }

  379. 

  380. // -------------------------------------------------------------------

  381. // Set data (state)

  382. 

  383. const SaveState& CarlaPlugin::getSaveState()

  384. {

  385.     static SaveState saveState;

  386. 

  387.     // TODO

  388.     return saveState;

  389. }

  390. 

  391. void CarlaPlugin::loadSaveState(const SaveState& saveState)

  392. {

  393.     // TODO

  394.     Q_UNUSED(saveState);

  395. }

  396. 

  397. // -------------------------------------------------------------------

  398. // Set data (internal stuff)

  399. 

  400. void CarlaPlugin::setId(const unsigned int id)

  401. {

  402.     fId = id;

  403. 

  404.     if (kData->engine->getProccessMode() == PROCESS_MODE_CONTINUOUS_RACK)

  405.         kData->ctrlInChannel = id;

  406. }

  407. 

  408. void CarlaPlugin::setEnabled(const bool yesNo)

  409. {

  410.     fEnabled = yesNo;

  411. }

  412. 

  413. void CarlaPlugin::setActive(const bool active, const bool sendOsc, const bool sendCallback)

  414. {

  415.     kData->active = active;

  416. 

  417.     const float value = active ? 1.0f : 0.0f;

  418. 

  419. #ifndef BUILD_BRIDGE

  420.     if (sendOsc)

  421.         kData->engine->osc_send_control_set_parameter_value(fId, PARAMETER_ACTIVE, value);

  422. #else

  423.     Q_UNUSED(sendOsc);

  424. #endif

  425. 

  426.     if (sendCallback)

  427.         kData->engine->callback(CALLBACK_PARAMETER_VALUE_CHANGED, fId, PARAMETER_ACTIVE, 0, value, nullptr);

  428. #ifndef BUILD_BRIDGE

  429.     else if (fHints & PLUGIN_IS_BRIDGE)

  430.         osc_send_control(&kData->osc.data, PARAMETER_ACTIVE, value);

  431. #endif

  432. }

  433. 

  434. void CarlaPlugin::setDryWet(const float value, const bool sendOsc, const bool sendCallback)

  435. {

  436.     CARLA_ASSERT(value >= 0.0f && value <= 1.0f);

  437. 

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

  439. 

  440.     kData->postProc.dryWet = fixedValue;

  441. 

  442. #ifndef BUILD_BRIDGE

  443.     if (sendOsc)

  444.         kData->engine->osc_send_control_set_parameter_value(fId, PARAMETER_DRYWET, fixedValue);

  445. #else

  446.     Q_UNUSED(sendOsc);

  447. #endif

  448. 

  449.     if (sendCallback)

  450.         kData->engine->callback(CALLBACK_PARAMETER_VALUE_CHANGED, fId, PARAMETER_DRYWET, 0, fixedValue, nullptr);

  451. #ifndef BUILD_BRIDGE

  452.     else if (fHints & PLUGIN_IS_BRIDGE)

  453.         osc_send_control(&kData->osc.data, PARAMETER_DRYWET, fixedValue);

  454. #endif

  455. }

  456. 

  457. void CarlaPlugin::setVolume(const float value, const bool sendOsc, const bool sendCallback)

  458. {

  459.     CARLA_ASSERT(value >= 0.0f && value <= 1.27f);

  460. 

  461.     const float fixedValue = carla_fixValue<float>(0.0f, 1.27f, value);

  462. 

  463.     kData->postProc.volume = fixedValue;

  464. 

  465. #ifndef BUILD_BRIDGE

  466.     if (sendOsc)

  467.         kData->engine->osc_send_control_set_parameter_value(fId, PARAMETER_VOLUME, fixedValue);

  468. #else

  469.     Q_UNUSED(sendOsc);

  470. #endif

  471. 

  472.     if (sendCallback)

  473.         kData->engine->callback(CALLBACK_PARAMETER_VALUE_CHANGED, fId, PARAMETER_VOLUME, 0, fixedValue, nullptr);

  474. #ifndef BUILD_BRIDGE

  475.     else if (fHints & PLUGIN_IS_BRIDGE)

  476.         osc_send_control(&kData->osc.data, PARAMETER_VOLUME, fixedValue);

  477. #endif

  478. }

  479. 

  480. void CarlaPlugin::setBalanceLeft(const float value, const bool sendOsc, const bool sendCallback)

  481. {

  482.     CARLA_ASSERT(value >= -1.0f && value <= 1.0f);

  483. 

  484.     const float fixedValue = carla_fixValue<float>(-1.0f, 1.0f, value);

  485. 

  486.     kData->postProc.balanceLeft = fixedValue;

  487. 

  488. #ifndef BUILD_BRIDGE

  489.     if (sendOsc)

  490.         kData->engine->osc_send_control_set_parameter_value(fId, PARAMETER_BALANCE_LEFT, fixedValue);

  491. #else

  492.     Q_UNUSED(sendOsc);

  493. #endif

  494. 

  495.     if (sendCallback)

  496.         kData->engine->callback(CALLBACK_PARAMETER_VALUE_CHANGED, fId, PARAMETER_BALANCE_LEFT, 0, fixedValue, nullptr);

  497. #ifndef BUILD_BRIDGE

  498.     else if (fHints & PLUGIN_IS_BRIDGE)

  499.         osc_send_control(&kData->osc.data, PARAMETER_BALANCE_LEFT, fixedValue);

  500. #endif

  501. }

  502. 

  503. void CarlaPlugin::setBalanceRight(const float value, const bool sendOsc, const bool sendCallback)

  504. {

  505.     CARLA_ASSERT(value >= -1.0f && value <= 1.0f);

  506. 

  507.     const float fixedValue = carla_fixValue<float>(-1.0f, 1.0f, value);

  508. 

  509.     kData->postProc.balanceRight = fixedValue;

  510. 

  511. #ifndef BUILD_BRIDGE

  512.     if (sendOsc)

  513.         kData->engine->osc_send_control_set_parameter_value(fId, PARAMETER_BALANCE_RIGHT, fixedValue);

  514. #else

  515.     Q_UNUSED(sendOsc);

  516. #endif

  517. 

  518.     if (sendCallback)

  519.         kData->engine->callback(CALLBACK_PARAMETER_VALUE_CHANGED, fId, PARAMETER_BALANCE_RIGHT, 0, fixedValue, nullptr);

  520. #ifndef BUILD_BRIDGE

  521.     else if (fHints & PLUGIN_IS_BRIDGE)

  522.         osc_send_control(&kData->osc.data, PARAMETER_BALANCE_RIGHT, fixedValue);

  523. #endif

  524. }

  525. 

  526. void CarlaPlugin::setPanning(const float value, const bool sendOsc, const bool sendCallback)

  527. {

  528.     CARLA_ASSERT(value >= -1.0f && value <= 1.0f);

  529. 

  530.     const float fixedValue = carla_fixValue<float>(-1.0f, 1.0f, value);

  531. 

  532.     kData->postProc.panning = fixedValue;

  533. 

  534. #ifndef BUILD_BRIDGE

  535.     if (sendOsc)

  536.         kData->engine->osc_send_control_set_parameter_value(fId, PARAMETER_PANNING, fixedValue);

  537. #else

  538.     Q_UNUSED(sendOsc);

  539. #endif

  540. 

  541.     if (sendCallback)

  542.         kData->engine->callback(CALLBACK_PARAMETER_VALUE_CHANGED, fId, PARAMETER_PANNING, 0, fixedValue, nullptr);

  543. #ifndef BUILD_BRIDGE

  544.     else if (fHints & PLUGIN_IS_BRIDGE)

  545.         osc_send_control(&kData->osc.data, PARAMETER_PANNING, fixedValue);

  546. #endif

  547. }

  548. 

  549. #if 0 //ndef BUILD_BRIDGE

  550. int CarlaPlugin::setOscBridgeInfo(const PluginBridgeInfoType, const int, const lo_arg* const* const, const char* const)

  551. {

  552.     return 1;

  553. }

  554. #endif

  555. 

  556. // -------------------------------------------------------------------

  557. // Set data (plugin-specific stuff)

  558. 

  559. void CarlaPlugin::setParameterValue(const uint32_t parameterId, const float value, const bool sendGui, const bool sendOsc, const bool sendCallback)

  560. {

  561.     CARLA_ASSERT(parameterId < kData->param.count);

  562. 

  563.     if (sendGui)

  564.         uiParameterChange(parameterId, value);

  565. 

  566. #ifndef BUILD_BRIDGE

  567.     if (sendOsc)

  568.         kData->engine->osc_send_control_set_parameter_value(fId, parameterId, value);

  569. #else

  570.     Q_UNUSED(sendOsc);

  571. #endif

  572. 

  573.     if (sendCallback)

  574.         kData->engine->callback(CALLBACK_PARAMETER_VALUE_CHANGED, fId, parameterId, 0, value, nullptr);

  575. }

  576. 

  577. void CarlaPlugin::setParameterValueByRIndex(const int32_t rindex, const float value, const bool sendGui, const bool sendOsc, const bool sendCallback)

  578. {

  579.     CARLA_ASSERT(rindex > PARAMETER_MAX && rindex != PARAMETER_NULL);

  580. 

  581.     if (rindex <= PARAMETER_MAX)

  582.         return;

  583.     if (rindex == PARAMETER_NULL)

  584.         return;

  585.     if (rindex == PARAMETER_ACTIVE)

  586.         return setActive(value > 0.0, sendOsc, sendCallback);

  587.     if (rindex == PARAMETER_DRYWET)

  588.         return setDryWet(value, sendOsc, sendCallback);

  589.     if (rindex == PARAMETER_VOLUME)

  590.         return setVolume(value, sendOsc, sendCallback);

  591.     if (rindex == PARAMETER_BALANCE_LEFT)

  592.         return setBalanceLeft(value, sendOsc, sendCallback);

  593.     if (rindex == PARAMETER_BALANCE_RIGHT)

  594.         return setBalanceRight(value, sendOsc, sendCallback);

  595.     if (rindex == PARAMETER_PANNING)

  596.         return setPanning(value, sendOsc, sendCallback);

  597. 

  598.     for (uint32_t i=0; i < kData->param.count; i++)

  599.     {

  600.         if (kData->param.data[i].rindex == rindex)

  601.             return setParameterValue(i, value, sendGui, sendOsc, sendCallback);

  602.     }

  603. }

  604. 

  605. void CarlaPlugin::setParameterMidiChannel(const uint32_t parameterId, uint8_t channel, const bool sendOsc, const bool sendCallback)

  606. {

  607.     CARLA_ASSERT(parameterId < kData->param.count);

  608.     CARLA_ASSERT(channel < MAX_MIDI_CHANNELS);

  609. 

  610.     if (channel >= MAX_MIDI_CHANNELS)

  611.         channel = MAX_MIDI_CHANNELS;

  612. 

  613.     kData->param.data[parameterId].midiChannel = channel;

  614. 

  615. #ifndef BUILD_BRIDGE

  616.     if (sendOsc)

  617.         kData->engine->osc_send_control_set_parameter_midi_channel(fId, parameterId, channel);

  618. #else

  619.     Q_UNUSED(sendOsc);

  620. #endif

  621. 

  622.     if (sendCallback)

  623.         kData->engine->callback(CALLBACK_PARAMETER_MIDI_CHANNEL_CHANGED, fId, parameterId, channel, 0.0f, nullptr);

  624. }

  625. 

  626. void CarlaPlugin::setParameterMidiCC(const uint32_t parameterId, int16_t cc, const bool sendOsc, const bool sendCallback)

  627. {

  628.     CARLA_ASSERT(parameterId < kData->param.count);

  629.     CARLA_ASSERT(cc >= -1);

  630. 

  631.     if (cc < -1 || cc > 0x5F)

  632.         cc = -1;

  633. 

  634.     kData->param.data[parameterId].midiCC = cc;

  635. 

  636. #ifndef BUILD_BRIDGE

  637.     if (sendOsc)

  638.         kData->engine->osc_send_control_set_parameter_midi_cc(fId, parameterId, cc);

  639. #else

  640.     Q_UNUSED(sendOsc);

  641. #endif

  642. 

  643.     if (sendCallback)

  644.         kData->engine->callback(CALLBACK_PARAMETER_MIDI_CC_CHANGED, fId, parameterId, cc, 0.0f, nullptr);

  645. }

  646. 

  647. void CarlaPlugin::setCustomData(const char* const type, const char* const key, const char* const value, const bool sendGui)

  648. {

  649.     CARLA_ASSERT(type  != nullptr);

  650.     CARLA_ASSERT(key   != nullptr);

  651.     CARLA_ASSERT(value != nullptr);

  652. 

  653.     if (type == nullptr)

  654.         return qCritical("CarlaPlugin::setCustomData(\"%s\", \"%s\", \"%s\", %s) - type is invalid", type, key, value, bool2str(sendGui));

  655. 

  656.     if (key == nullptr)

  657.         return qCritical("CarlaPlugin::setCustomData(\"%s\", \"%s\", \"%s\", %s) - key is null", type, key, value, bool2str(sendGui));

  658. 

  659.     if (value == nullptr)

  660.         return qCritical("CarlaPlugin::setCustomData(\"%s\", \"%s\", \"%s\", %s) - value is null", type, key, value, bool2str(sendGui));

  661. 

  662.     bool saveData = true;

  663. 

  664.     if (std::strcmp(type, CUSTOM_DATA_STRING) == 0)

  665.     {

  666.         // Ignore some keys

  667.         if (std::strncmp(key, "OSC:", 4) == 0 || std::strcmp(key, "guiVisible") == 0)

  668.             saveData = false;

  669.         //else if (strcmp(key, CARLA_BRIDGE_MSG_SAVE_NOW) == 0 || strcmp(key, CARLA_BRIDGE_MSG_SET_CHUNK) == 0 || strcmp(key, CARLA_BRIDGE_MSG_SET_CUSTOM) == 0)

  670.         //    saveData = false;

  671.     }

  672. 

  673.     if (saveData)

  674.     {

  675. #if 0

  676.         // Check if we already have this key

  677.         for (size_t i=0; i < kData->custom.count(); i++)

  678.         {

  679.             if (strcmp(custom[i].key, key) == 0)

  680.             {

  681.                 delete[] custom[i].value;

  682.                 custom[i].value = carla_strdup(value);

  683.                 return;

  684.             }

  685.         }

  686. #endif

  687. 

  688.         // Otherwise store it

  689.         CustomData newData;

  690.         newData.type  = carla_strdup(type);

  691.         newData.key   = carla_strdup(key);

  692.         newData.value = carla_strdup(value);

  693.         kData->custom.append(newData);

  694.     }

  695. }

  696. 

  697. void CarlaPlugin::setChunkData(const char* const stringData)

  698. {

  699.     CARLA_ASSERT(stringData != nullptr);

  700.     return;

  701. 

  702.     // unused

  703.     Q_UNUSED(stringData);

  704. }

  705. 

  706. void CarlaPlugin::setProgram(const int32_t index, const bool sendGui, const bool sendOsc, const bool sendCallback, const bool)

  707. {

  708.     CARLA_ASSERT(index >= -1 && index < static_cast<int32_t>(kData->prog.count));

  709. 

  710.     if (index > static_cast<int32_t>(kData->prog.count))

  711.         return;

  712. 

  713.     const int32_t fixedIndex = carla_fixValue<int32_t>(-1, kData->prog.count, index);

  714. 

  715.     kData->prog.current = fixedIndex;

  716. 

  717.     // Change default parameter values

  718.     if (fixedIndex >= 0)

  719.     {

  720.         if (sendGui)

  721.             uiProgramChange(fixedIndex);

  722. 

  723.         for (uint32_t i=0; i < kData->param.count; i++)

  724.         {

  725.             // FIXME?

  726.             kData->param.ranges[i].def = getParameterValue(i);

  727.             kData->param.ranges[i].fixDefault();

  728. 

  729.             if (sendOsc)

  730.             {

  731. #ifndef BUILD_BRIDGE

  732.                 kData->engine->osc_send_control_set_default_value(fId, i, kData->param.ranges[i].def);

  733.                 kData->engine->osc_send_control_set_parameter_value(fId, i, kData->param.ranges[i].def);

  734. #endif

  735.             }

  736.         }

  737.     }

  738. 

  739. #ifndef BUILD_BRIDGE

  740.     if (sendOsc)

  741.         kData->engine->osc_send_control_set_program(fId, fixedIndex);

  742. #endif

  743. 

  744.     if (sendCallback)

  745.         kData->engine->callback(CALLBACK_PROGRAM_CHANGED, fId, fixedIndex, 0, 0.0f, nullptr);

  746. }

  747. 

  748. void CarlaPlugin::setMidiProgram(int32_t index, const bool sendGui, const bool sendOsc, const bool sendCallback, const bool)

  749. {

  750.     CARLA_ASSERT(index >= -1 && index < static_cast<int32_t>(kData->midiprog.count));

  751. 

  752.     if (index > static_cast<int32_t>(kData->midiprog.count))

  753.         return;

  754. 

  755.     const int32_t fixedIndex = carla_fixValue<int32_t>(-1, kData->midiprog.count, index);

  756. 

  757.     kData->midiprog.current = fixedIndex;

  758. 

  759.     if (fixedIndex >= 0)

  760.     {

  761.         if (sendGui)

  762.             uiMidiProgramChange(fixedIndex);

  763. 

  764.         // Change default parameter values (sound banks never change defaults)

  765. #ifndef BUILD_BRIDGE // FIXME

  766.         if (type() != PLUGIN_GIG && type() != PLUGIN_SF2 && type() != PLUGIN_SFZ)

  767. #endif

  768.         {

  769.             for (uint32_t i=0; i < kData->param.count; i++)

  770.             {

  771.                 // FIXME?

  772.                 kData->param.ranges[i].def = getParameterValue(i);

  773.                 kData->param.ranges[i].fixDefault();

  774. 

  775.                 if (sendOsc)

  776.                 {

  777. #ifndef BUILD_BRIDGE

  778.                     kData->engine->osc_send_control_set_default_value(fId, i, kData->param.ranges[i].def);

  779.                     kData->engine->osc_send_control_set_parameter_value(fId, i, kData->param.ranges[i].def);

  780. #endif

  781.                 }

  782.             }

  783.         }

  784.     }

  785. 

  786. #ifndef BUILD_BRIDGE

  787.     if (sendOsc)

  788.         kData->engine->osc_send_control_set_midi_program(fId, fixedIndex);

  789. #endif

  790. 

  791.     if (sendCallback)

  792.         kData->engine->callback(CALLBACK_MIDI_PROGRAM_CHANGED, fId, fixedIndex, 0, 0.0f, nullptr);

  793. }

  794. 

  795. void CarlaPlugin::setMidiProgramById(const uint32_t bank, const uint32_t program, const bool sendGui, const bool sendOsc, const bool sendCallback, const bool block)

  796. {

  797.     for (uint32_t i=0; i < kData->midiprog.count; i++)

  798.     {

  799.         if (kData->midiprog.data[i].bank == bank && kData->midiprog.data[i].program == program)

  800.             return setMidiProgram(i, sendGui, sendOsc, sendCallback, block);

  801.     }

  802. }

  803. 

  804. // -------------------------------------------------------------------

  805. // Set gui stuff

  806. 

  807. void CarlaPlugin::showGui(const bool yesNo)

  808. {

  809.     Q_UNUSED(yesNo);

  810. }

  811. 

  812. void CarlaPlugin::idleGui()

  813. {

  814.     if (! fEnabled)

  815.         return;

  816. 

  817.     if (fHints & PLUGIN_USES_SINGLE_THREAD)

  818.     {

  819.         // Process postponed events

  820.         postRtEventsRun();

  821. 

  822.         // Update parameter outputs

  823.         for (uint32_t i=0; i < kData->param.count; i++)

  824.         {

  825.             if (kData->param.data[i].type == PARAMETER_OUTPUT)

  826.                 uiParameterChange(i, getParameterValue(i));

  827.         }

  828.     }

  829. }

  830. 

  831. // -------------------------------------------------------------------

  832. // Plugin state

  833. 

  834. void CarlaPlugin::reload()

  835. {

  836. }

  837. 

  838. void CarlaPlugin::reloadPrograms(const bool)

  839. {

  840. }

  841. 

  842. void CarlaPlugin::prepareForSave()

  843. {

  844. }

  845. 

  846. // -------------------------------------------------------------------

  847. // Plugin processing

  848. 

  849. void CarlaPlugin::process(float** const, float** const, const uint32_t, const uint32_t)

  850. {

  851. }

  852. 

  853. void CarlaPlugin::bufferSizeChanged(const uint32_t)

  854. {

  855. }

  856. 

  857. void CarlaPlugin::sampleRateChanged(const double)

  858. {

  859. }

  860. 

  861. void CarlaPlugin::recreateLatencyBuffers()

  862. {

  863. #if 0

  864.     if (kData->latencyBuffers)

  865.     {

  866.         for (uint32_t i=0; i < kData->audioIn.count; i++)

  867.             delete[] kData->latencyBuffers[i];

  868. 

  869.         delete[] kData->latencyBuffers;

  870.     }

  871. 

  872.     if (kData->audioIn.count > 0 && kData->latency > 0)

  873.     {

  874.         kData->latencyBuffers = new float*[kData->audioIn.count];

  875. 

  876.         for (uint32_t i=0; i < kData->audioIn.count; i++)

  877.             kData->latencyBuffers[i] = new float[kData->latency];

  878.     }

  879.     else

  880.         kData->latencyBuffers = nullptr;

  881. #endif

  882. }

  883. 

  884. // -------------------------------------------------------------------

  885. // OSC stuff

  886. 

  887. void CarlaPlugin::registerToOscClient()

  888. {

  889. #ifdef BUILD_BRIDGE

  890.     if (! kData->engine->isOscBridgeRegistered())

  891.         return;

  892. #else

  893.     if (! kData->engine->isOscControlRegistered())

  894.         return;

  895. #endif

  896. 

  897. #ifndef BUILD_BRIDGE

  898.     kData->engine->osc_send_control_add_plugin_start(fId, fName);

  899. #endif

  900. 

  901.     // Base data

  902.     {

  903.         char bufName[STR_MAX]  = { 0 };

  904.         char bufLabel[STR_MAX] = { 0 };

  905.         char bufMaker[STR_MAX] = { 0 };

  906.         char bufCopyright[STR_MAX] = { 0 };

  907.         getRealName(bufName);

  908.         getLabel(bufLabel);

  909.         getMaker(bufMaker);

  910.         getCopyright(bufCopyright);

  911. 

  912. #ifdef BUILD_BRIDGE

  913.         kData->engine->osc_send_bridge_plugin_info(category(), fHints, bufName, bufLabel, bufMaker, bufCopyright, uniqueId());

  914. #else

  915.         kData->engine->osc_send_control_set_plugin_data(fId, type(), category(), fHints, bufName, bufLabel, bufMaker, bufCopyright, uniqueId());

  916. #endif

  917.     }

  918. 

  919.     // Base count

  920.     {

  921.         uint32_t cIns, cOuts, cTotals;

  922.         getParameterCountInfo(&cIns, &cOuts, &cTotals);

  923. 

  924. #ifdef BUILD_BRIDGE

  925.         kData->engine->osc_send_bridge_audio_count(audioInCount(), audioOutCount(), audioInCount() + audioOutCount());

  926.         kData->engine->osc_send_bridge_midi_count(midiInCount(), midiOutCount(), midiInCount() + midiOutCount());

  927.         kData->engine->osc_send_bridge_parameter_count(cIns, cOuts, cTotals);

  928. #else

  929.         kData->engine->osc_send_control_set_plugin_ports(fId, audioInCount(), audioOutCount(), midiInCount(), midiOutCount(), cIns, cOuts, cTotals);

  930. #endif

  931.     }

  932. 

  933.     // Plugin Parameters

  934.     if (kData->param.count > 0 && kData->param.count < kData->engine->getOptions().maxParameters)

  935.     {

  936.         char bufName[STR_MAX], bufUnit[STR_MAX];

  937. 

  938.         for (uint32_t i=0; i < kData->param.count; i++)

  939.         {

  940.             getParameterName(i, bufName);

  941.             getParameterUnit(i, bufUnit);

  942. 

  943.             const ParameterData& paramData(kData->param.data[i]);

  944.             const ParameterRanges& paramRanges(kData->param.ranges[i]);

  945. 

  946. #ifdef BUILD_BRIDGE

  947.             kData->engine->osc_send_bridge_parameter_info(i, bufName, bufUnit);

  948.             kData->engine->osc_send_bridge_parameter_data(i, paramData.type, paramData.rindex, paramData.hints, paramData.midiChannel, paramData.midiCC);

  949.             kData->engine->osc_send_bridge_parameter_ranges(i, paramRanges.def, paramRanges.min, paramRanges.max, paramRanges.step, paramRanges.stepSmall, paramRanges.stepLarge);

  950.             kData->engine->osc_send_bridge_set_parameter_value(i, getParameterValue(i));

  951. #else

  952.             kData->engine->osc_send_control_set_parameter_data(fId, i, paramData.type, paramData.hints, bufName, bufUnit, getParameterValue(i));

  953.             kData->engine->osc_send_control_set_parameter_ranges(fId, i, paramRanges.min, paramRanges.max, paramRanges.def, paramRanges.step, paramRanges.stepSmall, paramRanges.stepLarge);

  954.             kData->engine->osc_send_control_set_parameter_midi_cc(fId, i, paramData.midiCC);

  955.             kData->engine->osc_send_control_set_parameter_midi_channel(fId, i, paramData.midiChannel);

  956.             kData->engine->osc_send_control_set_parameter_value(fId, i, getParameterValue(i));

  957. #endif

  958.         }

  959.     }

  960. 

  961.     // Programs

  962.     if (kData->prog.count > 0)

  963.     {

  964. #ifdef BUILD_BRIDGE

  965.         kData->engine->osc_send_bridge_program_count(kData->prog.count);

  966. 

  967.         for (uint32_t i=0; i < kData->prog.count; i++)

  968.             kData->engine->osc_send_bridge_program_info(i, kData->prog.names[i]);

  969. 

  970.         kData->engine->osc_send_bridge_set_program(kData->prog.current);

  971. #else

  972.         kData->engine->osc_send_control_set_program_count(fId, kData->prog.count);

  973. 

  974.         for (uint32_t i=0; i < kData->prog.count; i++)

  975.             kData->engine->osc_send_control_set_program_name(fId, i, kData->prog.names[i]);

  976. 

  977.         kData->engine->osc_send_control_set_program(fId, kData->prog.current);

  978. #endif

  979.     }

  980. 

  981.     // MIDI Programs

  982.     if (kData->midiprog.count > 0)

  983.     {

  984. #ifdef BUILD_BRIDGE

  985.         kData->engine->osc_send_bridge_midi_program_count(kData->midiprog.count);

  986. 

  987.         for (uint32_t i=0; i < kData->midiprog.count; i++)

  988.         {

  989.             const MidiProgramData& mpData(kData->midiprog.data[i]);

  990. 

  991.             kData->engine->osc_send_bridge_midi_program_info(i, mpData.bank, mpData.program, mpData.name);

  992.         }

  993. 

  994.         kData->engine->osc_send_bridge_set_midi_program(kData->midiprog.current);

  995. #else

  996.         kData->engine->osc_send_control_set_midi_program_count(fId, kData->midiprog.count);

  997. 

  998.         for (uint32_t i=0; i < kData->midiprog.count; i++)

  999.         {

  1000.             const MidiProgramData& mpData(kData->midiprog.data[i]);

  1001. 

  1002.             kData->engine->osc_send_control_set_midi_program_data(fId, i, mpData.bank, mpData.program, mpData.name);

  1003.         }

  1004. 

  1005.         kData->engine->osc_send_control_set_midi_program(fId, kData->midiprog.current);

  1006. #endif

  1007.     }

  1008. 

  1009. #ifndef BUILD_BRIDGE

  1010.     kData->engine->osc_send_control_add_plugin_end(fId);

  1011. 

  1012.     // Internal Parameters

  1013.     {

  1014.         kData->engine->osc_send_control_set_parameter_value(fId, PARAMETER_ACTIVE, kData->active ? 1.0 : 0.0);

  1015.         kData->engine->osc_send_control_set_parameter_value(fId, PARAMETER_DRYWET, kData->postProc.dryWet);

  1016.         kData->engine->osc_send_control_set_parameter_value(fId, PARAMETER_VOLUME, kData->postProc.volume);

  1017.         kData->engine->osc_send_control_set_parameter_value(fId, PARAMETER_BALANCE_LEFT, kData->postProc.balanceLeft);

  1018.         kData->engine->osc_send_control_set_parameter_value(fId, PARAMETER_BALANCE_RIGHT, kData->postProc.balanceRight);

  1019.         kData->engine->osc_send_control_set_parameter_value(fId, PARAMETER_PANNING, kData->postProc.panning);

  1020.     }

  1021. #endif

  1022. }

  1023. 

  1024. void CarlaPlugin::updateOscData(const lo_address& source, const char* const url)

  1025. {

  1026.     // FIXME - remove debug prints later

  1027.     qWarning("CarlaPlugin::updateOscData(%p, \"%s\")", source, url);

  1028. 

  1029.     kData->osc.data.free();

  1030. 

  1031.     const int proto = lo_address_get_protocol(source);

  1032. 

  1033.     {

  1034.         const char* host = lo_address_get_hostname(source);

  1035.         const char* port = lo_address_get_port(source);

  1036.         kData->osc.data.source = lo_address_new_with_proto(proto, host, port);

  1037. 

  1038.         qWarning("CarlaPlugin::updateOscData() - source: host \"%s\", port \"%s\"", host, port);

  1039.     }

  1040. 

  1041.     {

  1042.         char* host = lo_url_get_hostname(url);

  1043.         char* port = lo_url_get_port(url);

  1044.         kData->osc.data.path   = carla_strdup_free(lo_url_get_path(url));

  1045.         kData->osc.data.target = lo_address_new_with_proto(proto, host, port);

  1046.         qWarning("CarlaPlugin::updateOscData() - target: host \"%s\", port \"%s\", path \"%s\"", host, port, kData->osc.data.path);

  1047. 

  1048.         std::free(host);

  1049.         std::free(port);

  1050.     }

  1051. 

  1052. #ifndef BUILD_BRIDGE

  1053.     if (fHints & PLUGIN_IS_BRIDGE)

  1054.         return;

  1055. #endif

  1056. 

  1057.     osc_send_sample_rate(&kData->osc.data, kData->engine->getSampleRate());

  1058. 

  1059. #if 0

  1060.     for (size_t i=0; i < kData->custom.count(); i++)

  1061.     {

  1062.         // TODO

  1063.         //if (m_type == PLUGIN_LV2)

  1064.         //osc_send_lv2_transfer_event(&osc.data, getCustomDataTypeString(custom[i].type), /*custom[i].key,*/ custom[i].value);

  1065.         //else

  1066.         if (custom[i].type == CUSTOM_DATA_STRING)

  1067.             osc_send_configure(&osc.data, custom[i].key, custom[i].value);

  1068.     }

  1069. #endif

  1070. 

  1071.     if (kData->prog.current >= 0)

  1072.         osc_send_program(&kData->osc.data, kData->prog.current);

  1073. 

  1074.     if (kData->midiprog.current >= 0)

  1075.     {

  1076.         const MidiProgramData& curMidiProg(kData->midiprog.getCurrent());

  1077. 

  1078.         if (type() == PLUGIN_DSSI)

  1079.             osc_send_program(&kData->osc.data, curMidiProg.bank, curMidiProg.program);

  1080.         else

  1081.             osc_send_midi_program(&kData->osc.data, curMidiProg.bank, curMidiProg.program);

  1082.     }

  1083. 

  1084.     for (uint32_t i=0; i < kData->param.count; i++)

  1085.         osc_send_control(&kData->osc.data, kData->param.data[i].rindex, getParameterValue(i));

  1086. 

  1087.     qWarning("CarlaPlugin::updateOscData() - done");

  1088. }

  1089. 

  1090. void CarlaPlugin::freeOscData()

  1091. {

  1092.     kData->osc.data.free();

  1093. }

  1094. 

  1095. bool CarlaPlugin::waitForOscGuiShow()

  1096. {

  1097.     qWarning("CarlaPlugin::waitForOscGuiShow()");

  1098. 

  1099.     // wait for UI 'update' call

  1100.     for (uint i=0, oscUiTimeout = kData->engine->getOptions().oscUiTimeout; i < oscUiTimeout; i++)

  1101.     {

  1102.         if (kData->osc.data.target)

  1103.         {

  1104.             qWarning("CarlaPlugin::waitForOscGuiShow() - got response, asking UI to show itself now");

  1105.             osc_send_show(&kData->osc.data);

  1106.             return true;

  1107.         }

  1108.         else

  1109.             carla_msleep(100);

  1110.     }

  1111. 

  1112.     qWarning("CarlaPlugin::waitForOscGuiShow() - Timeout while waiting for UI to respond (waited %u msecs)", kData->engine->getOptions().oscUiTimeout);

  1113.     return false;

  1114. }

  1115. 

  1116. // -------------------------------------------------------------------

  1117. // MIDI events

  1118. 

  1119. void CarlaPlugin::sendMidiSingleNote(const uint8_t channel, const uint8_t note, const uint8_t velo, const bool sendGui, const bool sendOsc, const bool sendCallback)

  1120. {

  1121.     CARLA_ASSERT(channel < MAX_MIDI_CHANNELS);

  1122.     CARLA_ASSERT(note < MAX_MIDI_NOTE);

  1123.     CARLA_ASSERT(velo < MAX_MIDI_VALUE);

  1124. 

  1125.     if (! kData->active)

  1126.         return;

  1127. 

  1128.     ExternalMidiNote extNote;

  1129.     extNote.channel = channel;

  1130.     extNote.note    = note;

  1131.     extNote.velo    = velo;

  1132. 

  1133.     kData->extNotes.mutex.lock();

  1134.     kData->extNotes.append(extNote);

  1135.     kData->extNotes.mutex.unlock();

  1136. 

  1137.     if (sendGui)

  1138.     {

  1139.         if (velo > 0)

  1140.             uiNoteOn(channel, note, velo);

  1141.         else

  1142.             uiNoteOff(channel, note);

  1143.     }

  1144. 

  1145. #ifndef BUILD_BRIDGE

  1146.     if (sendOsc)

  1147.     {

  1148.         if (velo > 0)

  1149.             kData->engine->osc_send_control_note_on(fId, channel, note, velo);

  1150.         else

  1151.             kData->engine->osc_send_control_note_off(fId, channel, note);

  1152.     }

  1153. #else

  1154.     Q_UNUSED(sendOsc);

  1155. #endif

  1156. 

  1157.     if (sendCallback)

  1158.         kData->engine->callback(velo ? CALLBACK_NOTE_ON : CALLBACK_NOTE_OFF, fId, channel, note, velo, nullptr);

  1159. }

  1160. 

  1161. void CarlaPlugin::sendMidiAllNotesOff()

  1162. {

  1163.     kData->postRtEvents.mutex.lock();

  1164. 

  1165.     PluginPostRtEvent postEvent;

  1166.     postEvent.type   = kPluginPostRtEventNoteOff;

  1167.     postEvent.value1 = kData->ctrlInChannel;

  1168.     postEvent.value2 = 0;

  1169.     postEvent.value3 = 0.0;

  1170. 

  1171.     for (unsigned short i=0; i < MAX_MIDI_NOTE; i++)

  1172.     {

  1173.         postEvent.value2 = i;

  1174.         kData->postRtEvents.data.append(postEvent);

  1175.     }

  1176. 

  1177.     kData->postRtEvents.mutex.unlock();

  1178. }

  1179. 

  1180. // -------------------------------------------------------------------

  1181. // Post-poned events

  1182. 

  1183. void CarlaPlugin::postponeRtEvent(const PluginPostRtEventType type, const int32_t value1, const int32_t value2, const double value3)

  1184. {

  1185.     PluginPostRtEvent event;

  1186.     event.type   = type;

  1187.     event.value1 = value1;

  1188.     event.value2 = value2;

  1189.     event.value3 = value3;

  1190. 

  1191.     kData->postRtEvents.appendRT(event);

  1192. }

  1193. 

  1194. void CarlaPlugin::postRtEventsRun()

  1195. {

  1196.     unsigned short k = 0;

  1197.     PluginPostRtEvent listData[MAX_RT_EVENTS];

  1198. 

  1199.     // Make a safe copy of events while clearing them

  1200.     kData->postRtEvents.mutex.lock();

  1201. 

  1202.     while (! kData->postRtEvents.data.isEmpty())

  1203.     {

  1204.         PluginPostRtEvent& event = kData->postRtEvents.data.getFirst(true);

  1205.         listData[k++] = event;

  1206.         //std::memcpy(&listData[k++], &event, sizeof(PluginPostRtEvent));

  1207.     }

  1208. 

  1209.     kData->postRtEvents.mutex.unlock();

  1210. 

  1211.     // Handle events now

  1212.     for (unsigned short i=0; i < k; i++)

  1213.     {

  1214.         const PluginPostRtEvent& event = listData[i];

  1215. 

  1216.         switch (event.type)

  1217.         {

  1218.         case kPluginPostRtEventNull:

  1219.             break;

  1220. 

  1221.         case kPluginPostRtEventDebug:

  1222.             kData->engine->callback(CALLBACK_DEBUG, fId, event.value1, event.value2, event.value3, nullptr);

  1223.             break;

  1224. 

  1225.         case kPluginPostRtEventParameterChange:

  1226.             // Update UI

  1227.             if (event.value1 >= 0)

  1228.                 uiParameterChange(event.value1, event.value3);

  1229. 

  1230. #ifndef BUILD_BRIDGE

  1231.             // Update OSC control client

  1232.             if (kData->engine->isOscControlRegistered())

  1233.                 kData->engine->osc_send_control_set_parameter_value(fId, event.value1, event.value3);

  1234. #endif

  1235. 

  1236.             // Update Host

  1237.             kData->engine->callback(CALLBACK_PARAMETER_VALUE_CHANGED, fId, event.value1, 0, event.value3, nullptr);

  1238.             break;

  1239. 

  1240.         case kPluginPostRtEventProgramChange:

  1241.             // Update UI

  1242.             if (event.value1 >= 0)

  1243.                 uiProgramChange(event.value1);

  1244. 

  1245. #ifndef BUILD_BRIDGE

  1246.             // Update OSC control client

  1247.             if (kData->engine->isOscControlRegistered())

  1248.             {

  1249.                 kData->engine->osc_send_control_set_program(fId, event.value1);

  1250. 

  1251.                 for (uint32_t j=0; j < kData->param.count; j++)

  1252.                     kData->engine->osc_send_control_set_default_value(fId, j, kData->param.ranges[j].def);

  1253.             }

  1254. #endif

  1255. 

  1256.             // Update Host

  1257.             kData->engine->callback(CALLBACK_PROGRAM_CHANGED, fId, event.value1, 0, 0.0, nullptr);

  1258.             break;

  1259. 

  1260.         case kPluginPostRtEventMidiProgramChange:

  1261.             // Update UI

  1262.             if (event.value1 >= 0)

  1263.                 uiMidiProgramChange(event.value1);

  1264. 

  1265. #ifndef BUILD_BRIDGE

  1266.             // Update OSC control client

  1267.             if (kData->engine->isOscControlRegistered())

  1268.             {

  1269.                 kData->engine->osc_send_control_set_midi_program(fId, event.value1);

  1270. 

  1271.                 for (uint32_t j=0; j < kData->param.count; j++)

  1272.                     kData->engine->osc_send_control_set_default_value(fId, j, kData->param.ranges[j].def);

  1273.             }

  1274. #endif

  1275. 

  1276.             // Update Host

  1277.             kData->engine->callback(CALLBACK_MIDI_PROGRAM_CHANGED, fId, event.value1, 0, 0.0, nullptr);

  1278.             break;

  1279. 

  1280.         case kPluginPostRtEventNoteOn:

  1281.             // Update UI

  1282.             uiNoteOn(event.value1, event.value2, int(event.value3));

  1283. 

  1284. #ifndef BUILD_BRIDGE

  1285.             // Update OSC control client

  1286.             if (kData->engine->isOscControlRegistered())

  1287.                 kData->engine->osc_send_control_note_on(fId, event.value1, event.value2, int(event.value3));

  1288. #endif

  1289. 

  1290.             // Update Host

  1291.             kData->engine->callback(CALLBACK_NOTE_ON, fId, event.value1, event.value2, int(event.value3), nullptr);

  1292.             break;

  1293. 

  1294.         case kPluginPostRtEventNoteOff:

  1295.             // Update UI

  1296.             uiNoteOff(event.value1, event.value2);

  1297. 

  1298. #ifndef BUILD_BRIDGE

  1299.             // Update OSC control client

  1300.             if (kData->engine->isOscControlRegistered())

  1301.                 kData->engine->osc_send_control_note_off(fId, event.value1, event.value2);

  1302. #endif

  1303. 

  1304.             // Update Host

  1305.             kData->engine->callback(CALLBACK_NOTE_OFF, fId, event.value1, event.value2, 0.0, nullptr);

  1306.             break;

  1307.         }

  1308.     }

  1309. }

  1310. 

  1311. void CarlaPlugin::uiParameterChange(const uint32_t index, const float value)

  1312. {

  1313.     CARLA_ASSERT(index < parameterCount());

  1314.     return;

  1315. 

  1316.     // unused

  1317.     Q_UNUSED(index);

  1318.     Q_UNUSED(value);

  1319. }

  1320. 

  1321. void CarlaPlugin::uiProgramChange(const uint32_t index)

  1322. {

  1323.     CARLA_ASSERT(index < programCount());

  1324.     return;

  1325. 

  1326.     // unused

  1327.     Q_UNUSED(index);

  1328. }

  1329. 

  1330. void CarlaPlugin::uiMidiProgramChange(const uint32_t index)

  1331. {

  1332.     CARLA_ASSERT(index < midiProgramCount());

  1333.     return;

  1334. 

  1335.     // unused

  1336.     Q_UNUSED(index);

  1337. }

  1338. 

  1339. void CarlaPlugin::uiNoteOn(const uint8_t channel, const uint8_t note, const uint8_t velo)

  1340. {

  1341.     CARLA_ASSERT(channel < MAX_MIDI_CHANNELS);

  1342.     CARLA_ASSERT(note < MAX_MIDI_NOTE);

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

  1344.     return;

  1345. 

  1346.     // unused

  1347.     Q_UNUSED(channel);

  1348.     Q_UNUSED(note);

  1349.     Q_UNUSED(velo);

  1350. }

  1351. 

  1352. void CarlaPlugin::uiNoteOff(const uint8_t channel, const uint8_t note)

  1353. {

  1354.     CARLA_ASSERT(channel < MAX_MIDI_CHANNELS);

  1355.     CARLA_ASSERT(note < MAX_MIDI_NOTE);

  1356.     return;

  1357. 

  1358.     // unused

  1359.     Q_UNUSED(channel);

  1360.     Q_UNUSED(note);

  1361. }

  1362. 

  1363. // -------------------------------------------------------------------

  1364. // Cleanup

  1365. 

  1366. void CarlaPlugin::initBuffers()

  1367. {

  1368.     kData->audioIn.initBuffers(kData->engine);

  1369.     kData->audioOut.initBuffers(kData->engine);

  1370.     kData->event.initBuffers(kData->engine);

  1371. }

  1372. 

  1373. void CarlaPlugin::deleteBuffers()

  1374. {

  1375.     qDebug("CarlaPlugin::deleteBuffers() - start");

  1376. 

  1377.     kData->audioIn.clear();

  1378.     kData->audioOut.clear();

  1379.     kData->param.clear();

  1380.     kData->event.clear();

  1381. 

  1382.     qDebug("CarlaPlugin::deleteBuffers() - end");

  1383. }

  1384. 

  1385. // -------------------------------------------------------------------

  1386. // Library functions

  1387. 

  1388. bool CarlaPlugin::libOpen(const char* const filename)

  1389. {

  1390.     kData->lib = lib_open(filename);

  1391.     return bool(kData->lib);

  1392. }

  1393. 

  1394. bool CarlaPlugin::libClose()

  1395. {

  1396.     if (kData->lib == nullptr)

  1397.         return false;

  1398. 

  1399.     const bool ret = lib_close(kData->lib);

  1400.     kData->lib = nullptr;

  1401.     return ret;

  1402. }

  1403. 

  1404. void* CarlaPlugin::libSymbol(const char* const symbol)

  1405. {

  1406.     return lib_symbol(kData->lib, symbol);

  1407. }

  1408. 

  1409. const char* CarlaPlugin::libError(const char* const filename)

  1410. {

  1411.     return lib_error(filename);

  1412. }

  1413. 

  1414. // -------------------------------------------------------------------

  1415. // Scoped Disabler

  1416. 

  1417. CarlaPlugin::ScopedDisabler::ScopedDisabler(CarlaPlugin* const plugin)

  1418.     : kPlugin(plugin)

  1419. {

  1420.     if (plugin->fEnabled)

  1421.     {

  1422.         plugin->fEnabled = false;

  1423.         plugin->kData->engine->waitForProccessEnd();

  1424.     }

  1425. }

  1426. 

  1427. CarlaPlugin::ScopedDisabler::~ScopedDisabler()

  1428. {

  1429.     kPlugin->fEnabled = true;

  1430. }

  1431. 

  1432. // -------------------------------------------------------------------

  1433. // CarlaPluginGUI

  1434. 

  1435. CarlaPluginGUI::CarlaPluginGUI(QWidget* const parent, Callback* const callback)

  1436.     : QMainWindow(parent),

  1437.       kCallback(callback)

  1438. {

  1439.     qDebug("CarlaPluginGUI::CarlaPluginGUI(%p)", parent);

  1440.     //CARLA_ASSERT(callback);

  1441. 

  1442.     //m_container = new GuiContainer(this);

  1443.     //setCentralWidget(m_container);

  1444.     //adjustSize();

  1445. 

  1446.     //m_container->setParent(this);

  1447.     //m_container->show();

  1448. 

  1449.     //m_resizable = true;

  1450. 

  1451.     //setNewSize(50, 50);

  1452. 

  1453.     QMainWindow::setVisible(false);

  1454. }

  1455. 

  1456. CarlaPluginGUI::~CarlaPluginGUI()

  1457. {

  1458.     qDebug("CarlaPluginGUI::~CarlaPluginGUI()");

  1459.     //CARLA_ASSERT(m_container);

  1460. 

  1461.     // FIXME, automatically deleted by parent ?

  1462.     //delete m_container;

  1463. }

  1464. 

  1465. #if 0

  1466. 

  1467. // -------------------------------------------------------------------

  1468. 

  1469. GuiContainer* CarlaPluginGUI::getContainer() const

  1470. {

  1471.     return m_container;

  1472. }

  1473. 

  1474. WId CarlaPluginGUI::getWinId() const

  1475. {

  1476.     return m_container->winId();

  1477. }

  1478. 

  1479. // -------------------------------------------------------------------

  1480. 

  1481. void CarlaPluginGUI::setNewSize(int width, int height)

  1482. {

  1483.     qDebug("CarlaPluginGUI::setNewSize(%i, %i)", width, height);

  1484. 

  1485.     if (width < 30)

  1486.         width = 30;

  1487.     if (height < 30)

  1488.         height = 30;

  1489. 

  1490.     if (m_resizable)

  1491.     {

  1492.         resize(width, height);

  1493.     }

  1494.     else

  1495.     {

  1496.         setFixedSize(width, height);

  1497.         m_container->setFixedSize(width, height);

  1498.     }

  1499. }

  1500. 

  1501. void CarlaPluginGUI::setResizable(bool resizable)

  1502. {

  1503.     m_resizable = resizable;

  1504.     setNewSize(width(), height());

  1505. 

  1506. #ifdef Q_OS_WIN

  1507.     if (! resizable)

  1508.         setWindowFlags(windowFlags() | Qt::MSWindowsFixedSizeDialogHint);

  1509. #endif

  1510. }

  1511. 

  1512. void CarlaPluginGUI::setTitle(const char* const title)

  1513. {

  1514.     CARLA_ASSERT(title);

  1515.     setWindowTitle(QString("%1 (GUI)").arg(title));

  1516. }

  1517. 

  1518. void CarlaPluginGUI::setVisible(const bool yesNo)

  1519. {

  1520.     qDebug("CarlaPluginGUI::setVisible(%s)", bool2str(yesNo));

  1521. 

  1522.     if (yesNo)

  1523.     {

  1524.         if (! m_geometry.isNull())

  1525.             restoreGeometry(m_geometry);

  1526.     }

  1527.     else

  1528.         m_geometry = saveGeometry();

  1529. 

  1530.     QMainWindow::setVisible(yesNo);

  1531. }

  1532. 

  1533. // -------------------------------------------------------------------

  1534. 

  1535. void CarlaPluginGUI::hideEvent(QHideEvent* const event)

  1536. {

  1537.     qDebug("CarlaPluginGUI::hideEvent(%p)", event);

  1538.     CARLA_ASSERT(event);

  1539. 

  1540.     event->accept();

  1541.     close();

  1542. }

  1543. 

  1544. void CarlaPluginGUI::closeEvent(QCloseEvent* const event)

  1545. {

  1546.     qDebug("CarlaPluginGUI::closeEvent(%p)", event);

  1547.     CARLA_ASSERT(event);

  1548. 

  1549.     if (event->spontaneous())

  1550.     {

  1551.         if (m_callback)

  1552.             m_callback->guiClosedCallback();

  1553. 

  1554.         QMainWindow::closeEvent(event);

  1555.         return;

  1556.     }

  1557. 

  1558.     event->ignore();

  1559. }

  1560. #endif

  1561. 

  1562. // -------------------------------------------------------------------

  1563. 

  1564. CARLA_BACKEND_END_NAMESPACE