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

1876 lines
61KB
Raw Blame History 

  1. /*

  2.  * Carla Plugin Host

  3.  * Copyright (C) 2011-2014 Filipe Coelho <falktx@falktx.com>

  4.  *

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

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

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

  8.  * the License, or any later version.

  9.  *

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

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

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

  13.  * GNU General Public License for more details.

  14.  *

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

  16.  */

  17. 

  18. #include "CarlaEngineGraph.hpp"

  19. #include "CarlaEngineInternal.hpp"

  20. #include "CarlaPlugin.hpp"

  21. 

  22. #include "CarlaMathUtils.hpp"

  23. #include "CarlaMIDI.h"

  24. 

  25. using juce::AudioPluginInstance;

  26. using juce::AudioProcessor;

  27. using juce::AudioProcessorEditor;

  28. using juce::FloatVectorOperations;

  29. using juce::MemoryBlock;

  30. using juce::PluginDescription;

  31. using juce::String;

  32. using juce::jmax;

  33. 

  34. CARLA_BACKEND_START_NAMESPACE

  35. 

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

  37. // Rack Graph stuff

  38. 

  39. static inline

  40. uint getCarlaRackPortIdFromName(const char* const shortname) noexcept

  41. {

  42.     if (std::strcmp(shortname, "AudioIn1") == 0 || std::strcmp(shortname, "audio-in1") == 0)

  43.         return RACK_GRAPH_CARLA_PORT_AUDIO_IN1;

  44.     if (std::strcmp(shortname, "AudioIn2") == 0 || std::strcmp(shortname, "audio-in2") == 0)

  45.         return RACK_GRAPH_CARLA_PORT_AUDIO_IN2;

  46.     if (std::strcmp(shortname, "AudioOut1") == 0 || std::strcmp(shortname, "audio-out1") == 0)

  47.         return RACK_GRAPH_CARLA_PORT_AUDIO_OUT1;

  48.     if (std::strcmp(shortname, "AudioOut2") == 0 || std::strcmp(shortname, "audio-out2") == 0)

  49.         return RACK_GRAPH_CARLA_PORT_AUDIO_OUT2;

  50.     if (std::strcmp(shortname, "MidiIn") == 0 || std::strcmp(shortname, "midi-in") == 0)

  51.         return RACK_GRAPH_CARLA_PORT_MIDI_IN;

  52.     if (std::strcmp(shortname, "MidiOut") == 0 || std::strcmp(shortname, "midi-out") == 0)

  53.         return RACK_GRAPH_CARLA_PORT_MIDI_OUT;

  54. 

  55.     carla_stderr("CarlaBackend::getCarlaRackPortIdFromName(%s) - invalid short name", shortname);

  56.     return RACK_GRAPH_CARLA_PORT_NULL;

  57. }

  58. 

  59. static inline

  60. const char* getCarlaRackFullPortNameFromId(const /*RackGraphCarlaPortIds*/ uint portId)

  61. {

  62.     switch (portId)

  63.     {

  64.     case RACK_GRAPH_CARLA_PORT_AUDIO_IN1:

  65.         return "Carla:AudioIn1";

  66.     case RACK_GRAPH_CARLA_PORT_AUDIO_IN2:

  67.         return "Carla:AudioIn2";

  68.     case RACK_GRAPH_CARLA_PORT_AUDIO_OUT1:

  69.         return "Carla:AudioOut1";

  70.     case RACK_GRAPH_CARLA_PORT_AUDIO_OUT2:

  71.         return "Carla:AudioOut2";

  72.     case RACK_GRAPH_CARLA_PORT_MIDI_IN:

  73.         return "Carla:MidiIn";

  74.     case RACK_GRAPH_CARLA_PORT_MIDI_OUT:

  75.         return "Carla:MidiOut";

  76.     //case RACK_GRAPH_CARLA_PORT_NULL:

  77.     //case RACK_GRAPH_CARLA_PORT_MAX:

  78.     //    break;

  79.     }

  80. 

  81.     carla_stderr("CarlaBackend::getCarlaRackFullPortNameFromId(%i) - invalid port id", portId);

  82.     return nullptr;

  83. }

  84. 

  85. // -----------------------------------------------------------------------

  86. // RackGraph Audio

  87. 

  88. RackGraph::Audio::Audio() noexcept

  89.     : mutex(),

  90.       connectedIn1(),

  91.       connectedIn2(),

  92.       connectedOut1(),

  93.       connectedOut2()

  94. #ifdef CARLA_PROPER_CPP11_SUPPORT

  95.     , inBuf{nullptr, nullptr},

  96.       inBufTmp{nullptr, nullptr},

  97.       outBuf{nullptr, nullptr} {}

  98. #else

  99.     {

  100.         inBuf[0]    = inBuf[1]    = nullptr;

  101.         inBufTmp[0] = inBufTmp[1] = nullptr;

  102.         outBuf[0]   = outBuf[1]   = nullptr;

  103.     }

  104. #endif

  105. 

  106. // -----------------------------------------------------------------------

  107. // RackGraph MIDI

  108. 

  109. RackGraph::MIDI::MIDI() noexcept

  110.     : ins(),

  111.       outs() {}

  112. 

  113. const char* RackGraph::MIDI::getName(const bool isInput, const uint portId) const noexcept

  114. {

  115.     for (LinkedList<PortNameToId>::Itenerator it = isInput ? ins.begin() : outs.begin(); it.valid(); it.next())

  116.     {

  117.         static const PortNameToId portNameFallback = { 0, 0, { '\0' }, { '\0' } };

  118. 

  119.         const PortNameToId& portNameToId(it.getValue(portNameFallback));

  120.         CARLA_SAFE_ASSERT_CONTINUE(portNameToId.group != 0);

  121. 

  122.         if (portNameToId.port == portId)

  123.             return portNameToId.name;

  124.     }

  125. 

  126.     return nullptr;

  127. }

  128. 

  129. uint RackGraph::MIDI::getPortId(const bool isInput, const char portName[], bool* const ok) const noexcept

  130. {

  131.     for (LinkedList<PortNameToId>::Itenerator it = isInput ? ins.begin() : outs.begin(); it.valid(); it.next())

  132.     {

  133.         static const PortNameToId portNameFallback = { 0, 0, { '\0' }, { '\0' } };

  134. 

  135.         const PortNameToId& portNameToId(it.getValue(portNameFallback));

  136.         CARLA_SAFE_ASSERT_CONTINUE(portNameToId.group != 0);

  137. 

  138.         if (std::strncmp(portNameToId.name, portName, STR_MAX) == 0)

  139.         {

  140.             if (ok != nullptr)

  141.                 *ok = true;

  142.             return portNameToId.port;

  143.         }

  144.     }

  145. 

  146.     if (ok != nullptr)

  147.         *ok = false;

  148.     return 0;

  149. }

  150. 

  151. // -----------------------------------------------------------------------

  152. // RackGraph

  153. 

  154. RackGraph::RackGraph(const uint32_t bufferSize, const uint32_t ins, const uint32_t outs) noexcept

  155.     : connections(),

  156.       inputs(ins),

  157.       outputs(outs),

  158.       isOffline(false),

  159.       retCon(),

  160.       audio(),

  161.       midi()

  162. {

  163.     setBufferSize(bufferSize);

  164. }

  165. 

  166. RackGraph::~RackGraph() noexcept

  167. {

  168.     clearConnections();

  169. }

  170. 

  171. void RackGraph::setBufferSize(const uint32_t bufferSize) noexcept

  172. {

  173.     const int bufferSizei(static_cast<int>(bufferSize));

  174. 

  175.     if (audio.inBuf[0]    != nullptr) { delete[] audio.inBuf[0];    audio.inBuf[0]    = nullptr; }

  176.     if (audio.inBuf[1]    != nullptr) { delete[] audio.inBuf[1];    audio.inBuf[1]    = nullptr; }

  177.     if (audio.inBufTmp[0] != nullptr) { delete[] audio.inBufTmp[0]; audio.inBufTmp[0] = nullptr; }

  178.     if (audio.inBufTmp[1] != nullptr) { delete[] audio.inBufTmp[1]; audio.inBufTmp[1] = nullptr; }

  179.     if (audio.outBuf[0]   != nullptr) { delete[] audio.outBuf[0];   audio.outBuf[0]   = nullptr; }

  180.     if (audio.outBuf[1]   != nullptr) { delete[] audio.outBuf[1];   audio.outBuf[1]   = nullptr; }

  181. 

  182.     CARLA_SAFE_ASSERT_RETURN(bufferSize > 0,);

  183. 

  184.     try {

  185.         audio.inBufTmp[0] = new float[bufferSize];

  186.         audio.inBufTmp[1] = new float[bufferSize];

  187. 

  188.         if (inputs > 0 || outputs > 0)

  189.         {

  190.             audio.inBuf[0]  = new float[bufferSize];

  191.             audio.inBuf[1]  = new float[bufferSize];

  192.             audio.outBuf[0] = new float[bufferSize];

  193.             audio.outBuf[1] = new float[bufferSize];

  194.         }

  195.     }

  196.     catch(...) {

  197.         if (audio.inBufTmp[0] != nullptr) { delete[] audio.inBufTmp[0]; audio.inBufTmp[0] = nullptr; }

  198.         if (audio.inBufTmp[1] != nullptr) { delete[] audio.inBufTmp[1]; audio.inBufTmp[1] = nullptr; }

  199. 

  200.         if (inputs > 0 || outputs > 0)

  201.         {

  202.             if (audio.inBuf[0]  != nullptr) { delete[] audio.inBuf[0];  audio.inBuf[0]  = nullptr; }

  203.             if (audio.inBuf[1]  != nullptr) { delete[] audio.inBuf[1];  audio.inBuf[1]  = nullptr; }

  204.             if (audio.outBuf[0] != nullptr) { delete[] audio.outBuf[0]; audio.outBuf[0] = nullptr; }

  205.             if (audio.outBuf[1] != nullptr) { delete[] audio.outBuf[1]; audio.outBuf[1] = nullptr; }

  206.         }

  207.         return;

  208.     }

  209. 

  210.     FloatVectorOperations::clear(audio.inBufTmp[0], bufferSizei);

  211.     FloatVectorOperations::clear(audio.inBufTmp[1], bufferSizei);

  212. 

  213.     if (inputs > 0 || outputs > 0)

  214.     {

  215.         FloatVectorOperations::clear(audio.inBuf[0],  bufferSizei);

  216.         FloatVectorOperations::clear(audio.inBuf[1],  bufferSizei);

  217.         FloatVectorOperations::clear(audio.outBuf[0], bufferSizei);

  218.         FloatVectorOperations::clear(audio.outBuf[1], bufferSizei);

  219.     }

  220. }

  221. 

  222. void RackGraph::setOffline(const bool offline) noexcept

  223. {

  224.     isOffline = offline;

  225. }

  226. 

  227. bool RackGraph::connect(CarlaEngine* const engine, const uint groupA, const uint portA, const uint groupB, const uint portB) noexcept

  228. {

  229.     CARLA_SAFE_ASSERT_RETURN(engine != nullptr, false);

  230. 

  231.     uint otherGroup, otherPort, carlaPort;

  232. 

  233.     if (groupA == RACK_GRAPH_GROUP_CARLA)

  234.     {

  235.         CARLA_SAFE_ASSERT_RETURN(groupB != RACK_GRAPH_GROUP_CARLA, false);

  236. 

  237.         carlaPort  = portA;

  238.         otherGroup = groupB;

  239.         otherPort  = portB;

  240.     }

  241.     else

  242.     {

  243.         CARLA_SAFE_ASSERT_RETURN(groupB == RACK_GRAPH_GROUP_CARLA, false);

  244. 

  245.         carlaPort  = portB;

  246.         otherGroup = groupA;

  247.         otherPort  = portA;

  248.     }

  249. 

  250.     CARLA_SAFE_ASSERT_RETURN(carlaPort > RACK_GRAPH_CARLA_PORT_NULL && carlaPort < RACK_GRAPH_CARLA_PORT_MAX, false);

  251.     CARLA_SAFE_ASSERT_RETURN(otherGroup > RACK_GRAPH_GROUP_CARLA && otherGroup < RACK_GRAPH_GROUP_MAX, false);

  252. 

  253.     bool makeConnection = false;

  254. 

  255.     switch (carlaPort)

  256.     {

  257.     case RACK_GRAPH_CARLA_PORT_AUDIO_IN1:

  258.         CARLA_SAFE_ASSERT_RETURN(otherGroup == RACK_GRAPH_GROUP_AUDIO_IN, false);

  259.         audio.mutex.lock();

  260.         makeConnection = audio.connectedIn1.append(otherPort);

  261.         audio.mutex.unlock();

  262.         break;

  263. 

  264.     case RACK_GRAPH_CARLA_PORT_AUDIO_IN2:

  265.         CARLA_SAFE_ASSERT_RETURN(otherGroup == RACK_GRAPH_GROUP_AUDIO_IN, false);

  266.         audio.mutex.lock();

  267.         makeConnection = audio.connectedIn2.append(otherPort);

  268.         audio.mutex.unlock();

  269.         break;

  270. 

  271.     case RACK_GRAPH_CARLA_PORT_AUDIO_OUT1:

  272.         CARLA_SAFE_ASSERT_RETURN(otherGroup == RACK_GRAPH_GROUP_AUDIO_OUT, false);

  273.         audio.mutex.lock();

  274.         makeConnection = audio.connectedOut1.append(otherPort);

  275.         audio.mutex.unlock();

  276.         break;

  277. 

  278.     case RACK_GRAPH_CARLA_PORT_AUDIO_OUT2:

  279.         CARLA_SAFE_ASSERT_RETURN(otherGroup == RACK_GRAPH_GROUP_AUDIO_OUT, false);

  280.         audio.mutex.lock();

  281.         makeConnection = audio.connectedOut2.append(otherPort);

  282.         audio.mutex.unlock();

  283.         break;

  284. 

  285.     case RACK_GRAPH_CARLA_PORT_MIDI_IN:

  286.         CARLA_SAFE_ASSERT_RETURN(otherGroup == RACK_GRAPH_GROUP_MIDI_IN, false);

  287.         if (const char* const portName = midi.getName(true, otherPort))

  288.             makeConnection = engine->connectRackMidiInPort(portName);

  289.         break;

  290. 

  291.     case RACK_GRAPH_CARLA_PORT_MIDI_OUT:

  292.         CARLA_SAFE_ASSERT_RETURN(otherGroup == RACK_GRAPH_GROUP_MIDI_OUT, false);

  293.         if (const char* const portName = midi.getName(false, otherPort))

  294.             makeConnection = engine->connectRackMidiOutPort(portName);

  295.         break;

  296.     }

  297. 

  298.     if (! makeConnection)

  299.     {

  300.         engine->setLastError("Invalid rack connection");

  301.         return false;

  302.     }

  303. 

  304.     ConnectionToId connectionToId;

  305.     connectionToId.setData(++connections.lastId, groupA, portA, groupB, portB);

  306. 

  307.     char strBuf[STR_MAX+1];

  308.     strBuf[STR_MAX] = '\0';

  309.     std::snprintf(strBuf, STR_MAX, "%u:%u:%u:%u", groupA, portA, groupB, portB);

  310. 

  311.     engine->callback(ENGINE_CALLBACK_PATCHBAY_CONNECTION_ADDED, connectionToId.id, 0, 0, 0.0f, strBuf);

  312. 

  313.     connections.list.append(connectionToId);

  314.     return true;

  315. }

  316. 

  317. bool RackGraph::disconnect(CarlaEngine* const engine, const uint connectionId) noexcept

  318. {

  319.     CARLA_SAFE_ASSERT_RETURN(engine != nullptr, false);

  320.     CARLA_SAFE_ASSERT_RETURN(connections.list.count() > 0, false);

  321. 

  322.     for (LinkedList<ConnectionToId>::Itenerator it=connections.list.begin(); it.valid(); it.next())

  323.     {

  324.         static const ConnectionToId fallback = { 0, 0, 0, 0, 0 };

  325. 

  326.         const ConnectionToId& connectionToId(it.getValue(fallback));

  327.         CARLA_SAFE_ASSERT_CONTINUE(connectionToId.id != 0);

  328. 

  329.         if (connectionToId.id != connectionId)

  330.             continue;

  331. 

  332.         uint otherGroup, otherPort, carlaPort;

  333. 

  334.         if (connectionToId.groupA == RACK_GRAPH_GROUP_CARLA)

  335.         {

  336.             CARLA_SAFE_ASSERT_RETURN(connectionToId.groupB != RACK_GRAPH_GROUP_CARLA, false);

  337. 

  338.             carlaPort  = connectionToId.portA;

  339.             otherGroup = connectionToId.groupB;

  340.             otherPort  = connectionToId.portB;

  341.         }

  342.         else

  343.         {

  344.             CARLA_SAFE_ASSERT_RETURN(connectionToId.groupB == RACK_GRAPH_GROUP_CARLA, false);

  345. 

  346.             carlaPort  = connectionToId.portB;

  347.             otherGroup = connectionToId.groupA;

  348.             otherPort  = connectionToId.portA;

  349.         }

  350. 

  351.         CARLA_SAFE_ASSERT_RETURN(carlaPort > RACK_GRAPH_CARLA_PORT_NULL && carlaPort < RACK_GRAPH_CARLA_PORT_MAX, false);

  352.         CARLA_SAFE_ASSERT_RETURN(otherGroup > RACK_GRAPH_GROUP_CARLA && otherGroup < RACK_GRAPH_GROUP_MAX, false);

  353. 

  354.         bool makeDisconnection = false;

  355. 

  356.         switch (carlaPort)

  357.         {

  358.         case RACK_GRAPH_CARLA_PORT_AUDIO_IN1:

  359.             audio.mutex.lock();

  360.             makeDisconnection = audio.connectedIn1.removeOne(otherPort);

  361.             audio.mutex.unlock();

  362.             break;

  363. 

  364.         case RACK_GRAPH_CARLA_PORT_AUDIO_IN2:

  365.             audio.mutex.lock();

  366.             makeDisconnection = audio.connectedIn2.removeOne(otherPort);

  367.             audio.mutex.unlock();

  368.             break;

  369. 

  370.         case RACK_GRAPH_CARLA_PORT_AUDIO_OUT1:

  371.             audio.mutex.lock();

  372.             makeDisconnection = audio.connectedOut1.removeOne(otherPort);

  373.             audio.mutex.unlock();

  374.             break;

  375. 

  376.         case RACK_GRAPH_CARLA_PORT_AUDIO_OUT2:

  377.             audio.mutex.lock();

  378.             makeDisconnection = audio.connectedOut2.removeOne(otherPort);

  379.             audio.mutex.unlock();

  380.             break;

  381. 

  382.         case RACK_GRAPH_CARLA_PORT_MIDI_IN:

  383.             if (const char* const portName = midi.getName(true, otherPort))

  384.                 makeDisconnection = engine->disconnectRackMidiInPort(portName);

  385.             break;

  386. 

  387.         case RACK_GRAPH_CARLA_PORT_MIDI_OUT:

  388.             if (const char* const portName = midi.getName(false, otherPort))

  389.                 makeDisconnection = engine->disconnectRackMidiOutPort(portName);

  390.             break;

  391.         }

  392. 

  393.         if (! makeDisconnection)

  394.         {

  395.             engine->setLastError("Invalid rack connection");

  396.             return false;

  397.         }

  398. 

  399.         engine->callback(ENGINE_CALLBACK_PATCHBAY_CONNECTION_REMOVED, connectionToId.id, 0, 0, 0.0f, nullptr);

  400. 

  401.         connections.list.remove(it);

  402.         return true;

  403.     }

  404. 

  405.     engine->setLastError("Failed to find connection");

  406.     return false;

  407. }

  408. 

  409. void RackGraph::clearConnections() noexcept

  410. {

  411.     connections.clear();

  412. 

  413.     audio.mutex.lock();

  414.     audio.connectedIn1.clear();

  415.     audio.connectedIn2.clear();

  416.     audio.connectedOut1.clear();

  417.     audio.connectedOut2.clear();

  418.     audio.mutex.unlock();

  419. 

  420.     midi.ins.clear();

  421.     midi.outs.clear();

  422. }

  423. 

  424. const char* const* RackGraph::getConnections() const noexcept

  425. {

  426.     if (connections.list.count() == 0)

  427.         return nullptr;

  428. 

  429.     CarlaStringList connList;

  430. 

  431.     char strBuf[STR_MAX+1];

  432.     strBuf[STR_MAX] = '\0';

  433. 

  434.     for (LinkedList<ConnectionToId>::Itenerator it=connections.list.begin(); it.valid(); it.next())

  435.     {

  436.         static const ConnectionToId fallback = { 0, 0, 0, 0, 0 };

  437. 

  438.         const ConnectionToId& connectionToId(it.getValue(fallback));

  439.         CARLA_SAFE_ASSERT_CONTINUE(connectionToId.id != 0);

  440. 

  441.         uint otherGroup, otherPort, carlaPort;

  442. 

  443.         if (connectionToId.groupA == RACK_GRAPH_GROUP_CARLA)

  444.         {

  445.             CARLA_SAFE_ASSERT_CONTINUE(connectionToId.groupB != RACK_GRAPH_GROUP_CARLA);

  446. 

  447.             carlaPort  = connectionToId.portA;

  448.             otherGroup = connectionToId.groupB;

  449.             otherPort  = connectionToId.portB;

  450.         }

  451.         else

  452.         {

  453.             CARLA_SAFE_ASSERT_CONTINUE(connectionToId.groupB == RACK_GRAPH_GROUP_CARLA);

  454. 

  455.             carlaPort  = connectionToId.portB;

  456.             otherGroup = connectionToId.groupA;

  457.             otherPort  = connectionToId.portA;

  458.         }

  459. 

  460.         CARLA_SAFE_ASSERT_CONTINUE(carlaPort > RACK_GRAPH_CARLA_PORT_NULL && carlaPort < RACK_GRAPH_CARLA_PORT_MAX);

  461.         CARLA_SAFE_ASSERT_CONTINUE(otherGroup > RACK_GRAPH_GROUP_CARLA && otherGroup < RACK_GRAPH_GROUP_MAX);

  462. 

  463.         switch (carlaPort)

  464.         {

  465.         case RACK_GRAPH_CARLA_PORT_AUDIO_IN1:

  466.         case RACK_GRAPH_CARLA_PORT_AUDIO_IN2:

  467.             std::snprintf(strBuf, STR_MAX, "AudioIn:%i", otherPort+1);

  468.             connList.append(strBuf);

  469.             connList.append(getCarlaRackFullPortNameFromId(carlaPort));

  470.             break;

  471. 

  472.         case RACK_GRAPH_CARLA_PORT_AUDIO_OUT1:

  473.         case RACK_GRAPH_CARLA_PORT_AUDIO_OUT2:

  474.             std::snprintf(strBuf, STR_MAX, "AudioOut:%i", otherPort+1);

  475.             connList.append(getCarlaRackFullPortNameFromId(carlaPort));

  476.             connList.append(strBuf);

  477.             break;

  478. 

  479.         case RACK_GRAPH_CARLA_PORT_MIDI_IN:

  480.             std::snprintf(strBuf, STR_MAX, "MidiIn:%s", midi.getName(true, otherPort));

  481.             connList.append(strBuf);

  482.             connList.append(getCarlaRackFullPortNameFromId(carlaPort));

  483.             break;

  484. 

  485.         case RACK_GRAPH_CARLA_PORT_MIDI_OUT:

  486.             std::snprintf(strBuf, STR_MAX, "MidiOut:%s", midi.getName(false, otherPort));

  487.             connList.append(getCarlaRackFullPortNameFromId(carlaPort));

  488.             connList.append(strBuf);

  489.             break;

  490.         }

  491.     }

  492. 

  493.     if (connList.count() == 0)

  494.         return nullptr;

  495. 

  496.     retCon = connList.toCharStringListPtr();

  497. 

  498.     return retCon;

  499. }

  500. 

  501. bool RackGraph::getGroupAndPortIdFromFullName(const char* const fullPortName, uint& groupId, uint& portId) const noexcept

  502. {

  503.     CARLA_SAFE_ASSERT_RETURN(fullPortName != nullptr && fullPortName[0] != '\0', false);

  504. 

  505.     if (std::strncmp(fullPortName, "Carla:", 6) == 0)

  506.     {

  507.         groupId = RACK_GRAPH_GROUP_CARLA;

  508.         portId  = getCarlaRackPortIdFromName(fullPortName+6);

  509. 

  510.         if (portId > RACK_GRAPH_CARLA_PORT_NULL && portId < RACK_GRAPH_CARLA_PORT_MAX)

  511.             return true;

  512.     }

  513.     else if (std::strncmp(fullPortName, "AudioIn:", 8) == 0)

  514.     {

  515.         groupId = RACK_GRAPH_GROUP_AUDIO_IN;

  516. 

  517.         if (const int portTest = std::atoi(fullPortName+8))

  518.         {

  519.             portId = static_cast<uint>(portTest-1);

  520.             return true;

  521.         }

  522.     }

  523.     else if (std::strncmp(fullPortName, "AudioOut:", 9) == 0)

  524.     {

  525.         groupId = RACK_GRAPH_GROUP_AUDIO_OUT;

  526. 

  527.         if (const int portTest = std::atoi(fullPortName+9))

  528.         {

  529.             portId = static_cast<uint>(portTest-1);

  530.             return true;

  531.         }

  532.     }

  533.     else if (std::strncmp(fullPortName, "MidiIn:", 7) == 0)

  534.     {

  535.         groupId = RACK_GRAPH_GROUP_MIDI_IN;

  536. 

  537.         if (const char* const portName = fullPortName+7)

  538.         {

  539.             bool ok;

  540.             portId = midi.getPortId(true, portName, &ok);

  541.             return ok;

  542.         }

  543.     }

  544.     else if (std::strncmp(fullPortName, "MidiOut:", 8) == 0)

  545.     {

  546.         groupId = RACK_GRAPH_GROUP_MIDI_OUT;

  547. 

  548.         if (const char* const portName = fullPortName+8)

  549.         {

  550.             bool ok;

  551.             portId = midi.getPortId(false, portName, &ok);

  552.             return ok;

  553.         }

  554.     }

  555. 

  556.     return false;

  557. }

  558. 

  559. void RackGraph::process(CarlaEngine::ProtectedData* const data, const float* inBufReal[2], float* outBuf[2], const uint32_t frames)

  560. {

  561.     CARLA_SAFE_ASSERT_RETURN(data != nullptr,);

  562.     CARLA_SAFE_ASSERT_RETURN(data->events.in != nullptr,);

  563.     CARLA_SAFE_ASSERT_RETURN(data->events.out != nullptr,);

  564. 

  565.     const int iframes(static_cast<int>(frames));

  566. 

  567.     // safe copy

  568.     float inBuf0[frames];

  569.     float inBuf1[frames];

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

  571. 

  572.     // initialize audio inputs

  573.     FloatVectorOperations::copy(inBuf0, inBufReal[0], iframes);

  574.     FloatVectorOperations::copy(inBuf1, inBufReal[1], iframes);

  575. 

  576.     // initialize audio outputs (zero)

  577.     FloatVectorOperations::clear(outBuf[0], iframes);

  578.     FloatVectorOperations::clear(outBuf[1], iframes);

  579. 

  580.     // initialize event outputs (zero)

  581.     carla_zeroStruct<EngineEvent>(data->events.out, kMaxEngineEventInternalCount);

  582. 

  583.     bool processed = false;

  584. 

  585.     uint32_t oldAudioInCount = 0;

  586.     uint32_t oldMidiOutCount = 0;

  587. 

  588.     // process plugins

  589.     for (uint i=0; i < data->curPluginCount; ++i)

  590.     {

  591.         CarlaPlugin* const plugin = data->plugins[i].plugin;

  592. 

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

  594.             continue;

  595. 

  596.         if (processed)

  597.         {

  598.             // initialize audio inputs (from previous outputs)

  599.             FloatVectorOperations::copy(inBuf0, outBuf[0], iframes);

  600.             FloatVectorOperations::copy(inBuf1, outBuf[1], iframes);

  601. 

  602.             // initialize audio outputs (zero)

  603.             FloatVectorOperations::clear(outBuf[0], iframes);

  604.             FloatVectorOperations::clear(outBuf[1], iframes);

  605. 

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

  607.             if (oldMidiOutCount == 0 && data->events.in[0].type != kEngineEventTypeNull)

  608.             {

  609.                 if (data->events.out[0].type != kEngineEventTypeNull)

  610.                 {

  611.                     // TODO: carefully add to input, sorted events

  612.                 }

  613.                 // else nothing needed

  614.             }

  615.             else

  616.             {

  617.                 // initialize event inputs from previous outputs

  618.                 carla_copyStruct<EngineEvent>(data->events.in, data->events.out, kMaxEngineEventInternalCount);

  619. 

  620.                 // initialize event outputs (zero)

  621.                 carla_zeroStruct<EngineEvent>(data->events.out, kMaxEngineEventInternalCount);

  622.             }

  623.         }

  624. 

  625.         oldAudioInCount = plugin->getAudioInCount();

  626.         oldMidiOutCount = plugin->getMidiOutCount();

  627. 

  628.         // process

  629.         plugin->initBuffers();

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

  631.         plugin->unlock();

  632. 

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

  634.         if (oldAudioInCount == 0)

  635.         {

  636.             FloatVectorOperations::add(outBuf[0], inBuf0, iframes);

  637.             FloatVectorOperations::add(outBuf[1], inBuf1, iframes);

  638.         }

  639. 

  640.         // set peaks

  641.         {

  642.             EnginePluginData& pluginData(data->plugins[i]);

  643. 

  644.             juce::Range<float> range;

  645. 

  646.             if (oldAudioInCount > 0)

  647.             {

  648.                 range = FloatVectorOperations::findMinAndMax(inBuf0, iframes);

  649.                 pluginData.insPeak[0] = carla_max<float>(std::abs(range.getStart()), std::abs(range.getEnd()), 1.0f);

  650. 

  651.                 range = FloatVectorOperations::findMinAndMax(inBuf1, iframes);

  652.                 pluginData.insPeak[1] = carla_max<float>(std::abs(range.getStart()), std::abs(range.getEnd()), 1.0f);

  653.             }

  654.             else

  655.             {

  656.                 pluginData.insPeak[0] = 0.0f;

  657.                 pluginData.insPeak[1] = 0.0f;

  658.             }

  659. 

  660.             if (plugin->getAudioOutCount() > 0)

  661.             {

  662.                 range = FloatVectorOperations::findMinAndMax(outBuf[0], iframes);

  663.                 pluginData.outsPeak[0] = carla_max<float>(std::abs(range.getStart()), std::abs(range.getEnd()), 1.0f);

  664. 

  665.                 range = FloatVectorOperations::findMinAndMax(outBuf[1], iframes);

  666.                 pluginData.outsPeak[1] = carla_max<float>(std::abs(range.getStart()), std::abs(range.getEnd()), 1.0f);

  667.             }

  668.             else

  669.             {

  670.                 pluginData.outsPeak[0] = 0.0f;

  671.                 pluginData.outsPeak[1] = 0.0f;

  672.             }

  673.         }

  674. 

  675.         processed = true;

  676.     }

  677. }

  678. 

  679. void RackGraph::processHelper(CarlaEngine::ProtectedData* const data, const float* const* const inBuf, float* const* const outBuf, const uint32_t frames)

  680. {

  681.     CARLA_SAFE_ASSERT_RETURN(audio.outBuf[1] != nullptr,);

  682. 

  683.     const int iframes(static_cast<int>(frames));

  684. 

  685.     const CarlaRecursiveMutexLocker _cml(audio.mutex);

  686. 

  687.     if (inBuf != nullptr && inputs > 0)

  688.     {

  689.         bool noConnections = true;

  690. 

  691.         // connect input buffers

  692.         for (LinkedList<uint>::Itenerator it = audio.connectedIn1.begin(); it.valid(); it.next())

  693.         {

  694.             const uint& port(it.getValue(0));

  695.             CARLA_SAFE_ASSERT_CONTINUE(port != 0);

  696.             CARLA_SAFE_ASSERT_CONTINUE(port < inputs);

  697. 

  698.             if (noConnections)

  699.             {

  700.                 FloatVectorOperations::copy(audio.inBuf[0], inBuf[port], iframes);

  701.                 noConnections = false;

  702.             }

  703.             else

  704.             {

  705.                 FloatVectorOperations::add(audio.inBuf[0], inBuf[port], iframes);

  706.             }

  707.         }

  708. 

  709.         if (noConnections)

  710.             FloatVectorOperations::clear(audio.inBuf[0], iframes);

  711. 

  712.         noConnections = true;

  713. 

  714.         for (LinkedList<uint>::Itenerator it = audio.connectedIn2.begin(); it.valid(); it.next())

  715.         {

  716.             const uint& port(it.getValue(0));

  717.             CARLA_SAFE_ASSERT_CONTINUE(port != 0);

  718.             CARLA_SAFE_ASSERT_CONTINUE(port < inputs);

  719. 

  720.             if (noConnections)

  721.             {

  722.                 FloatVectorOperations::copy(audio.inBuf[1], inBuf[port], iframes);

  723.                 noConnections = false;

  724.             }

  725.             else

  726.             {

  727.                 FloatVectorOperations::add(audio.inBuf[1], inBuf[port], iframes);

  728.             }

  729.         }

  730. 

  731.         if (noConnections)

  732.             FloatVectorOperations::clear(audio.inBuf[1], iframes);

  733.     }

  734.     else

  735.     {

  736.         FloatVectorOperations::clear(audio.inBuf[0], iframes);

  737.         FloatVectorOperations::clear(audio.inBuf[1], iframes);

  738.     }

  739. 

  740.     FloatVectorOperations::clear(audio.outBuf[0], iframes);

  741.     FloatVectorOperations::clear(audio.outBuf[1], iframes);

  742. 

  743.     // process

  744.     process(data, const_cast<const float**>(audio.inBuf), audio.outBuf, frames);

  745. 

  746.     // connect output buffers

  747.     if (audio.connectedOut1.count() != 0)

  748.     {

  749.         for (LinkedList<uint>::Itenerator it = audio.connectedOut1.begin(); it.valid(); it.next())

  750.         {

  751.             const uint& port(it.getValue(0));

  752.             CARLA_SAFE_ASSERT_CONTINUE(port != 0);

  753.             CARLA_SAFE_ASSERT_CONTINUE(port < outputs);

  754. 

  755.             FloatVectorOperations::add(outBuf[port], audio.outBuf[0], iframes);

  756.         }

  757.     }

  758. 

  759.     if (audio.connectedOut2.count() != 0)

  760.     {

  761.         for (LinkedList<uint>::Itenerator it = audio.connectedOut2.begin(); it.valid(); it.next())

  762.         {

  763.             const uint& port(it.getValue(0));

  764.             CARLA_SAFE_ASSERT_CONTINUE(port != 0);

  765.             CARLA_SAFE_ASSERT_CONTINUE(port < outputs);

  766. 

  767.             FloatVectorOperations::add(outBuf[port], audio.outBuf[1], iframes);

  768.         }

  769.     }

  770. }

  771. 

  772. // -----------------------------------------------------------------------

  773. // Patchbay Graph stuff

  774. 

  775. static const uint32_t kAudioInputPortOffset  = MAX_PATCHBAY_PLUGINS*1;

  776. static const uint32_t kAudioOutputPortOffset = MAX_PATCHBAY_PLUGINS*2;

  777. static const uint32_t kMidiInputPortOffset   = MAX_PATCHBAY_PLUGINS*3;

  778. static const uint32_t kMidiOutputPortOffset  = MAX_PATCHBAY_PLUGINS*3+1;

  779. 

  780. static const uint kMidiChannelIndex = static_cast<uint>(AudioProcessorGraph::midiChannelIndex);

  781. 

  782. static inline

  783. bool adjustPatchbayPortIdForJuce(uint& portId)

  784. {

  785.     CARLA_SAFE_ASSERT_RETURN(portId >= kAudioInputPortOffset, false);

  786.     CARLA_SAFE_ASSERT_RETURN(portId <= kMidiOutputPortOffset, false);

  787. 

  788.     if (portId == kMidiInputPortOffset)

  789.     {

  790.         portId = kMidiChannelIndex;

  791.         return true;

  792.     }

  793.     if (portId == kMidiOutputPortOffset)

  794.     {

  795.         portId = kMidiChannelIndex;

  796.         return true;

  797.     }

  798.     if (portId >= kAudioOutputPortOffset)

  799.     {

  800.         portId -= kAudioOutputPortOffset;

  801.         return true;

  802.     }

  803.     if (portId >= kAudioInputPortOffset)

  804.     {

  805.         portId -= kAudioInputPortOffset;

  806.         return true;

  807.     }

  808. 

  809.     return false;

  810. }

  811. 

  812. static inline

  813. const String getProcessorFullPortName(AudioProcessor* const proc, const uint32_t portId)

  814. {

  815.     CARLA_SAFE_ASSERT_RETURN(proc != nullptr, String());

  816.     CARLA_SAFE_ASSERT_RETURN(portId >= kAudioInputPortOffset, String());

  817.     CARLA_SAFE_ASSERT_RETURN(portId <= kMidiOutputPortOffset, String());

  818. 

  819.     String fullPortName(proc->getName());

  820. 

  821.     if (portId == kMidiOutputPortOffset)

  822.     {

  823.         fullPortName += ":events-out";

  824.     }

  825.     else if (portId == kMidiInputPortOffset)

  826.     {

  827.         fullPortName += ":events-in";

  828.     }

  829.     else if (portId >= kAudioOutputPortOffset)

  830.     {

  831.         CARLA_SAFE_ASSERT_RETURN(proc->getNumOutputChannels() > 0, String());

  832.         fullPortName += ":" + proc->getOutputChannelName(static_cast<int>(portId-kAudioOutputPortOffset));

  833.     }

  834.     else if (portId >= kAudioInputPortOffset)

  835.     {

  836.         CARLA_SAFE_ASSERT_RETURN(proc->getNumInputChannels() > 0, String());

  837.         fullPortName += ":" + proc->getInputChannelName(static_cast<int>(portId-kAudioInputPortOffset));

  838.     }

  839.     else

  840.     {

  841.         return String();

  842.     }

  843. 

  844.     return fullPortName;

  845. }

  846. 

  847. static inline

  848. void addNodeToPatchbay(CarlaEngine* const engine, const uint32_t groupId, const int clientId, const AudioProcessor* const proc)

  849. {

  850.     CARLA_SAFE_ASSERT_RETURN(engine != nullptr,);

  851.     CARLA_SAFE_ASSERT_RETURN(proc != nullptr,);

  852. 

  853.     const int icon((clientId >= 0) ? PATCHBAY_ICON_PLUGIN : PATCHBAY_ICON_HARDWARE);

  854.     engine->callback(ENGINE_CALLBACK_PATCHBAY_CLIENT_ADDED, groupId, icon, clientId, 0.0f, proc->getName().toRawUTF8());

  855. 

  856.     for (int i=0, numInputs=proc->getNumInputChannels(); i<numInputs; ++i)

  857.     {

  858.         engine->callback(ENGINE_CALLBACK_PATCHBAY_PORT_ADDED, groupId, static_cast<int>(kAudioInputPortOffset)+i,

  859.                          PATCHBAY_PORT_TYPE_AUDIO|PATCHBAY_PORT_IS_INPUT, 0.0f, proc->getInputChannelName(i).toRawUTF8());

  860.     }

  861. 

  862.     for (int i=0, numOutputs=proc->getNumOutputChannels(); i<numOutputs; ++i)

  863.     {

  864.         engine->callback(ENGINE_CALLBACK_PATCHBAY_PORT_ADDED, groupId, static_cast<int>(kAudioOutputPortOffset)+i,

  865.                          PATCHBAY_PORT_TYPE_AUDIO, 0.0f, proc->getOutputChannelName(i).toRawUTF8());

  866.     }

  867. 

  868.     if (proc->acceptsMidi())

  869.     {

  870.         engine->callback(ENGINE_CALLBACK_PATCHBAY_PORT_ADDED, groupId, static_cast<int>(kMidiInputPortOffset),

  871.                          PATCHBAY_PORT_TYPE_MIDI|PATCHBAY_PORT_IS_INPUT, 0.0f, "events-in");

  872.     }

  873. 

  874.     if (proc->producesMidi())

  875.     {

  876.         engine->callback(ENGINE_CALLBACK_PATCHBAY_PORT_ADDED, groupId, static_cast<int>(kMidiOutputPortOffset),

  877.                          PATCHBAY_PORT_TYPE_MIDI, 0.0f, "events-out");

  878.     }

  879. }

  880. 

  881. static inline

  882. void removeNodeFromPatchbay(CarlaEngine* const engine, const uint32_t groupId, const AudioProcessor* const proc)

  883. {

  884.     CARLA_SAFE_ASSERT_RETURN(engine != nullptr,);

  885.     CARLA_SAFE_ASSERT_RETURN(proc != nullptr,);

  886. 

  887.     for (int i=0, numInputs=proc->getNumInputChannels(); i<numInputs; ++i)

  888.     {

  889.         engine->callback(ENGINE_CALLBACK_PATCHBAY_PORT_REMOVED, groupId, static_cast<int>(kAudioInputPortOffset)+i,

  890.                          0, 0.0f, nullptr);

  891.     }

  892. 

  893.     for (int i=0, numOutputs=proc->getNumOutputChannels(); i<numOutputs; ++i)

  894.     {

  895.         engine->callback(ENGINE_CALLBACK_PATCHBAY_PORT_REMOVED, groupId, static_cast<int>(kAudioOutputPortOffset)+i,

  896.                          0, 0.0f, nullptr);

  897.     }

  898. 

  899.     if (proc->acceptsMidi())

  900.     {

  901.         engine->callback(ENGINE_CALLBACK_PATCHBAY_PORT_REMOVED, groupId, static_cast<int>(kMidiInputPortOffset),

  902.                          0, 0.0f, nullptr);

  903.     }

  904. 

  905.     if (proc->producesMidi())

  906.     {

  907.         engine->callback(ENGINE_CALLBACK_PATCHBAY_PORT_REMOVED, groupId, static_cast<int>(kMidiOutputPortOffset),

  908.                          0, 0.0f, nullptr);

  909.     }

  910. 

  911.     engine->callback(ENGINE_CALLBACK_PATCHBAY_CLIENT_REMOVED, groupId, 0, 0, 0.0f, nullptr);

  912. }

  913. 

  914. // -----------------------------------------------------------------------

  915. 

  916. class CarlaPluginInstance : public AudioPluginInstance

  917. {

  918. public:

  919.     CarlaPluginInstance(CarlaPlugin* const plugin)

  920.         : fPlugin(plugin),

  921.           leakDetector_CarlaPluginInstance()

  922.     {

  923.         setPlayConfigDetails(static_cast<int>(fPlugin->getAudioInCount()),

  924.                              static_cast<int>(fPlugin->getAudioOutCount()),

  925.                              getSampleRate(), getBlockSize());

  926.     }

  927. 

  928.     ~CarlaPluginInstance() override

  929.     {

  930.     }

  931. 

  932.     // -------------------------------------------------------------------

  933. 

  934.     void* getPlatformSpecificData() noexcept override

  935.     {

  936.         return fPlugin;

  937.     }

  938. 

  939.     void fillInPluginDescription(PluginDescription& d) const override

  940.     {

  941.         d.pluginFormatName = "Carla";

  942.         d.category = "Carla Plugin";

  943.         d.version = "1.0";

  944. 

  945.         CARLA_SAFE_ASSERT_RETURN(fPlugin != nullptr,);

  946. 

  947.         char strBuf[STR_MAX+1];

  948.         strBuf[STR_MAX] = '\0';

  949. 

  950.         fPlugin->getRealName(strBuf);

  951.         d.name = strBuf;

  952. 

  953.         fPlugin->getLabel(strBuf);

  954.         d.descriptiveName = strBuf;

  955. 

  956.         fPlugin->getMaker(strBuf);

  957.         d.manufacturerName = strBuf;

  958. 

  959.         d.uid = d.name.hashCode();

  960.         d.isInstrument = (fPlugin->getHints() & PLUGIN_IS_SYNTH);

  961. 

  962.         d.numInputChannels  = static_cast<int>(fPlugin->getAudioInCount());

  963.         d.numOutputChannels = static_cast<int>(fPlugin->getAudioOutCount());

  964.         //d.hasSharedContainer = true;

  965.     }

  966. 

  967.     // -------------------------------------------------------------------

  968. 

  969.     const String getName() const override

  970.     {

  971.         return fPlugin->getName();

  972.     }

  973. 

  974.     void processBlock(AudioSampleBuffer& audio, MidiBuffer& midi)

  975.     {

  976.         if (! fPlugin->isEnabled())

  977.         {

  978.             audio.clear();

  979.             midi.clear();

  980.             return;

  981.         }

  982. 

  983.         CarlaEngine* const engine(fPlugin->getEngine());

  984.         CARLA_SAFE_ASSERT_RETURN(engine != nullptr,);

  985. 

  986.         if (! fPlugin->tryLock(engine->isOffline()))

  987.         {

  988.             audio.clear();

  989.             midi.clear();

  990.             return;

  991.         }

  992. 

  993.         fPlugin->initBuffers();

  994. 

  995.         if (CarlaEngineEventPort* const port = fPlugin->getDefaultEventInPort())

  996.         {

  997.             EngineEvent* const engineEvents(port->fBuffer);

  998.             CARLA_SAFE_ASSERT_RETURN(engineEvents != nullptr,);

  999. 

  1000.             carla_zeroStruct<EngineEvent>(engineEvents, kMaxEngineEventInternalCount);

  1001.             fillEngineEventsFromJuceMidiBuffer(engineEvents, midi);

  1002.         }

  1003. 

  1004.         midi.clear();

  1005. 

  1006.         // TODO - CV support

  1007. 

  1008.         const uint32_t bufferSize(static_cast<uint32_t>(audio.getNumSamples()));

  1009. 

  1010.         if (const int numChan = audio.getNumChannels())

  1011.         {

  1012.             if (fPlugin->getAudioInCount() == 0)

  1013.                 audio.clear();

  1014. 

  1015.             float* audioBuffers[numChan];

  1016. 

  1017.             for (int i=0; i<numChan; ++i)

  1018.                 audioBuffers[i] = audio.getWritePointer(i);

  1019. 

  1020.             float inPeaks[2] = { 0.0f };

  1021.             float outPeaks[2] = { 0.0f };

  1022. 

  1023.             for (int i=0; i<numChan; ++i)

  1024.             {

  1025.                 for (uint32_t j=0; j < bufferSize; ++j)

  1026.                 {

  1027.                     const float absV(std::abs(audioBuffers[i][j]));

  1028. 

  1029.                     if (absV > inPeaks[i])

  1030.                         inPeaks[i] = absV;

  1031.                 }

  1032.             }

  1033. 

  1034.             fPlugin->process(const_cast<const float**>(audioBuffers), audioBuffers, nullptr, nullptr, bufferSize);

  1035. 

  1036.             for (int i=0; i<numChan; ++i)

  1037.             {

  1038.                 for (uint32_t j=0; j < bufferSize; ++j)

  1039.                 {

  1040.                     const float absV(std::abs(audioBuffers[i][j]));

  1041. 

  1042.                     if (absV > outPeaks[i])

  1043.                         outPeaks[i] = absV;

  1044.                 }

  1045.             }

  1046. 

  1047.             engine->setPluginPeaks(fPlugin->getId(), inPeaks, outPeaks);

  1048.         }

  1049.         else

  1050.         {

  1051.             fPlugin->process(nullptr, nullptr, nullptr, nullptr, bufferSize);

  1052.         }

  1053. 

  1054.         midi.clear();

  1055. 

  1056.         if (CarlaEngineEventPort* const port = fPlugin->getDefaultEventOutPort())

  1057.         {

  1058.             /*const*/ EngineEvent* const engineEvents(port->fBuffer);

  1059.             CARLA_SAFE_ASSERT_RETURN(engineEvents != nullptr,);

  1060. 

  1061.             fillJuceMidiBufferFromEngineEvents(midi, engineEvents);

  1062.             carla_zeroStruct<EngineEvent>(engineEvents, kMaxEngineEventInternalCount);

  1063.         }

  1064. 

  1065.         fPlugin->unlock();

  1066.     }

  1067. 

  1068.     const String getInputChannelName(int i)  const override

  1069.     {

  1070.         CARLA_SAFE_ASSERT_RETURN(i >= 0, String());

  1071.         CarlaEngineClient* const client(fPlugin->getEngineClient());

  1072.         return client->getAudioInputPortName(static_cast<uint>(i));

  1073.     }

  1074. 

  1075.     const String getOutputChannelName(int i) const override

  1076.     {

  1077.         CARLA_SAFE_ASSERT_RETURN(i >= 0, String());

  1078.         CarlaEngineClient* const client(fPlugin->getEngineClient());

  1079.         return client->getAudioOutputPortName(static_cast<uint>(i));

  1080.     }

  1081. 

  1082.     void prepareToPlay(double, int) override {}

  1083.     void releaseResources() override {}

  1084. 

  1085.     const String getParameterName(int)             override { return String(); }

  1086.           String getParameterName(int, int)        override { return String(); }

  1087.     const String getParameterText(int)             override { return String(); }

  1088.           String getParameterText(int, int)        override { return String(); }

  1089.     const String getProgramName(int)               override { return String(); }

  1090. 

  1091.     double getTailLengthSeconds()        const override { return 0.0;  }

  1092.     float  getParameter(int)                   override { return 0.0f; }

  1093. 

  1094.     bool isInputChannelStereoPair(int)   const override { return false; }

  1095.     bool isOutputChannelStereoPair(int)  const override { return false; }

  1096.     bool silenceInProducesSilenceOut()   const override { return true;  }

  1097.     bool acceptsMidi()                   const override { return fPlugin->getDefaultEventInPort()  != nullptr; }

  1098.     bool producesMidi()                  const override { return fPlugin->getDefaultEventOutPort() != nullptr; }

  1099. 

  1100.     void setParameter(int, float)              override {}

  1101.     void setCurrentProgram(int)                override {}

  1102.     void changeProgramName(int, const String&) override {}

  1103.     void getStateInformation(MemoryBlock&)     override {}

  1104.     void setStateInformation(const void*, int) override {}

  1105. 

  1106.     int getNumParameters()                     override { return 0; }

  1107.     int getNumPrograms()                       override { return 0; }

  1108.     int getCurrentProgram()                    override { return 0; }

  1109. 

  1110. #ifndef JUCE_AUDIO_PROCESSOR_NO_GUI

  1111.     bool hasEditor()                     const override { return false; }

  1112.     AudioProcessorEditor* createEditor()       override { return nullptr; }

  1113. #endif

  1114. 

  1115.     // -------------------------------------------------------------------

  1116. 

  1117. private:

  1118.     CarlaPlugin* const fPlugin;

  1119. 

  1120.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaPluginInstance)

  1121. };

  1122. 

  1123. // -----------------------------------------------------------------------

  1124. // Patchbay Graph

  1125. 

  1126. PatchbayGraph::PatchbayGraph(const int bufferSize, const double sampleRate, const uint32_t ins, const uint32_t outs)

  1127.     : connections(),

  1128.       graph(),

  1129.       audioBuffer(),

  1130.       midiBuffer(),

  1131.       inputs(carla_fixValue(0U, MAX_PATCHBAY_PLUGINS-2, ins)),

  1132.       outputs(carla_fixValue(0U, MAX_PATCHBAY_PLUGINS-2, outs)),

  1133.       ignorePathbay(false),

  1134.       retCon()

  1135. {

  1136.     graph.setPlayConfigDetails(static_cast<int>(inputs), static_cast<int>(outputs), sampleRate, bufferSize);

  1137.     graph.prepareToPlay(sampleRate, bufferSize);

  1138. 

  1139.     audioBuffer.setSize(static_cast<int>(jmax(inputs, outputs)), bufferSize);

  1140. 

  1141.     midiBuffer.ensureSize(kMaxEngineEventInternalCount*2);

  1142.     midiBuffer.clear();

  1143. 

  1144.     {

  1145.         AudioProcessorGraph::AudioGraphIOProcessor* const proc(new AudioProcessorGraph::AudioGraphIOProcessor(AudioProcessorGraph::AudioGraphIOProcessor::audioInputNode));

  1146.         AudioProcessorGraph::Node* const node(graph.addNode(proc));

  1147.         node->properties.set("isPlugin", false);

  1148.         node->properties.set("isOutput", false);

  1149.         node->properties.set("isAudio", true);

  1150.         node->properties.set("isMIDI", false);

  1151.     }

  1152. 

  1153.     {

  1154.         AudioProcessorGraph::AudioGraphIOProcessor* const proc(new AudioProcessorGraph::AudioGraphIOProcessor(AudioProcessorGraph::AudioGraphIOProcessor::audioOutputNode));

  1155.         AudioProcessorGraph::Node* const node(graph.addNode(proc));

  1156.         node->properties.set("isPlugin", false);

  1157.         node->properties.set("isOutput", false);

  1158.         node->properties.set("isAudio", true);

  1159.         node->properties.set("isMIDI", false);

  1160.     }

  1161. 

  1162.     {

  1163.         AudioProcessorGraph::AudioGraphIOProcessor* const proc(new AudioProcessorGraph::AudioGraphIOProcessor(AudioProcessorGraph::AudioGraphIOProcessor::midiInputNode));

  1164.         AudioProcessorGraph::Node* const node(graph.addNode(proc));

  1165.         node->properties.set("isPlugin", false);

  1166.         node->properties.set("isOutput", false);

  1167.         node->properties.set("isAudio", false);

  1168.         node->properties.set("isMIDI", true);

  1169.     }

  1170. 

  1171.     {

  1172.         AudioProcessorGraph::AudioGraphIOProcessor* const proc(new AudioProcessorGraph::AudioGraphIOProcessor(AudioProcessorGraph::AudioGraphIOProcessor::midiOutputNode));

  1173.         AudioProcessorGraph::Node* const node(graph.addNode(proc));

  1174.         node->properties.set("isPlugin", false);

  1175.         node->properties.set("isOutput", true);

  1176.         node->properties.set("isAudio", false);

  1177.         node->properties.set("isMIDI", true);

  1178.     }

  1179. }

  1180. 

  1181. PatchbayGraph::~PatchbayGraph()

  1182. {

  1183.     clearConnections();

  1184.     graph.releaseResources();

  1185.     graph.clear();

  1186.     audioBuffer.clear();

  1187. }

  1188. 

  1189. void PatchbayGraph::setBufferSize(const int bufferSize)

  1190. {

  1191.     graph.releaseResources();

  1192.     graph.prepareToPlay(graph.getSampleRate(), bufferSize);

  1193.     audioBuffer.setSize(audioBuffer.getNumChannels(), bufferSize);

  1194. }

  1195. 

  1196. void PatchbayGraph::setSampleRate(const double sampleRate)

  1197. {

  1198.     graph.releaseResources();

  1199.     graph.prepareToPlay(sampleRate, graph.getBlockSize());

  1200. }

  1201. 

  1202. void PatchbayGraph::setOffline(const bool offline)

  1203. {

  1204.     graph.setNonRealtime(offline);

  1205. }

  1206. 

  1207. void PatchbayGraph::addPlugin(CarlaPlugin* const plugin)

  1208. {

  1209.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1210.     carla_debug("PatchbayGraph::addPlugin(%p)", plugin);

  1211. 

  1212.     CarlaPluginInstance* const instance(new CarlaPluginInstance(plugin));

  1213.     AudioProcessorGraph::Node* const node(graph.addNode(instance));

  1214.     CARLA_SAFE_ASSERT_RETURN(node != nullptr,);

  1215. 

  1216.     plugin->setPatchbayNodeId(node->nodeId);

  1217. 

  1218.     node->properties.set("isPlugin", true);

  1219.     node->properties.set("pluginId", static_cast<int>(plugin->getId()));

  1220. 

  1221.     if (! ignorePathbay)

  1222.         addNodeToPatchbay(plugin->getEngine(), node->nodeId, static_cast<int>(plugin->getId()), instance);

  1223. }

  1224. 

  1225. void PatchbayGraph::replacePlugin(CarlaPlugin* const oldPlugin, CarlaPlugin* const newPlugin)

  1226. {

  1227.     CARLA_SAFE_ASSERT_RETURN(oldPlugin != nullptr,);

  1228.     CARLA_SAFE_ASSERT_RETURN(newPlugin != nullptr,);

  1229.     CARLA_SAFE_ASSERT_RETURN(oldPlugin != newPlugin,);

  1230.     CARLA_SAFE_ASSERT_RETURN(oldPlugin->getId() == newPlugin->getId(),);

  1231. 

  1232.     // FIXME

  1233. 

  1234.     graph.removeNode(oldPlugin->getPatchbayNodeId());

  1235. 

  1236.     CarlaPluginInstance* const instance(new CarlaPluginInstance(newPlugin));

  1237.     AudioProcessorGraph::Node* const node(graph.addNode(instance));

  1238.     CARLA_SAFE_ASSERT_RETURN(node != nullptr,);

  1239. 

  1240.     newPlugin->setPatchbayNodeId(node->nodeId);

  1241. 

  1242.     node->properties.set("isPlugin", true);

  1243.     node->properties.set("pluginId", static_cast<int>(newPlugin->getId()));

  1244. 

  1245.     if (! ignorePathbay)

  1246.         addNodeToPatchbay(newPlugin->getEngine(), node->nodeId, static_cast<int>(newPlugin->getId()), instance);

  1247. }

  1248. 

  1249. void PatchbayGraph::removePlugin(CarlaPlugin* const plugin)

  1250. {

  1251.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1252.     carla_debug("PatchbayGraph::removePlugin(%p)", plugin);

  1253. 

  1254.     CarlaEngine* const engine(plugin->getEngine());

  1255.     CARLA_SAFE_ASSERT_RETURN(engine != nullptr,);

  1256. 

  1257.     AudioProcessorGraph::Node* const node(graph.getNodeForId(plugin->getPatchbayNodeId()));

  1258.     CARLA_SAFE_ASSERT_RETURN(node != nullptr,);

  1259. 

  1260.     if (! ignorePathbay)

  1261.         removeNodeFromPatchbay(engine, plugin->getPatchbayNodeId(), node->getProcessor());

  1262. 

  1263.     // Fix plugin Ids properties

  1264.     for (uint i=plugin->getId(), count=engine->getCurrentPluginCount(); i<count; ++i)

  1265.     {

  1266.         CarlaPlugin* const plugin2(engine->getPlugin(i));

  1267.         CARLA_SAFE_ASSERT_BREAK(plugin2 != nullptr);

  1268. 

  1269.         if (AudioProcessorGraph::Node* const node2 = graph.getNodeForId(plugin2->getPatchbayNodeId()))

  1270.         {

  1271.             CARLA_SAFE_ASSERT_CONTINUE(node2->properties.getWithDefault("pluginId", -1) != juce::var(-1));

  1272.             node2->properties.set("pluginId", static_cast<int>(plugin2->getId()));

  1273.         }

  1274.     }

  1275. 

  1276.     CARLA_SAFE_ASSERT_RETURN(graph.removeNode(plugin->getPatchbayNodeId()),);

  1277. }

  1278. 

  1279. void PatchbayGraph::removeAllPlugins(CarlaEngine* const engine)

  1280. {

  1281.     CARLA_SAFE_ASSERT_RETURN(engine != nullptr,);

  1282.     carla_debug("PatchbayGraph::removeAllPlugins(%p)", engine);

  1283. 

  1284.     for (uint i=0, count=engine->getCurrentPluginCount(); i<count; ++i)

  1285.     {

  1286.         CarlaPlugin* const plugin(engine->getPlugin(i));

  1287.         CARLA_SAFE_ASSERT_CONTINUE(plugin != nullptr);

  1288. 

  1289.         AudioProcessorGraph::Node* const node(graph.getNodeForId(plugin->getPatchbayNodeId()));

  1290.         CARLA_SAFE_ASSERT_CONTINUE(node != nullptr);

  1291. 

  1292.         if (! ignorePathbay)

  1293.             removeNodeFromPatchbay(engine, node->nodeId, node->getProcessor());

  1294. 

  1295.         graph.removeNode(node->nodeId);

  1296.     }

  1297. }

  1298. 

  1299. bool PatchbayGraph::connect(CarlaEngine* const engine, const uint groupA, const uint portA, const uint groupB, const uint portB) noexcept

  1300. {

  1301.     CARLA_SAFE_ASSERT_RETURN(engine != nullptr, false);

  1302. 

  1303.     uint adjustedPortA = portA;

  1304.     uint adjustedPortB = portB;

  1305. 

  1306.     if (! adjustPatchbayPortIdForJuce(adjustedPortA))

  1307.         return false;

  1308.     if (! adjustPatchbayPortIdForJuce(adjustedPortB))

  1309.         return false;

  1310. 

  1311.     if (! graph.addConnection(groupA, static_cast<int>(adjustedPortA), groupB, static_cast<int>(adjustedPortB)))

  1312.     {

  1313.         engine->setLastError("Failed from juce");

  1314.         return false;

  1315.     }

  1316. 

  1317.     ConnectionToId connectionToId;

  1318.     connectionToId.setData(++connections.lastId, groupA, portA, groupB, portB);

  1319. 

  1320.     char strBuf[STR_MAX+1];

  1321.     strBuf[STR_MAX] = '\0';

  1322.     std::snprintf(strBuf, STR_MAX, "%u:%u:%u:%u", groupA, portA, groupB, portB);

  1323. 

  1324.     engine->callback(ENGINE_CALLBACK_PATCHBAY_CONNECTION_ADDED, connectionToId.id, 0, 0, 0.0f, strBuf);

  1325. 

  1326.     connections.list.append(connectionToId);

  1327.     return true;

  1328. }

  1329. 

  1330. bool PatchbayGraph::disconnect(CarlaEngine* const engine, const uint connectionId) noexcept

  1331. {

  1332.     CARLA_SAFE_ASSERT_RETURN(engine != nullptr, false);

  1333. 

  1334.     for (LinkedList<ConnectionToId>::Itenerator it=connections.list.begin(); it.valid(); it.next())

  1335.     {

  1336.         static const ConnectionToId fallback = { 0, 0, 0, 0, 0 };

  1337. 

  1338.         const ConnectionToId& connectionToId(it.getValue(fallback));

  1339.         CARLA_SAFE_ASSERT_CONTINUE(connectionToId.id != 0);

  1340. 

  1341.         if (connectionToId.id != connectionId)

  1342.             continue;

  1343. 

  1344.         uint adjustedPortA = connectionToId.portA;

  1345.         uint adjustedPortB = connectionToId.portB;

  1346. 

  1347.         if (! adjustPatchbayPortIdForJuce(adjustedPortA))

  1348.             return false;

  1349.         if (! adjustPatchbayPortIdForJuce(adjustedPortB))

  1350.             return false;

  1351. 

  1352.         if (! graph.removeConnection(connectionToId.groupA, static_cast<int>(adjustedPortA),

  1353.                                      connectionToId.groupB, static_cast<int>(adjustedPortB)))

  1354.             return false;

  1355. 

  1356.         engine->callback(ENGINE_CALLBACK_PATCHBAY_CONNECTION_REMOVED, connectionToId.id, 0, 0, 0.0f, nullptr);

  1357. 

  1358.         connections.list.remove(it);

  1359.         return true;

  1360.     }

  1361. 

  1362.     engine->setLastError("Failed to find connection");

  1363.     return false;

  1364. }

  1365. 

  1366. void PatchbayGraph::clearConnections()

  1367. {

  1368.     connections.clear();

  1369. 

  1370.     for (int i=0, count=graph.getNumConnections(); i<count; ++i)

  1371.         graph.removeConnection(0);

  1372. }

  1373. 

  1374. void PatchbayGraph::refreshConnections(CarlaEngine* const engine)

  1375. {

  1376.     CARLA_SAFE_ASSERT_RETURN(engine != nullptr,);

  1377. 

  1378.     connections.clear();

  1379. 

  1380.     for (int i=0, count=graph.getNumNodes(); i<count; ++i)

  1381.     {

  1382.         AudioProcessorGraph::Node* const node(graph.getNode(i));

  1383.         CARLA_SAFE_ASSERT_CONTINUE(node != nullptr);

  1384. 

  1385.         AudioProcessor* const proc(node->getProcessor());

  1386.         CARLA_SAFE_ASSERT_CONTINUE(proc != nullptr);

  1387. 

  1388.         int clientId = -1;

  1389. 

  1390.         if (node->properties.getWithDefault("isPlugin", false) == juce::var(true))

  1391.             clientId = node->properties.getWithDefault("pluginId", -1);

  1392. 

  1393.         if (! ignorePathbay)

  1394.             addNodeToPatchbay(engine, node->nodeId, clientId, proc);

  1395.     }

  1396. 

  1397.     char strBuf[STR_MAX+1];

  1398. 

  1399.     for (int i=0, count=graph.getNumConnections(); i<count; ++i)

  1400.     {

  1401.         const AudioProcessorGraph::Connection* const conn(graph.getConnection(i));

  1402.         CARLA_SAFE_ASSERT_CONTINUE(conn != nullptr);

  1403.         CARLA_SAFE_ASSERT_CONTINUE(conn->sourceChannelIndex >= 0);

  1404.         CARLA_SAFE_ASSERT_CONTINUE(conn->destChannelIndex >= 0);

  1405. 

  1406.         const uint groupA = conn->sourceNodeId;

  1407.         const uint groupB = conn->destNodeId;

  1408. 

  1409.         uint portA = static_cast<uint>(conn->sourceChannelIndex);

  1410.         uint portB = static_cast<uint>(conn->destChannelIndex);

  1411. 

  1412.         if (portA == kMidiChannelIndex)

  1413.             portA  = kMidiOutputPortOffset;

  1414.         else

  1415.             portA += kAudioOutputPortOffset;

  1416. 

  1417.         if (portB == kMidiChannelIndex)

  1418.             portB  = kMidiInputPortOffset;

  1419.         else

  1420.             portB += kAudioInputPortOffset;

  1421. 

  1422.         ConnectionToId connectionToId;

  1423.         connectionToId.setData(++connections.lastId, groupA, portA, groupB, portB);

  1424. 

  1425.         std::snprintf(strBuf, STR_MAX, "%i:%i:%i:%i", groupA, portA, groupB, portB);

  1426.         strBuf[STR_MAX] = '\0';

  1427. 

  1428.         engine->callback(ENGINE_CALLBACK_PATCHBAY_CONNECTION_ADDED, connectionToId.id, 0, 0, 0.0f, strBuf);

  1429. 

  1430.         connections.list.append(connectionToId);

  1431.     }

  1432. }

  1433. 

  1434. const char* const* PatchbayGraph::getConnections() const

  1435. {

  1436.     if (connections.list.count() == 0)

  1437.         return nullptr;

  1438. 

  1439.     CarlaStringList connList;

  1440. 

  1441.     for (LinkedList<ConnectionToId>::Itenerator it=connections.list.begin(); it.valid(); it.next())

  1442.     {

  1443.         static const ConnectionToId fallback = { 0, 0, 0, 0, 0 };

  1444. 

  1445.         const ConnectionToId& connectionToId(it.getValue(fallback));

  1446.         CARLA_SAFE_ASSERT_CONTINUE(connectionToId.id != 0);

  1447. 

  1448.         AudioProcessorGraph::Node* const nodeA(graph.getNodeForId(connectionToId.groupA));

  1449.         CARLA_SAFE_ASSERT_CONTINUE(nodeA != nullptr);

  1450. 

  1451.         AudioProcessorGraph::Node* const nodeB(graph.getNodeForId(connectionToId.groupB));

  1452.         CARLA_SAFE_ASSERT_CONTINUE(nodeB != nullptr);

  1453. 

  1454.         AudioProcessor* const procA(nodeA->getProcessor());

  1455.         CARLA_SAFE_ASSERT_CONTINUE(procA != nullptr);

  1456. 

  1457.         AudioProcessor* const procB(nodeB->getProcessor());

  1458.         CARLA_SAFE_ASSERT_CONTINUE(procB != nullptr);

  1459. 

  1460.         String fullPortNameA(getProcessorFullPortName(procA, connectionToId.portA));

  1461.         CARLA_SAFE_ASSERT_CONTINUE(fullPortNameA.isNotEmpty());

  1462. 

  1463.         String fullPortNameB(getProcessorFullPortName(procB, connectionToId.portB));

  1464.         CARLA_SAFE_ASSERT_CONTINUE(fullPortNameB.isNotEmpty());

  1465. 

  1466.         connList.append(fullPortNameA.toRawUTF8());

  1467.         connList.append(fullPortNameB.toRawUTF8());

  1468.     }

  1469. 

  1470.     if (connList.count() == 0)

  1471.         return nullptr;

  1472. 

  1473.     retCon = connList.toCharStringListPtr();

  1474. 

  1475.     return retCon;

  1476. }

  1477. 

  1478. bool PatchbayGraph::getGroupAndPortIdFromFullName(const char* const fullPortName, uint& groupId, uint& portId) const

  1479. {

  1480.     String groupName(String(fullPortName).upToFirstOccurrenceOf(":", false, false));

  1481.     String portName(String(fullPortName).fromFirstOccurrenceOf(":", false, false));

  1482. 

  1483.     for (int i=0, count=graph.getNumNodes(); i<count; ++i)

  1484.     {

  1485.         AudioProcessorGraph::Node* const node(graph.getNode(i));

  1486.         CARLA_SAFE_ASSERT_CONTINUE(node != nullptr);

  1487. 

  1488.         AudioProcessor* const proc(node->getProcessor());

  1489.         CARLA_SAFE_ASSERT_CONTINUE(proc != nullptr);

  1490. 

  1491.         if (proc->getName() != groupName)

  1492.             continue;

  1493. 

  1494.         groupId = node->nodeId;

  1495. 

  1496.         if (portName == "events-in")

  1497.         {

  1498.             portId = kMidiInputPortOffset;

  1499.             return true;

  1500.         }

  1501.         if (portName == "events-out")

  1502.         {

  1503.             portId = kMidiOutputPortOffset;

  1504.             return true;

  1505.         }

  1506.         else

  1507.         {

  1508.             for (int j=0, numInputs=proc->getNumInputChannels(); j<numInputs; ++j)

  1509.             {

  1510.                 if (proc->getInputChannelName(j) != portName)

  1511.                     continue;

  1512. 

  1513.                 portId = kAudioInputPortOffset+static_cast<uint>(j);

  1514.                 return true;

  1515.             }

  1516. 

  1517.             for (int j=0, numOutputs=proc->getNumOutputChannels(); j<numOutputs; ++j)

  1518.             {

  1519.                 if (proc->getOutputChannelName(j) != portName)

  1520.                     continue;

  1521. 

  1522.                 portId = kAudioOutputPortOffset+static_cast<uint>(j);

  1523.                 return true;

  1524.             }

  1525.         }

  1526.     }

  1527. 

  1528.     return false;

  1529. }

  1530. 

  1531. void PatchbayGraph::process(CarlaEngine::ProtectedData* const data, const float* const* const inBuf, float* const* const outBuf, const int frames)

  1532. {

  1533.     CARLA_SAFE_ASSERT_RETURN(data != nullptr,);

  1534.     CARLA_SAFE_ASSERT_RETURN(data->events.in != nullptr,);

  1535.     CARLA_SAFE_ASSERT_RETURN(data->events.out != nullptr,);

  1536.     CARLA_SAFE_ASSERT_RETURN(frames > 0,);

  1537. 

  1538.     // put events in juce buffer

  1539.     {

  1540.         midiBuffer.clear();

  1541.         fillJuceMidiBufferFromEngineEvents(midiBuffer, data->events.in);

  1542.     }

  1543. 

  1544.     // put carla audio in juce buffer

  1545.     {

  1546.         int i=0;

  1547. 

  1548.         for (; i < static_cast<int>(inputs); ++i)

  1549.             FloatVectorOperations::copy(audioBuffer.getWritePointer(i), inBuf[i], frames);

  1550. 

  1551.         // clear remaining channels

  1552.         for (const int count=audioBuffer.getNumChannels(); i<count; ++i)

  1553.             audioBuffer.clear(i, 0, frames);

  1554.     }

  1555. 

  1556.     graph.processBlock(audioBuffer, midiBuffer);

  1557. 

  1558.     // put juce audio in carla buffer

  1559.     {

  1560.         for (int i=0; i < static_cast<int>(outputs); ++i)

  1561.             FloatVectorOperations::copy(outBuf[i], audioBuffer.getReadPointer(i), frames);

  1562.     }

  1563. 

  1564.     // put juce events in carla buffer

  1565.     {

  1566.         carla_zeroStruct<EngineEvent>(data->events.out, kMaxEngineEventInternalCount);

  1567.         fillEngineEventsFromJuceMidiBuffer(data->events.out, midiBuffer);

  1568.         midiBuffer.clear();

  1569.     }

  1570. }

  1571. 

  1572. // -----------------------------------------------------------------------

  1573. // InternalGraph

  1574. 

  1575. EngineInternalGraph::EngineInternalGraph() noexcept

  1576.     : fIsRack(true),

  1577.       fIsReady(false)

  1578. {

  1579.     fRack = nullptr;

  1580. }

  1581. 

  1582. EngineInternalGraph::~EngineInternalGraph() noexcept

  1583. {

  1584.     CARLA_SAFE_ASSERT(! fIsReady);

  1585.     CARLA_SAFE_ASSERT(fRack == nullptr);

  1586. }

  1587. 

  1588. void EngineInternalGraph::create(const bool isRack, const double sampleRate, const uint32_t bufferSize, const uint32_t inputs, const uint32_t outputs)

  1589. {

  1590.     fIsRack = isRack;

  1591. 

  1592.     if (isRack)

  1593.     {

  1594.         CARLA_SAFE_ASSERT_RETURN(fRack == nullptr,);

  1595.         fRack = new RackGraph(bufferSize, inputs, outputs);

  1596.     }

  1597.     else

  1598.     {

  1599.         CARLA_SAFE_ASSERT_RETURN(fPatchbay == nullptr,);

  1600.         fPatchbay = new PatchbayGraph(static_cast<int>(bufferSize), sampleRate, inputs, outputs);

  1601.     }

  1602. 

  1603.     fIsReady = true;

  1604. }

  1605. 

  1606. void EngineInternalGraph::destroy() noexcept

  1607. {

  1608.     if (! fIsReady)

  1609.     {

  1610.         CARLA_SAFE_ASSERT(fRack == nullptr);

  1611.         return;

  1612.     }

  1613. 

  1614.     fIsReady = false;

  1615. 

  1616.     if (fIsRack)

  1617.     {

  1618.         CARLA_SAFE_ASSERT_RETURN(fRack != nullptr,);

  1619.         delete fRack;

  1620.         fRack = nullptr;

  1621.     }

  1622.     else

  1623.     {

  1624.         CARLA_SAFE_ASSERT_RETURN(fPatchbay != nullptr,);

  1625.         delete fPatchbay;

  1626.         fPatchbay = nullptr;

  1627.     }

  1628. }

  1629. 

  1630. void EngineInternalGraph::setBufferSize(const uint32_t bufferSize)

  1631. {

  1632.     ScopedValueSetter<bool> svs(fIsReady, false, true);

  1633. 

  1634.     if (fIsRack)

  1635.     {

  1636.         CARLA_SAFE_ASSERT_RETURN(fRack != nullptr,);

  1637.         fRack->setBufferSize(bufferSize);

  1638.     }

  1639.     else

  1640.     {

  1641.         CARLA_SAFE_ASSERT_RETURN(fPatchbay != nullptr,);

  1642.         fPatchbay->setBufferSize(static_cast<int>(bufferSize));

  1643.     }

  1644. }

  1645. 

  1646. void EngineInternalGraph::setSampleRate(const double sampleRate)

  1647. {

  1648.     ScopedValueSetter<bool> svs(fIsReady, false, true);

  1649. 

  1650.     if (fIsRack)

  1651.     {

  1652.         CARLA_SAFE_ASSERT_RETURN(fRack != nullptr,);

  1653.     }

  1654.     else

  1655.     {

  1656.         CARLA_SAFE_ASSERT_RETURN(fPatchbay != nullptr,);

  1657.         fPatchbay->setSampleRate(sampleRate);

  1658.     }

  1659. }

  1660. 

  1661. void EngineInternalGraph::setOffline(const bool offline)

  1662. {

  1663.     ScopedValueSetter<bool> svs(fIsReady, false, true);

  1664. 

  1665.     if (fIsRack)

  1666.     {

  1667.         CARLA_SAFE_ASSERT_RETURN(fRack != nullptr,);

  1668.         fRack->setOffline(offline);

  1669.     }

  1670.     else

  1671.     {

  1672.         CARLA_SAFE_ASSERT_RETURN(fPatchbay != nullptr,);

  1673.         fPatchbay->setOffline(offline);

  1674.     }

  1675. }

  1676. 

  1677. bool EngineInternalGraph::isReady() const noexcept

  1678. {

  1679.     return fIsReady;

  1680. }

  1681. 

  1682. RackGraph* EngineInternalGraph::getRackGraph() const noexcept

  1683. {

  1684.     CARLA_SAFE_ASSERT_RETURN(fIsRack, nullptr);

  1685. 

  1686.     return fRack;

  1687. }

  1688. 

  1689. PatchbayGraph* EngineInternalGraph::getPatchbayGraph() const noexcept

  1690. {

  1691.     CARLA_SAFE_ASSERT_RETURN(! fIsRack, nullptr);

  1692. 

  1693.     return fPatchbay;

  1694. }

  1695. 

  1696. void EngineInternalGraph::process(CarlaEngine::ProtectedData* const data, const float* const* const inBuf, float* const* const outBuf, const uint32_t frames)

  1697. {

  1698.     if (fIsRack)

  1699.     {

  1700.         CARLA_SAFE_ASSERT_RETURN(fRack != nullptr,);

  1701.         fRack->processHelper(data, inBuf, outBuf, frames);

  1702.     }

  1703.     else

  1704.     {

  1705.         CARLA_SAFE_ASSERT_RETURN(fPatchbay != nullptr,);

  1706.         fPatchbay->process(data, inBuf, outBuf, static_cast<int>(frames));

  1707.     }

  1708. }

  1709. 

  1710. void EngineInternalGraph::processRack(CarlaEngine::ProtectedData* const data, const float* inBuf[2], float* outBuf[2], const uint32_t frames)

  1711. {

  1712.     CARLA_SAFE_ASSERT_RETURN(fIsRack,);

  1713.     CARLA_SAFE_ASSERT_RETURN(fRack != nullptr,);

  1714. 

  1715.     fRack->process(data, inBuf, outBuf, frames);

  1716. }

  1717. 

  1718. // -----------------------------------------------------------------------

  1719. // used for internal patchbay mode

  1720. 

  1721. void EngineInternalGraph::addPlugin(CarlaPlugin* const plugin)

  1722. {

  1723.     CARLA_SAFE_ASSERT_RETURN(fPatchbay != nullptr,);

  1724.     fPatchbay->addPlugin(plugin);

  1725. }

  1726. 

  1727. void EngineInternalGraph::replacePlugin(CarlaPlugin* const oldPlugin, CarlaPlugin* const newPlugin)

  1728. {

  1729.     CARLA_SAFE_ASSERT_RETURN(fPatchbay != nullptr,);

  1730.     fPatchbay->replacePlugin(oldPlugin, newPlugin);

  1731. }

  1732. 

  1733. void EngineInternalGraph::removePlugin(CarlaPlugin* const plugin)

  1734. {

  1735.     CARLA_SAFE_ASSERT_RETURN(fPatchbay != nullptr,);

  1736.     fPatchbay->removePlugin(plugin);

  1737. }

  1738. 

  1739. void EngineInternalGraph::removeAllPlugins(CarlaEngine* const engine)

  1740. {

  1741.     CARLA_SAFE_ASSERT_RETURN(fPatchbay != nullptr,);

  1742.     fPatchbay->removeAllPlugins(engine);

  1743. }

  1744. 

  1745. void EngineInternalGraph::setIgnorePatchbay(const bool ignore) noexcept

  1746. {

  1747.     CARLA_SAFE_ASSERT_RETURN(fPatchbay != nullptr,);

  1748.     fPatchbay->ignorePathbay = ignore;

  1749. }

  1750. 

  1751. // -----------------------------------------------------------------------

  1752. // CarlaEngine Patchbay stuff

  1753. 

  1754. bool CarlaEngine::patchbayConnect(const uint groupA, const uint portA, const uint groupB, const uint portB)

  1755. {

  1756.     CARLA_SAFE_ASSERT_RETURN(pData->options.processMode == ENGINE_PROCESS_MODE_CONTINUOUS_RACK || pData->options.processMode == ENGINE_PROCESS_MODE_PATCHBAY, false);

  1757.     CARLA_SAFE_ASSERT_RETURN(pData->graph.isReady(), false);

  1758.     carla_debug("CarlaEngine::patchbayConnect(%u, %u, %u, %u)", groupA, portA, groupB, portB);

  1759. 

  1760.     if (pData->options.processMode == ENGINE_PROCESS_MODE_CONTINUOUS_RACK)

  1761.     {

  1762.         if (RackGraph* const graph = pData->graph.getRackGraph())

  1763.             return graph->connect(this, groupA, portA, groupB, portB);

  1764.     }

  1765.     else

  1766.     {

  1767.         if (PatchbayGraph* const graph = pData->graph.getPatchbayGraph())

  1768.             return graph->connect(this, groupA, portA, groupB, portB);

  1769.     }

  1770. 

  1771.     return false;

  1772. }

  1773. 

  1774. bool CarlaEngine::patchbayDisconnect(const uint connectionId)

  1775. {

  1776.     CARLA_SAFE_ASSERT_RETURN(pData->options.processMode == ENGINE_PROCESS_MODE_CONTINUOUS_RACK || pData->options.processMode == ENGINE_PROCESS_MODE_PATCHBAY, false);

  1777.     CARLA_SAFE_ASSERT_RETURN(pData->graph.isReady(), false);

  1778.     carla_debug("CarlaEngine::patchbayDisconnect(%u)", connectionId);

  1779. 

  1780.     if (pData->options.processMode == ENGINE_PROCESS_MODE_CONTINUOUS_RACK)

  1781.     {

  1782.         if (RackGraph* const graph = pData->graph.getRackGraph())

  1783.             return graph->disconnect(this, connectionId);

  1784.     }

  1785.     else

  1786.     {

  1787.         if (PatchbayGraph* const graph = pData->graph.getPatchbayGraph())

  1788.             return graph->disconnect(this, connectionId);

  1789.     }

  1790. 

  1791.     return false;

  1792. }

  1793. 

  1794. bool CarlaEngine::patchbayRefresh(const bool external)

  1795. {

  1796.     // subclasses should handle this

  1797.     CARLA_SAFE_ASSERT_RETURN(! external, false);

  1798. 

  1799.     if (pData->options.processMode == ENGINE_PROCESS_MODE_CONTINUOUS_RACK)

  1800.     {

  1801.         // This is implemented in engine subclasses for MIDI support

  1802.         setLastError("Unsupported operation");

  1803.         return false;

  1804.     }

  1805. 

  1806.     CARLA_SAFE_ASSERT_RETURN(pData->options.processMode == ENGINE_PROCESS_MODE_PATCHBAY, false);

  1807. 

  1808.     PatchbayGraph* const graph = pData->graph.getPatchbayGraph();

  1809.     CARLA_SAFE_ASSERT_RETURN(graph != nullptr, false);

  1810. 

  1811.     graph->refreshConnections(this);

  1812. 

  1813.     return true;

  1814. }

  1815. 

  1816. // -----------------------------------------------------------------------

  1817. 

  1818. const char* const* CarlaEngine::getPatchbayConnections() const

  1819. {

  1820.     CARLA_SAFE_ASSERT_RETURN(pData->graph.isReady(), nullptr);

  1821.     carla_debug("CarlaEngine::getPatchbayConnections()");

  1822. 

  1823.     if (pData->options.processMode == ENGINE_PROCESS_MODE_CONTINUOUS_RACK)

  1824.     {

  1825.         if (RackGraph* const graph = pData->graph.getRackGraph())

  1826.             return graph->getConnections();

  1827.     }

  1828.     else

  1829.     {

  1830.         if (PatchbayGraph* const graph = pData->graph.getPatchbayGraph())

  1831.             return graph->getConnections();

  1832.     }

  1833. 

  1834.     return nullptr;

  1835. }

  1836. 

  1837. void CarlaEngine::restorePatchbayConnection(const char* const connSource, const char* const connTarget)

  1838. {

  1839.     CARLA_SAFE_ASSERT_RETURN(pData->graph.isReady(),);

  1840.     CARLA_SAFE_ASSERT_RETURN(connSource != nullptr && connSource[0] != '\0',);

  1841.     CARLA_SAFE_ASSERT_RETURN(connTarget != nullptr && connTarget[0] != '\0',);

  1842.     carla_debug("CarlaEngine::restorePatchbayConnection(\"%s\", \"%s\")", connSource, connTarget);

  1843. 

  1844.     uint groupA, portA;

  1845.     uint groupB, portB;

  1846. 

  1847.     if (pData->options.processMode == ENGINE_PROCESS_MODE_CONTINUOUS_RACK)

  1848.     {

  1849.         RackGraph* const graph = pData->graph.getRackGraph();

  1850.         CARLA_SAFE_ASSERT_RETURN(graph != nullptr,);

  1851. 

  1852.         if (! graph->getGroupAndPortIdFromFullName(connSource, groupA, portA))

  1853.             return;

  1854.         if (! graph->getGroupAndPortIdFromFullName(connTarget, groupB, portB))

  1855.             return;

  1856.     }

  1857.     else

  1858.     {

  1859.         PatchbayGraph* const graph = pData->graph.getPatchbayGraph();

  1860.         CARLA_SAFE_ASSERT_RETURN(graph != nullptr,);

  1861. 

  1862.         if (! graph->getGroupAndPortIdFromFullName(connSource, groupA, portA))

  1863.             return;

  1864.         if (! graph->getGroupAndPortIdFromFullName(connTarget, groupB, portB))

  1865.             return;

  1866.     }

  1867. 

  1868.     patchbayConnect(groupA, portA, groupB, portB);

  1869. }

  1870. 

  1871. // -----------------------------------------------------------------------

  1872. 

  1873. CARLA_BACKEND_END_NAMESPACE

  1874. 

  1875. // -----------------------------------------------------------------------