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.
2728 Commits
16 Branches
14GB
Tree: 27cd151daa
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '27cd151daa'
${ noResults }
Carla/source/backend/engine/CarlaEngineGraph.cpp

1926 lines
63KB
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);

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

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

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

  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_maxLimited<float>(std::abs(range.getStart()), std::abs(range.getEnd()), 1.0f);

  650. 

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

  652.                 pluginData.insPeak[1] = carla_maxLimited<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_maxLimited<float>(std::abs(range.getStart()), std::abs(range.getEnd()), 1.0f);

  664. 

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

  666.                 pluginData.outsPeak[1] = carla_maxLimited<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-1], 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-1], 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->getAudioPortName(true, 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->getAudioPortName(false, 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.     CarlaEngine* const engine(oldPlugin->getEngine());

  1233.     CARLA_SAFE_ASSERT_RETURN(engine != nullptr,);

  1234. 

  1235.     AudioProcessorGraph::Node* const oldNode(graph.getNodeForId(oldPlugin->getPatchbayNodeId()));

  1236.     CARLA_SAFE_ASSERT_RETURN(oldNode != nullptr,);

  1237. 

  1238.     if (! ignorePathbay)

  1239.     {

  1240.         disconnectGroup(engine, oldNode->nodeId);

  1241.         removeNodeFromPatchbay(engine, oldNode->nodeId, oldNode->getProcessor());

  1242.     }

  1243. 

  1244.     graph.removeNode(oldNode->nodeId);

  1245. 

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

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

  1248.     CARLA_SAFE_ASSERT_RETURN(node != nullptr,);

  1249. 

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

  1251. 

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

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

  1254. 

  1255.     if (! ignorePathbay)

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

  1257. }

  1258. 

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

  1260. {

  1261.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

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

  1263. 

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

  1265.     CARLA_SAFE_ASSERT_RETURN(engine != nullptr,);

  1266. 

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

  1268.     CARLA_SAFE_ASSERT_RETURN(node != nullptr,);

  1269. 

  1270.     if (! ignorePathbay)

  1271.     {

  1272.         disconnectGroup(engine, node->nodeId);

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

  1274.     }

  1275. 

  1276.     // Fix plugin Ids properties

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

  1278.     {

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

  1280.         CARLA_SAFE_ASSERT_BREAK(plugin2 != nullptr);

  1281. 

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

  1283.         {

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

  1285.             node2->properties.set("pluginId", static_cast<int>(i-1));

  1286.         }

  1287.     }

  1288. 

  1289.     CARLA_SAFE_ASSERT_RETURN(graph.removeNode(node->nodeId),);

  1290. }

  1291. 

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

  1293. {

  1294.     CARLA_SAFE_ASSERT_RETURN(engine != nullptr,);

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

  1296. 

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

  1298.     {

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

  1300.         CARLA_SAFE_ASSERT_CONTINUE(plugin != nullptr);

  1301. 

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

  1303.         CARLA_SAFE_ASSERT_CONTINUE(node != nullptr);

  1304. 

  1305.         if (! ignorePathbay)

  1306.         {

  1307.             disconnectGroup(engine, node->nodeId);

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

  1309.         }

  1310. 

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

  1312.     }

  1313. }

  1314. 

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

  1316. {

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

  1318. 

  1319.     uint adjustedPortA = portA;

  1320.     uint adjustedPortB = portB;

  1321. 

  1322.     if (! adjustPatchbayPortIdForJuce(adjustedPortA))

  1323.         return false;

  1324.     if (! adjustPatchbayPortIdForJuce(adjustedPortB))

  1325.         return false;

  1326. 

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

  1328.     {

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

  1330.         return false;

  1331.     }

  1332. 

  1333.     ConnectionToId connectionToId;

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

  1335. 

  1336.     char strBuf[STR_MAX+1];

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

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

  1339. 

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

  1341. 

  1342.     connections.list.append(connectionToId);

  1343.     return true;

  1344. }

  1345. 

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

  1347. {

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

  1349. 

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

  1351.     {

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

  1353. 

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

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

  1356. 

  1357.         if (connectionToId.id != connectionId)

  1358.             continue;

  1359. 

  1360.         uint adjustedPortA = connectionToId.portA;

  1361.         uint adjustedPortB = connectionToId.portB;

  1362. 

  1363.         if (! adjustPatchbayPortIdForJuce(adjustedPortA))

  1364.             return false;

  1365.         if (! adjustPatchbayPortIdForJuce(adjustedPortB))

  1366.             return false;

  1367. 

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

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

  1370.             return false;

  1371. 

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

  1373. 

  1374.         connections.list.remove(it);

  1375.         return true;

  1376.     }

  1377. 

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

  1379.     return false;

  1380. }

  1381. 

  1382. void PatchbayGraph::disconnectGroup(CarlaEngine* const engine, const uint groupId) noexcept

  1383. {

  1384.     CARLA_SAFE_ASSERT_RETURN(engine != nullptr,);

  1385. 

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

  1387.     {

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

  1389. 

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

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

  1392. 

  1393.         if (connectionToId.groupA != groupId && connectionToId.groupB != groupId)

  1394.             continue;

  1395. 

  1396.         /*

  1397.         uint adjustedPortA = connectionToId.portA;

  1398.         uint adjustedPortB = connectionToId.portB;

  1399. 

  1400.         if (! adjustPatchbayPortIdForJuce(adjustedPortA))

  1401.             return false;

  1402.         if (! adjustPatchbayPortIdForJuce(adjustedPortB))

  1403.             return false;

  1404. 

  1405.         graph.removeConnection(connectionToId.groupA, static_cast<int>(adjustedPortA),

  1406.                                connectionToId.groupB, static_cast<int>(adjustedPortB));

  1407.         */

  1408. 

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

  1410. 

  1411.         connections.list.remove(it);

  1412.     }

  1413. }

  1414. 

  1415. void PatchbayGraph::clearConnections()

  1416. {

  1417.     connections.clear();

  1418. 

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

  1420.         graph.removeConnection(0);

  1421. }

  1422. 

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

  1424. {

  1425.     CARLA_SAFE_ASSERT_RETURN(engine != nullptr,);

  1426. 

  1427.     connections.clear();

  1428.     graph.removeIllegalConnections();

  1429. 

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

  1431.     {

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

  1433.         CARLA_SAFE_ASSERT_CONTINUE(node != nullptr);

  1434. 

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

  1436.         CARLA_SAFE_ASSERT_CONTINUE(proc != nullptr);

  1437. 

  1438.         int clientId = -1;

  1439. 

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

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

  1442. 

  1443.         if (! ignorePathbay)

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

  1445.     }

  1446. 

  1447.     char strBuf[STR_MAX+1];

  1448. 

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

  1450.     {

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

  1452.         CARLA_SAFE_ASSERT_CONTINUE(conn != nullptr);

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

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

  1455. 

  1456.         const uint groupA = conn->sourceNodeId;

  1457.         const uint groupB = conn->destNodeId;

  1458. 

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

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

  1461. 

  1462.         if (portA == kMidiChannelIndex)

  1463.             portA  = kMidiOutputPortOffset;

  1464.         else

  1465.             portA += kAudioOutputPortOffset;

  1466. 

  1467.         if (portB == kMidiChannelIndex)

  1468.             portB  = kMidiInputPortOffset;

  1469.         else

  1470.             portB += kAudioInputPortOffset;

  1471. 

  1472.         ConnectionToId connectionToId;

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

  1474. 

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

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

  1477. 

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

  1479. 

  1480.         connections.list.append(connectionToId);

  1481.     }

  1482. }

  1483. 

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

  1485. {

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

  1487.         return nullptr;

  1488. 

  1489.     CarlaStringList connList;

  1490. 

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

  1492.     {

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

  1494. 

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

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

  1497. 

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

  1499.         CARLA_SAFE_ASSERT_CONTINUE(nodeA != nullptr);

  1500. 

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

  1502.         CARLA_SAFE_ASSERT_CONTINUE(nodeB != nullptr);

  1503. 

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

  1505.         CARLA_SAFE_ASSERT_CONTINUE(procA != nullptr);

  1506. 

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

  1508.         CARLA_SAFE_ASSERT_CONTINUE(procB != nullptr);

  1509. 

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

  1511.         CARLA_SAFE_ASSERT_CONTINUE(fullPortNameA.isNotEmpty());

  1512. 

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

  1514.         CARLA_SAFE_ASSERT_CONTINUE(fullPortNameB.isNotEmpty());

  1515. 

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

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

  1518.     }

  1519. 

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

  1521.         return nullptr;

  1522. 

  1523.     retCon = connList.toCharStringListPtr();

  1524. 

  1525.     return retCon;

  1526. }

  1527. 

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

  1529. {

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

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

  1532. 

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

  1534.     {

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

  1536.         CARLA_SAFE_ASSERT_CONTINUE(node != nullptr);

  1537. 

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

  1539.         CARLA_SAFE_ASSERT_CONTINUE(proc != nullptr);

  1540. 

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

  1542.             continue;

  1543. 

  1544.         groupId = node->nodeId;

  1545. 

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

  1547.         {

  1548.             portId = kMidiInputPortOffset;

  1549.             return true;

  1550.         }

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

  1552.         {

  1553.             portId = kMidiOutputPortOffset;

  1554.             return true;

  1555.         }

  1556.         else

  1557.         {

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

  1559.             {

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

  1561.                     continue;

  1562. 

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

  1564.                 return true;

  1565.             }

  1566. 

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

  1568.             {

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

  1570.                     continue;

  1571. 

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

  1573.                 return true;

  1574.             }

  1575.         }

  1576.     }

  1577. 

  1578.     return false;

  1579. }

  1580. 

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

  1582. {

  1583.     CARLA_SAFE_ASSERT_RETURN(data != nullptr,);

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

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

  1586.     CARLA_SAFE_ASSERT_RETURN(frames > 0,);

  1587. 

  1588.     // put events in juce buffer

  1589.     {

  1590.         midiBuffer.clear();

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

  1592.     }

  1593. 

  1594.     // put carla audio in juce buffer

  1595.     {

  1596.         int i=0;

  1597. 

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

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

  1600. 

  1601.         // clear remaining channels

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

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

  1604.     }

  1605. 

  1606.     graph.processBlock(audioBuffer, midiBuffer);

  1607. 

  1608.     // put juce audio in carla buffer

  1609.     {

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

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

  1612.     }

  1613. 

  1614.     // put juce events in carla buffer

  1615.     {

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

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

  1618.         midiBuffer.clear();

  1619.     }

  1620. }

  1621. 

  1622. // -----------------------------------------------------------------------

  1623. // InternalGraph

  1624. 

  1625. EngineInternalGraph::EngineInternalGraph() noexcept

  1626.     : fIsRack(true),

  1627.       fIsReady(false)

  1628. {

  1629.     fRack = nullptr;

  1630. }

  1631. 

  1632. EngineInternalGraph::~EngineInternalGraph() noexcept

  1633. {

  1634.     CARLA_SAFE_ASSERT(! fIsReady);

  1635.     CARLA_SAFE_ASSERT(fRack == nullptr);

  1636. }

  1637. 

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

  1639. {

  1640.     fIsRack = isRack;

  1641. 

  1642.     if (isRack)

  1643.     {

  1644.         CARLA_SAFE_ASSERT_RETURN(fRack == nullptr,);

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

  1646.     }

  1647.     else

  1648.     {

  1649.         CARLA_SAFE_ASSERT_RETURN(fPatchbay == nullptr,);

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

  1651.     }

  1652. 

  1653.     fIsReady = true;

  1654. }

  1655. 

  1656. void EngineInternalGraph::destroy() noexcept

  1657. {

  1658.     if (! fIsReady)

  1659.     {

  1660.         CARLA_SAFE_ASSERT(fRack == nullptr);

  1661.         return;

  1662.     }

  1663. 

  1664.     fIsReady = false;

  1665. 

  1666.     if (fIsRack)

  1667.     {

  1668.         CARLA_SAFE_ASSERT_RETURN(fRack != nullptr,);

  1669.         delete fRack;

  1670.         fRack = nullptr;

  1671.     }

  1672.     else

  1673.     {

  1674.         CARLA_SAFE_ASSERT_RETURN(fPatchbay != nullptr,);

  1675.         delete fPatchbay;

  1676.         fPatchbay = nullptr;

  1677.     }

  1678. }

  1679. 

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

  1681. {

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

  1683. 

  1684.     if (fIsRack)

  1685.     {

  1686.         CARLA_SAFE_ASSERT_RETURN(fRack != nullptr,);

  1687.         fRack->setBufferSize(bufferSize);

  1688.     }

  1689.     else

  1690.     {

  1691.         CARLA_SAFE_ASSERT_RETURN(fPatchbay != nullptr,);

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

  1693.     }

  1694. }

  1695. 

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

  1697. {

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

  1699. 

  1700.     if (fIsRack)

  1701.     {

  1702.         CARLA_SAFE_ASSERT_RETURN(fRack != nullptr,);

  1703.     }

  1704.     else

  1705.     {

  1706.         CARLA_SAFE_ASSERT_RETURN(fPatchbay != nullptr,);

  1707.         fPatchbay->setSampleRate(sampleRate);

  1708.     }

  1709. }

  1710. 

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

  1712. {

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

  1714. 

  1715.     if (fIsRack)

  1716.     {

  1717.         CARLA_SAFE_ASSERT_RETURN(fRack != nullptr,);

  1718.         fRack->setOffline(offline);

  1719.     }

  1720.     else

  1721.     {

  1722.         CARLA_SAFE_ASSERT_RETURN(fPatchbay != nullptr,);

  1723.         fPatchbay->setOffline(offline);

  1724.     }

  1725. }

  1726. 

  1727. bool EngineInternalGraph::isReady() const noexcept

  1728. {

  1729.     return fIsReady;

  1730. }

  1731. 

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

  1733. {

  1734.     CARLA_SAFE_ASSERT_RETURN(fIsRack, nullptr);

  1735. 

  1736.     return fRack;

  1737. }

  1738. 

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

  1740. {

  1741.     CARLA_SAFE_ASSERT_RETURN(! fIsRack, nullptr);

  1742. 

  1743.     return fPatchbay;

  1744. }

  1745. 

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

  1747. {

  1748.     if (fIsRack)

  1749.     {

  1750.         CARLA_SAFE_ASSERT_RETURN(fRack != nullptr,);

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

  1752.     }

  1753.     else

  1754.     {

  1755.         CARLA_SAFE_ASSERT_RETURN(fPatchbay != nullptr,);

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

  1757.     }

  1758. }

  1759. 

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

  1761. {

  1762.     CARLA_SAFE_ASSERT_RETURN(fIsRack,);

  1763.     CARLA_SAFE_ASSERT_RETURN(fRack != nullptr,);

  1764. 

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

  1766. }

  1767. 

  1768. // -----------------------------------------------------------------------

  1769. // used for internal patchbay mode

  1770. 

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

  1772. {

  1773.     CARLA_SAFE_ASSERT_RETURN(fPatchbay != nullptr,);

  1774.     fPatchbay->addPlugin(plugin);

  1775. }

  1776. 

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

  1778. {

  1779.     CARLA_SAFE_ASSERT_RETURN(fPatchbay != nullptr,);

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

  1781. }

  1782. 

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

  1784. {

  1785.     CARLA_SAFE_ASSERT_RETURN(fPatchbay != nullptr,);

  1786.     fPatchbay->removePlugin(plugin);

  1787. }

  1788. 

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

  1790. {

  1791.     CARLA_SAFE_ASSERT_RETURN(fPatchbay != nullptr,);

  1792.     fPatchbay->removeAllPlugins(engine);

  1793. }

  1794. 

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

  1796. {

  1797.     CARLA_SAFE_ASSERT_RETURN(fPatchbay != nullptr,);

  1798.     fPatchbay->ignorePathbay = ignore;

  1799. }

  1800. 

  1801. // -----------------------------------------------------------------------

  1802. // CarlaEngine Patchbay stuff

  1803. 

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

  1805. {

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

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

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

  1809. 

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

  1811.     {

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

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

  1814.     }

  1815.     else

  1816.     {

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

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

  1819.     }

  1820. 

  1821.     return false;

  1822. }

  1823. 

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

  1825. {

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

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

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

  1829. 

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

  1831.     {

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

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

  1834.     }

  1835.     else

  1836.     {

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

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

  1839.     }

  1840. 

  1841.     return false;

  1842. }

  1843. 

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

  1845. {

  1846.     // subclasses should handle this

  1847.     CARLA_SAFE_ASSERT_RETURN(! external, false);

  1848. 

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

  1850.     {

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

  1852.         setLastError("Unsupported operation");

  1853.         return false;

  1854.     }

  1855. 

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

  1857. 

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

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

  1860. 

  1861.     graph->refreshConnections(this);

  1862. 

  1863.     return true;

  1864. }

  1865. 

  1866. // -----------------------------------------------------------------------

  1867. 

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

  1869. {

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

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

  1872. 

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

  1874.     {

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

  1876.             return graph->getConnections();

  1877.     }

  1878.     else

  1879.     {

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

  1881.             return graph->getConnections();

  1882.     }

  1883. 

  1884.     return nullptr;

  1885. }

  1886. 

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

  1888. {

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

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

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

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

  1893. 

  1894.     uint groupA, portA;

  1895.     uint groupB, portB;

  1896. 

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

  1898.     {

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

  1900.         CARLA_SAFE_ASSERT_RETURN(graph != nullptr,);

  1901. 

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

  1903.             return;

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

  1905.             return;

  1906.     }

  1907.     else

  1908.     {

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

  1910.         CARLA_SAFE_ASSERT_RETURN(graph != nullptr,);

  1911. 

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

  1913.             return;

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

  1915.             return;

  1916.     }

  1917. 

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

  1919. }

  1920. 

  1921. // -----------------------------------------------------------------------

  1922. 

  1923. CARLA_BACKEND_END_NAMESPACE

  1924. 

  1925. // -----------------------------------------------------------------------