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

2330 lines
79KB
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. // FIXME: update to new Juce API

  26. #if defined(__clang__)

  27. # pragma clang diagnostic push

  28. # pragma clang diagnostic ignored "-Wdeprecated-declarations"

  29. #elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))

  30. # pragma GCC diagnostic push

  31. # pragma GCC diagnostic ignored "-Wdeprecated-declarations"

  32. #endif

  33. 

  34. using juce::AudioPluginInstance;

  35. using juce::AudioProcessor;

  36. using juce::AudioProcessorEditor;

  37. using juce::FloatVectorOperations;

  38. using juce::MemoryBlock;

  39. using juce::PluginDescription;

  40. using juce::String;

  41. using juce::StringArray;

  42. using juce::jmin;

  43. using juce::jmax;

  44. 

  45. CARLA_BACKEND_START_NAMESPACE

  46. 

  47. // -----------------------------------------------------------------------

  48. // External Graph stuff

  49. 

  50. static inline

  51. uint getExternalGraphPortIdFromName(const char* const shortname) noexcept

  52. {

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

  54.         return kExternalGraphCarlaPortAudioIn1;

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

  56.         return kExternalGraphCarlaPortAudioIn2;

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

  58.         return kExternalGraphCarlaPortAudioOut1;

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

  60.         return kExternalGraphCarlaPortAudioOut2;

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

  62.         return kExternalGraphCarlaPortMidiIn;

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

  64.         return kExternalGraphCarlaPortMidiOut;

  65. 

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

  67.     return kExternalGraphCarlaPortNull;

  68. }

  69. 

  70. static inline

  71. const char* getExternalGraphFullPortNameFromId(const /*RackGraphCarlaPortIds*/ uint portId)

  72. {

  73.     switch (portId)

  74.     {

  75.     case kExternalGraphCarlaPortAudioIn1:

  76.         return "Carla:AudioIn1";

  77.     case kExternalGraphCarlaPortAudioIn2:

  78.         return "Carla:AudioIn2";

  79.     case kExternalGraphCarlaPortAudioOut1:

  80.         return "Carla:AudioOut1";

  81.     case kExternalGraphCarlaPortAudioOut2:

  82.         return "Carla:AudioOut2";

  83.     case kExternalGraphCarlaPortMidiIn:

  84.         return "Carla:MidiIn";

  85.     case kExternalGraphCarlaPortMidiOut:

  86.         return "Carla:MidiOut";

  87.     //case kExternalGraphCarlaPortNull:

  88.     //case kExternalGraphCarlaPortMax:

  89.     //    break;

  90.     }

  91. 

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

  93.     return nullptr;

  94. }

  95. 

  96. // -----------------------------------------------------------------------

  97. 

  98. ExternalGraphPorts::ExternalGraphPorts() noexcept

  99.     : ins(),

  100.       outs() {}

  101. 

  102. const char* ExternalGraphPorts::getName(const bool isInput, const uint portId) const noexcept

  103. {

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

  105.     {

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

  107. 

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

  109.         CARLA_SAFE_ASSERT_CONTINUE(portNameToId.group > 0);

  110. 

  111.         if (portNameToId.port == portId)

  112.             return portNameToId.name;

  113.     }

  114. 

  115.     return nullptr;

  116. }

  117. 

  118. uint ExternalGraphPorts::getPortId(const bool isInput, const char portName[], bool* const ok) const noexcept

  119. {

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

  121.     {

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

  123. 

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

  125.         CARLA_SAFE_ASSERT_CONTINUE(portNameToId.group > 0);

  126. 

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

  128.         {

  129.             if (ok != nullptr)

  130.                 *ok = true;

  131.             return portNameToId.port;

  132.         }

  133.     }

  134. 

  135.     if (ok != nullptr)

  136.         *ok = false;

  137.     return 0;

  138. }

  139. 

  140. // -----------------------------------------------------------------------

  141. 

  142. ExternalGraph::ExternalGraph(CarlaEngine* const engine) noexcept

  143.     : connections(),

  144.       audioPorts(),

  145.       midiPorts(),

  146.       retCon(),

  147.       kEngine(engine) {}

  148. 

  149. void ExternalGraph::clear() noexcept

  150. {

  151.     connections.clear();

  152.     audioPorts.ins.clear();

  153.     audioPorts.outs.clear();

  154.     midiPorts.ins.clear();

  155.     midiPorts.outs.clear();

  156. }

  157. 

  158. bool ExternalGraph::connect(const uint groupA, const uint portA, const uint groupB, const uint portB, const bool sendCallback) noexcept

  159. {

  160.     uint otherGroup, otherPort, carlaPort;

  161. 

  162.     if (groupA == kExternalGraphGroupCarla)

  163.     {

  164.         CARLA_SAFE_ASSERT_RETURN(groupB != kExternalGraphGroupCarla, false);

  165. 

  166.         carlaPort  = portA;

  167.         otherGroup = groupB;

  168.         otherPort  = portB;

  169.     }

  170.     else

  171.     {

  172.         CARLA_SAFE_ASSERT_RETURN(groupB == kExternalGraphGroupCarla, false);

  173. 

  174.         carlaPort  = portB;

  175.         otherGroup = groupA;

  176.         otherPort  = portA;

  177.     }

  178. 

  179.     CARLA_SAFE_ASSERT_RETURN(carlaPort > kExternalGraphCarlaPortNull && carlaPort < kExternalGraphCarlaPortMax, false);

  180.     CARLA_SAFE_ASSERT_RETURN(otherGroup > kExternalGraphGroupCarla && otherGroup < kExternalGraphGroupMax, false);

  181. 

  182.     bool makeConnection = false;

  183. 

  184.     switch (carlaPort)

  185.     {

  186.     case kExternalGraphCarlaPortAudioIn1:

  187.         CARLA_SAFE_ASSERT_RETURN(otherGroup == kExternalGraphGroupAudioIn, false);

  188.         makeConnection = kEngine->connectExternalGraphPort(kExternalGraphConnectionAudioIn1, otherPort, nullptr);

  189.         break;

  190. 

  191.     case kExternalGraphCarlaPortAudioIn2:

  192.         CARLA_SAFE_ASSERT_RETURN(otherGroup == kExternalGraphGroupAudioIn, false);

  193.         makeConnection = kEngine->connectExternalGraphPort(kExternalGraphConnectionAudioIn2, otherPort, nullptr);

  194.         break;

  195. 

  196.     case kExternalGraphCarlaPortAudioOut1:

  197.         CARLA_SAFE_ASSERT_RETURN(otherGroup == kExternalGraphGroupAudioOut, false);

  198.         makeConnection = kEngine->connectExternalGraphPort(kExternalGraphConnectionAudioOut1, otherPort, nullptr);

  199.         break;

  200. 

  201.     case kExternalGraphCarlaPortAudioOut2:

  202.         CARLA_SAFE_ASSERT_RETURN(otherGroup == kExternalGraphGroupAudioOut, false);

  203.         makeConnection = kEngine->connectExternalGraphPort(kExternalGraphConnectionAudioOut2, otherPort, nullptr);

  204.         break;

  205. 

  206.     case kExternalGraphCarlaPortMidiIn:

  207.         CARLA_SAFE_ASSERT_RETURN(otherGroup == kExternalGraphGroupMidiIn, false);

  208.         if (const char* const portName = midiPorts.getName(true, otherPort))

  209.             makeConnection = kEngine->connectExternalGraphPort(kExternalGraphConnectionMidiInput, 0, portName);

  210.         break;

  211. 

  212.     case kExternalGraphCarlaPortMidiOut:

  213.         CARLA_SAFE_ASSERT_RETURN(otherGroup == kExternalGraphGroupMidiOut, false);

  214.         if (const char* const portName = midiPorts.getName(false, otherPort))

  215.             makeConnection = kEngine->connectExternalGraphPort(kExternalGraphConnectionMidiOutput, 0, portName);

  216.         break;

  217.     }

  218. 

  219.     if (! makeConnection)

  220.     {

  221.         kEngine->setLastError("Invalid rack connection");

  222.         return false;

  223.     }

  224. 

  225.     ConnectionToId connectionToId;

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

  227. 

  228.     char strBuf[STR_MAX+1];

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

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

  231. 

  232.     if (sendCallback)

  233.         kEngine->callback(ENGINE_CALLBACK_PATCHBAY_CONNECTION_ADDED, connectionToId.id, 0, 0, 0.0f, strBuf);

  234. 

  235.     connections.list.append(connectionToId);

  236.     return true;

  237. }

  238. 

  239. bool ExternalGraph::disconnect(const uint connectionId) noexcept

  240. {

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

  242. 

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

  244.     {

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

  246. 

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

  248.         CARLA_SAFE_ASSERT_CONTINUE(connectionToId.id > 0);

  249. 

  250.         if (connectionToId.id != connectionId)

  251.             continue;

  252. 

  253.         uint otherGroup, otherPort, carlaPort;

  254. 

  255.         if (connectionToId.groupA == kExternalGraphGroupCarla)

  256.         {

  257.             CARLA_SAFE_ASSERT_RETURN(connectionToId.groupB != kExternalGraphGroupCarla, false);

  258. 

  259.             carlaPort  = connectionToId.portA;

  260.             otherGroup = connectionToId.groupB;

  261.             otherPort  = connectionToId.portB;

  262.         }

  263.         else

  264.         {

  265.             CARLA_SAFE_ASSERT_RETURN(connectionToId.groupB == kExternalGraphGroupCarla, false);

  266. 

  267.             carlaPort  = connectionToId.portB;

  268.             otherGroup = connectionToId.groupA;

  269.             otherPort  = connectionToId.portA;

  270.         }

  271. 

  272.         CARLA_SAFE_ASSERT_RETURN(carlaPort > kExternalGraphCarlaPortNull && carlaPort < kExternalGraphCarlaPortMax, false);

  273.         CARLA_SAFE_ASSERT_RETURN(otherGroup > kExternalGraphGroupCarla && otherGroup < kExternalGraphGroupMax, false);

  274. 

  275.         bool makeDisconnection = false;

  276. 

  277.         switch (carlaPort)

  278.         {

  279.         case kExternalGraphCarlaPortAudioIn1:

  280.             makeDisconnection = kEngine->disconnectExternalGraphPort(kExternalGraphConnectionAudioIn1, otherPort, nullptr);

  281.             break;

  282. 

  283.         case kExternalGraphCarlaPortAudioIn2:

  284.             makeDisconnection = kEngine->disconnectExternalGraphPort(kExternalGraphConnectionAudioIn2, otherPort, nullptr);

  285.             break;

  286. 

  287.         case kExternalGraphCarlaPortAudioOut1:

  288.             makeDisconnection = kEngine->disconnectExternalGraphPort(kExternalGraphConnectionAudioOut1, otherPort, nullptr);

  289.             break;

  290. 

  291.         case kExternalGraphCarlaPortAudioOut2:

  292.             makeDisconnection = kEngine->disconnectExternalGraphPort(kExternalGraphConnectionAudioOut2, otherPort, nullptr);

  293.             break;

  294. 

  295.         case kExternalGraphCarlaPortMidiIn:

  296.             if (const char* const portName = midiPorts.getName(true, otherPort))

  297.                 makeDisconnection = kEngine->disconnectExternalGraphPort(kExternalGraphConnectionMidiInput, 0, portName);

  298.             break;

  299. 

  300.         case kExternalGraphCarlaPortMidiOut:

  301.             if (const char* const portName = midiPorts.getName(false, otherPort))

  302.                 makeDisconnection = kEngine->disconnectExternalGraphPort(kExternalGraphConnectionMidiOutput, 0, portName);

  303.             break;

  304.         }

  305. 

  306.         if (! makeDisconnection)

  307.         {

  308.             kEngine->setLastError("Invalid rack connection");

  309.             return false;

  310.         }

  311. 

  312.         kEngine->callback(ENGINE_CALLBACK_PATCHBAY_CONNECTION_REMOVED, connectionToId.id, 0, 0, 0.0f, nullptr);

  313. 

  314.         connections.list.remove(it);

  315.         return true;

  316.     }

  317. 

  318.     kEngine->setLastError("Failed to find connection");

  319.     return false;

  320. }

  321. 

  322. void ExternalGraph::refresh(const char* const deviceName)

  323. {

  324.     CARLA_SAFE_ASSERT_RETURN(deviceName != nullptr,);

  325. 

  326.     const bool isRack(kEngine->getOptions().processMode == ENGINE_PROCESS_MODE_CONTINUOUS_RACK);

  327. 

  328.     // Main

  329.     {

  330.         kEngine->callback(ENGINE_CALLBACK_PATCHBAY_CLIENT_ADDED, kExternalGraphGroupCarla, PATCHBAY_ICON_CARLA, -1, 0.0f, kEngine->getName());

  331. 

  332.         if (isRack)

  333.         {

  334.             kEngine->callback(ENGINE_CALLBACK_PATCHBAY_PORT_ADDED, kExternalGraphGroupCarla, kExternalGraphCarlaPortAudioIn1,  PATCHBAY_PORT_TYPE_AUDIO|PATCHBAY_PORT_IS_INPUT, 0.0f, "audio-in1");

  335.             kEngine->callback(ENGINE_CALLBACK_PATCHBAY_PORT_ADDED, kExternalGraphGroupCarla, kExternalGraphCarlaPortAudioIn2,  PATCHBAY_PORT_TYPE_AUDIO|PATCHBAY_PORT_IS_INPUT, 0.0f, "audio-in2");

  336.             kEngine->callback(ENGINE_CALLBACK_PATCHBAY_PORT_ADDED, kExternalGraphGroupCarla, kExternalGraphCarlaPortAudioOut1, PATCHBAY_PORT_TYPE_AUDIO,                        0.0f, "audio-out1");

  337.             kEngine->callback(ENGINE_CALLBACK_PATCHBAY_PORT_ADDED, kExternalGraphGroupCarla, kExternalGraphCarlaPortAudioOut2, PATCHBAY_PORT_TYPE_AUDIO,                        0.0f, "audio-out2");

  338.         }

  339. 

  340.         kEngine->callback(ENGINE_CALLBACK_PATCHBAY_PORT_ADDED, kExternalGraphGroupCarla, kExternalGraphCarlaPortMidiIn,    PATCHBAY_PORT_TYPE_MIDI|PATCHBAY_PORT_IS_INPUT,  0.0f, "midi-in");

  341.         kEngine->callback(ENGINE_CALLBACK_PATCHBAY_PORT_ADDED, kExternalGraphGroupCarla, kExternalGraphCarlaPortMidiOut,   PATCHBAY_PORT_TYPE_MIDI,                         0.0f, "midi-out");

  342.     }

  343. 

  344.     char strBuf[STR_MAX+1];

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

  346. 

  347.     if (isRack)

  348.     {

  349.         // Audio In

  350.         if (deviceName[0] != '\0')

  351.             std::snprintf(strBuf, STR_MAX, "Capture (%s)", deviceName);

  352.         else

  353.             std::strncpy(strBuf, "Capture", STR_MAX);

  354. 

  355.         kEngine->callback(ENGINE_CALLBACK_PATCHBAY_CLIENT_ADDED, kExternalGraphGroupAudioIn, PATCHBAY_ICON_HARDWARE, -1, 0.0f, strBuf);

  356. 

  357.         const CarlaString groupNameIn(strBuf);

  358. 

  359.         int h = 0;

  360.         for (LinkedList<PortNameToId>::Itenerator it = audioPorts.ins.begin2(); it.valid(); it.next())

  361.         {

  362.             PortNameToId& portNameToId(it.getValue());

  363.             portNameToId.setFullName(groupNameIn + portNameToId.name);

  364. 

  365.             kEngine->callback(ENGINE_CALLBACK_PATCHBAY_PORT_ADDED, kExternalGraphGroupAudioIn, ++h,

  366.                               PATCHBAY_PORT_TYPE_AUDIO, 0.0f, portNameToId.name);

  367.         }

  368. 

  369.         // Audio Out

  370.         if (deviceName[0] != '\0')

  371.             std::snprintf(strBuf, STR_MAX, "Playback (%s)", deviceName);

  372.         else

  373.             std::strncpy(strBuf, "Playback", STR_MAX);

  374. 

  375.         kEngine->callback(ENGINE_CALLBACK_PATCHBAY_CLIENT_ADDED, kExternalGraphGroupAudioOut, PATCHBAY_ICON_HARDWARE, -1, 0.0f, strBuf);

  376. 

  377.         const CarlaString groupNameOut(strBuf);

  378. 

  379.         h = 0;

  380.         for (LinkedList<PortNameToId>::Itenerator it = audioPorts.outs.begin2(); it.valid(); it.next())

  381.         {

  382.             PortNameToId& portNameToId(it.getValue());

  383.             portNameToId.setFullName(groupNameOut + portNameToId.name);

  384. 

  385.             kEngine->callback(ENGINE_CALLBACK_PATCHBAY_PORT_ADDED, kExternalGraphGroupAudioOut, ++h,

  386.                               PATCHBAY_PORT_TYPE_AUDIO|PATCHBAY_PORT_IS_INPUT, 0.0f, portNameToId.name);

  387.         }

  388.     }

  389. 

  390.     // MIDI In

  391.     {

  392.         kEngine->callback(ENGINE_CALLBACK_PATCHBAY_CLIENT_ADDED, kExternalGraphGroupMidiIn, PATCHBAY_ICON_HARDWARE, -1, 0.0f, "Readable MIDI ports");

  393. 

  394.         const CarlaString groupNamePlus("Readable MIDI ports:");

  395. 

  396.         int h = 0;

  397.         for (LinkedList<PortNameToId>::Itenerator it = midiPorts.ins.begin2(); it.valid(); it.next())

  398.         {

  399.             PortNameToId& portNameToId(it.getValue());

  400.             portNameToId.setFullName(groupNamePlus + portNameToId.name);

  401. 

  402.             kEngine->callback(ENGINE_CALLBACK_PATCHBAY_PORT_ADDED, kExternalGraphGroupMidiIn, ++h,

  403.                               PATCHBAY_PORT_TYPE_MIDI, 0.0f, portNameToId.name);

  404.         }

  405.     }

  406. 

  407.     // MIDI Out

  408.     {

  409.         kEngine->callback(ENGINE_CALLBACK_PATCHBAY_CLIENT_ADDED, kExternalGraphGroupMidiOut, PATCHBAY_ICON_HARDWARE, -1, 0.0f, "Writable MIDI ports");

  410. 

  411.         const CarlaString groupNamePlus("Writable MIDI ports:");

  412. 

  413.         int h = 0;

  414.         for (LinkedList<PortNameToId>::Itenerator it = midiPorts.outs.begin2(); it.valid(); it.next())

  415.         {

  416.             PortNameToId& portNameToId(it.getValue());

  417.             portNameToId.setFullName(groupNamePlus + portNameToId.name);

  418. 

  419.             kEngine->callback(ENGINE_CALLBACK_PATCHBAY_PORT_ADDED, kExternalGraphGroupMidiOut, ++h,

  420.                               PATCHBAY_PORT_TYPE_MIDI|PATCHBAY_PORT_IS_INPUT, 0.0f, portNameToId.name);

  421.         }

  422.     }

  423. }

  424. 

  425. const char* const* ExternalGraph::getConnections() const noexcept

  426. {

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

  428.         return nullptr;

  429. 

  430.     CarlaStringList connList;

  431. 

  432.     char strBuf[STR_MAX+1];

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

  434. 

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

  436.     {

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

  438. 

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

  440.         CARLA_SAFE_ASSERT_CONTINUE(connectionToId.id > 0);

  441. 

  442.         uint otherGroup, otherPort, carlaPort;

  443. 

  444.         if (connectionToId.groupA == kExternalGraphGroupCarla)

  445.         {

  446.             CARLA_SAFE_ASSERT_CONTINUE(connectionToId.groupB != kExternalGraphGroupCarla);

  447. 

  448.             carlaPort  = connectionToId.portA;

  449.             otherGroup = connectionToId.groupB;

  450.             otherPort  = connectionToId.portB;

  451.         }

  452.         else

  453.         {

  454.             CARLA_SAFE_ASSERT_CONTINUE(connectionToId.groupB == kExternalGraphGroupCarla);

  455. 

  456.             carlaPort  = connectionToId.portB;

  457.             otherGroup = connectionToId.groupA;

  458.             otherPort  = connectionToId.portA;

  459.         }

  460. 

  461.         CARLA_SAFE_ASSERT_CONTINUE(carlaPort > kExternalGraphCarlaPortNull && carlaPort < kExternalGraphCarlaPortMax);

  462.         CARLA_SAFE_ASSERT_CONTINUE(otherGroup > kExternalGraphGroupCarla && otherGroup < kExternalGraphGroupMax);

  463. 

  464.         switch (carlaPort)

  465.         {

  466.         case kExternalGraphCarlaPortAudioIn1:

  467.         case kExternalGraphCarlaPortAudioIn2:

  468.             std::snprintf(strBuf, STR_MAX, "AudioIn:%s", audioPorts.getName(true, otherPort));

  469.             connList.append(strBuf);

  470.             connList.append(getExternalGraphFullPortNameFromId(carlaPort));

  471.             break;

  472. 

  473.         case kExternalGraphCarlaPortAudioOut1:

  474.         case kExternalGraphCarlaPortAudioOut2:

  475.             std::snprintf(strBuf, STR_MAX, "AudioOut:%s", audioPorts.getName(false, otherPort));

  476.             connList.append(getExternalGraphFullPortNameFromId(carlaPort));

  477.             connList.append(strBuf);

  478.             break;

  479. 

  480.         case kExternalGraphCarlaPortMidiIn:

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

  482.             connList.append(strBuf);

  483.             connList.append(getExternalGraphFullPortNameFromId(carlaPort));

  484.             break;

  485. 

  486.         case kExternalGraphCarlaPortMidiOut:

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

  488.             connList.append(getExternalGraphFullPortNameFromId(carlaPort));

  489.             connList.append(strBuf);

  490.             break;

  491.         }

  492.     }

  493. 

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

  495.         return nullptr;

  496. 

  497.     retCon = connList.toCharStringListPtr();

  498. 

  499.     return retCon;

  500. }

  501. 

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

  503. {

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

  505. 

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

  507.     {

  508.         groupId = kExternalGraphGroupCarla;

  509.         portId  = getExternalGraphPortIdFromName(fullPortName+6);

  510. 

  511.         if (portId > kExternalGraphCarlaPortNull && portId < kExternalGraphCarlaPortMax)

  512.             return true;

  513.     }

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

  515.     {

  516.         groupId = kExternalGraphGroupAudioIn;

  517. 

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

  519.         {

  520.             bool ok;

  521.             portId = audioPorts.getPortId(true, portName, &ok);

  522.             return ok;

  523.         }

  524.     }

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

  526.     {

  527.         groupId = kExternalGraphGroupAudioOut;

  528. 

  529.         if (const char* const portName = fullPortName+9)

  530.         {

  531.             bool ok;

  532.             portId = audioPorts.getPortId(false, portName, &ok);

  533.             return ok;

  534.         }

  535.     }

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

  537.     {

  538.         groupId = kExternalGraphGroupMidiIn;

  539. 

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

  541.         {

  542.             bool ok;

  543.             portId = midiPorts.getPortId(true, portName, &ok);

  544.             return ok;

  545.         }

  546.     }

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

  548.     {

  549.         groupId = kExternalGraphGroupMidiOut;

  550. 

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

  552.         {

  553.             bool ok;

  554.             portId = midiPorts.getPortId(false, portName, &ok);

  555.             return ok;

  556.         }

  557.     }

  558. 

  559.     return false;

  560. }

  561. 

  562. // -----------------------------------------------------------------------

  563. // RackGraph Buffers

  564. 

  565. RackGraph::Buffers::Buffers() noexcept

  566.     : mutex(),

  567.       connectedIn1(),

  568.       connectedIn2(),

  569.       connectedOut1(),

  570.       connectedOut2()

  571. #ifdef CARLA_PROPER_CPP11_SUPPORT

  572.     , inBuf{nullptr, nullptr},

  573.       inBufTmp{nullptr, nullptr},

  574.       outBuf{nullptr, nullptr} {}

  575. #else

  576.     {

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

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

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

  580.     }

  581. #endif

  582. 

  583. RackGraph::Buffers::~Buffers() noexcept

  584. {

  585.     const CarlaRecursiveMutexLocker cml(mutex);

  586. 

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

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

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

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

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

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

  593. 

  594.     connectedIn1.clear();

  595.     connectedIn2.clear();

  596.     connectedOut1.clear();

  597.     connectedOut2.clear();

  598. }

  599. 

  600. void RackGraph::Buffers::setBufferSize(const uint32_t bufferSize, const bool createBuffers) noexcept

  601. {

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

  603. 

  604.     const CarlaRecursiveMutexLocker cml(mutex);

  605. 

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

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

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

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

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

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

  612. 

  613.     CARLA_SAFE_ASSERT_RETURN(bufferSize > 0,);

  614. 

  615.     try {

  616.         inBufTmp[0] = new float[bufferSize];

  617.         inBufTmp[1] = new float[bufferSize];

  618. 

  619.         if (createBuffers)

  620.         {

  621.             inBuf[0]  = new float[bufferSize];

  622.             inBuf[1]  = new float[bufferSize];

  623.             outBuf[0] = new float[bufferSize];

  624.             outBuf[1] = new float[bufferSize];

  625.         }

  626.     }

  627.     catch(...) {

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

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

  630. 

  631.         if (createBuffers)

  632.         {

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

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

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

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

  637.         }

  638.         return;

  639.     }

  640. 

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

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

  643. 

  644.     if (createBuffers)

  645.     {

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

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

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

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

  650.     }

  651. }

  652. 

  653. // -----------------------------------------------------------------------

  654. // RackGraph

  655. 

  656. RackGraph::RackGraph(CarlaEngine* const engine, const uint32_t ins, const uint32_t outs) noexcept

  657.     : extGraph(engine),

  658.       inputs(ins),

  659.       outputs(outs),

  660.       isOffline(false),

  661.       audioBuffers(),

  662.       kEngine(engine)

  663. {

  664.     setBufferSize(engine->getBufferSize());

  665. }

  666. 

  667. RackGraph::~RackGraph() noexcept

  668. {

  669.     extGraph.clear();

  670. }

  671. 

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

  673. {

  674.     audioBuffers.setBufferSize(bufferSize, (inputs > 0 || outputs > 0));

  675. }

  676. 

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

  678. {

  679.     isOffline = offline;

  680. }

  681. 

  682. bool RackGraph::connect(const uint groupA, const uint portA, const uint groupB, const uint portB) noexcept

  683. {

  684.     return extGraph.connect(groupA, portA, groupB, portB, true);

  685. }

  686. 

  687. bool RackGraph::disconnect(const uint connectionId) noexcept

  688. {

  689.     return extGraph.disconnect(connectionId);

  690. }

  691. 

  692. void RackGraph::refresh(const char* const deviceName)

  693. {

  694.     extGraph.refresh(deviceName);

  695. 

  696.     char strBuf[STR_MAX+1];

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

  698. 

  699.     // Connections

  700.     const CarlaRecursiveMutexLocker cml(audioBuffers.mutex);

  701. 

  702.     for (LinkedList<uint>::Itenerator it = audioBuffers.connectedIn1.begin2(); it.valid(); it.next())

  703.     {

  704.         const uint& portId(it.getValue(0));

  705.         CARLA_SAFE_ASSERT_CONTINUE(portId > 0);

  706.         CARLA_SAFE_ASSERT_CONTINUE(portId <= extGraph.audioPorts.ins.count());

  707. 

  708.         ConnectionToId connectionToId;

  709.         connectionToId.setData(++(extGraph.connections.lastId), kExternalGraphGroupAudioIn, portId, kExternalGraphGroupCarla, kExternalGraphCarlaPortAudioIn1);

  710. 

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

  712. 

  713.         kEngine->callback(ENGINE_CALLBACK_PATCHBAY_CONNECTION_ADDED, connectionToId.id, 0, 0, 0.0f, strBuf);

  714. 

  715.         extGraph.connections.list.append(connectionToId);

  716.     }

  717. 

  718.     for (LinkedList<uint>::Itenerator it = audioBuffers.connectedIn2.begin2(); it.valid(); it.next())

  719.     {

  720.         const uint& portId(it.getValue(0));

  721.         CARLA_SAFE_ASSERT_CONTINUE(portId > 0);

  722.         CARLA_SAFE_ASSERT_CONTINUE(portId <= extGraph.audioPorts.ins.count());

  723. 

  724.         ConnectionToId connectionToId;

  725.         connectionToId.setData(++(extGraph.connections.lastId), kExternalGraphGroupAudioIn, portId, kExternalGraphGroupCarla, kExternalGraphCarlaPortAudioIn2);

  726. 

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

  728. 

  729.         kEngine->callback(ENGINE_CALLBACK_PATCHBAY_CONNECTION_ADDED, connectionToId.id, 0, 0, 0.0f, strBuf);

  730. 

  731.         extGraph.connections.list.append(connectionToId);

  732.     }

  733. 

  734.     for (LinkedList<uint>::Itenerator it = audioBuffers.connectedOut1.begin2(); it.valid(); it.next())

  735.     {

  736.         const uint& portId(it.getValue(0));

  737.         CARLA_SAFE_ASSERT_CONTINUE(portId > 0);

  738.         CARLA_SAFE_ASSERT_CONTINUE(portId <= extGraph.audioPorts.outs.count());

  739. 

  740.         ConnectionToId connectionToId;

  741.         connectionToId.setData(++(extGraph.connections.lastId), kExternalGraphGroupCarla, kExternalGraphCarlaPortAudioOut1, kExternalGraphGroupAudioOut, portId);

  742. 

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

  744. 

  745.         kEngine->callback(ENGINE_CALLBACK_PATCHBAY_CONNECTION_ADDED, connectionToId.id, 0, 0, 0.0f, strBuf);

  746. 

  747.         extGraph.connections.list.append(connectionToId);

  748.     }

  749. 

  750.     for (LinkedList<uint>::Itenerator it = audioBuffers.connectedOut2.begin2(); it.valid(); it.next())

  751.     {

  752.         const uint& portId(it.getValue(0));

  753.         CARLA_SAFE_ASSERT_CONTINUE(portId > 0);

  754.         CARLA_SAFE_ASSERT_CONTINUE(portId <= extGraph.audioPorts.outs.count());

  755. 

  756.         ConnectionToId connectionToId;

  757.         connectionToId.setData(++(extGraph.connections.lastId), kExternalGraphGroupCarla, kExternalGraphCarlaPortAudioOut2, kExternalGraphGroupAudioOut, portId);

  758. 

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

  760. 

  761.         kEngine->callback(ENGINE_CALLBACK_PATCHBAY_CONNECTION_ADDED, connectionToId.id, 0, 0, 0.0f, strBuf);

  762. 

  763.         extGraph.connections.list.append(connectionToId);

  764.     }

  765. }

  766. 

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

  768. {

  769.     return extGraph.getConnections();

  770. }

  771. 

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

  773. {

  774.     return extGraph.getGroupAndPortIdFromFullName(fullPortName, groupId, portId);

  775. }

  776. 

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

  778. {

  779.     CARLA_SAFE_ASSERT_RETURN(data != nullptr,);

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

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

  782. 

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

  784. 

  785.     // safe copy

  786.     float inBuf0[frames];

  787.     float inBuf1[frames];

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

  789. 

  790.     // initialize audio inputs

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

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

  793. 

  794.     // initialize audio outputs (zero)

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

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

  797. 

  798.     // initialize event outputs (zero)

  799.     carla_zeroStructs(data->events.out, kMaxEngineEventInternalCount);

  800. 

  801.     uint32_t oldAudioInCount  = 0;

  802.     uint32_t oldAudioOutCount = 0;

  803.     uint32_t oldMidiOutCount  = 0;

  804.     bool processed = false;

  805.     juce::Range<float> range;

  806. 

  807.     // process plugins

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

  809.     {

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

  811. 

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

  813.             continue;

  814. 

  815.         if (processed)

  816.         {

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

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

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

  820. 

  821.             // initialize audio outputs (zero)

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

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

  824. 

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

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

  827.             {

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

  829.                 {

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

  831.                 }

  832.                 // else nothing needed

  833.             }

  834.             else

  835.             {

  836.                 // initialize event inputs from previous outputs

  837.                 carla_copyStructs(data->events.in, data->events.out, kMaxEngineEventInternalCount);

  838. 

  839.                 // initialize event outputs (zero)

  840.                 carla_zeroStructs(data->events.out, kMaxEngineEventInternalCount);

  841.             }

  842.         }

  843. 

  844.         oldAudioInCount  = plugin->getAudioInCount();

  845.         oldAudioOutCount = plugin->getAudioOutCount();

  846.         oldMidiOutCount  = plugin->getMidiOutCount();

  847. 

  848.         // process

  849.         plugin->initBuffers();

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

  851.         plugin->unlock();

  852. 

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

  854.         if (oldAudioInCount == 0)

  855.         {

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

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

  858.         }

  859. 

  860.         // if plugin only has 1 output, copy it to the 2nd

  861.         if (oldAudioOutCount == 1)

  862.         {

  863.             FloatVectorOperations::copy(outBuf[1], outBuf[0], iframes);

  864.         }

  865. 

  866.         // set peaks

  867.         {

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

  869. 

  870.             if (oldAudioInCount > 0)

  871.             {

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

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

  874. 

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

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

  877.             }

  878.             else

  879.             {

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

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

  882.             }

  883. 

  884.             if (oldAudioOutCount > 0)

  885.             {

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

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

  888. 

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

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

  891.             }

  892.             else

  893.             {

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

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

  896.             }

  897.         }

  898. 

  899.         processed = true;

  900.     }

  901. }

  902. 

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

  904. {

  905.     CARLA_SAFE_ASSERT_RETURN(audioBuffers.outBuf[1] != nullptr,);

  906. 

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

  908. 

  909.     const CarlaRecursiveMutexLocker _cml(audioBuffers.mutex);

  910. 

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

  912.     {

  913.         bool noConnections = true;

  914. 

  915.         // connect input buffers

  916.         for (LinkedList<uint>::Itenerator it = audioBuffers.connectedIn1.begin2(); it.valid(); it.next())

  917.         {

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

  919.             CARLA_SAFE_ASSERT_CONTINUE(port > 0);

  920.             CARLA_SAFE_ASSERT_CONTINUE(port <= inputs);

  921. 

  922.             if (noConnections)

  923.             {

  924.                 FloatVectorOperations::copy(audioBuffers.inBuf[0], inBuf[port], iframes);

  925.                 noConnections = false;

  926.             }

  927.             else

  928.             {

  929.                 FloatVectorOperations::add(audioBuffers.inBuf[0], inBuf[port], iframes);

  930.             }

  931.         }

  932. 

  933.         if (noConnections)

  934.             FloatVectorOperations::clear(audioBuffers.inBuf[0], iframes);

  935. 

  936.         noConnections = true;

  937. 

  938.         for (LinkedList<uint>::Itenerator it = audioBuffers.connectedIn2.begin2(); it.valid(); it.next())

  939.         {

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

  941.             CARLA_SAFE_ASSERT_CONTINUE(port > 0);

  942.             CARLA_SAFE_ASSERT_CONTINUE(port <= inputs);

  943. 

  944.             if (noConnections)

  945.             {

  946.                 FloatVectorOperations::copy(audioBuffers.inBuf[1], inBuf[port-1], iframes);

  947.                 noConnections = false;

  948.             }

  949.             else

  950.             {

  951.                 FloatVectorOperations::add(audioBuffers.inBuf[1], inBuf[port-1], iframes);

  952.             }

  953.         }

  954. 

  955.         if (noConnections)

  956.             FloatVectorOperations::clear(audioBuffers.inBuf[1], iframes);

  957.     }

  958.     else

  959.     {

  960.         FloatVectorOperations::clear(audioBuffers.inBuf[0], iframes);

  961.         FloatVectorOperations::clear(audioBuffers.inBuf[1], iframes);

  962.     }

  963. 

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

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

  966. 

  967.     // process

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

  969. 

  970.     // connect output buffers

  971.     if (audioBuffers.connectedOut1.count() != 0)

  972.     {

  973.         for (LinkedList<uint>::Itenerator it = audioBuffers.connectedOut1.begin2(); it.valid(); it.next())

  974.         {

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

  976.             CARLA_SAFE_ASSERT_CONTINUE(port > 0);

  977.             CARLA_SAFE_ASSERT_CONTINUE(port <= outputs);

  978. 

  979.             FloatVectorOperations::add(outBuf[port-1], audioBuffers.outBuf[0], iframes);

  980.         }

  981.     }

  982. 

  983.     if (audioBuffers.connectedOut2.count() != 0)

  984.     {

  985.         for (LinkedList<uint>::Itenerator it = audioBuffers.connectedOut2.begin2(); it.valid(); it.next())

  986.         {

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

  988.             CARLA_SAFE_ASSERT_CONTINUE(port > 0);

  989.             CARLA_SAFE_ASSERT_CONTINUE(port <= outputs);

  990. 

  991.             FloatVectorOperations::add(outBuf[port-1], audioBuffers.outBuf[1], iframes);

  992.         }

  993.     }

  994. }

  995. 

  996. // -----------------------------------------------------------------------

  997. // Patchbay Graph stuff

  998. 

  999. static const uint32_t kAudioInputPortOffset  = MAX_PATCHBAY_PLUGINS*1;

  1000. static const uint32_t kAudioOutputPortOffset = MAX_PATCHBAY_PLUGINS*2;

  1001. static const uint32_t kMidiInputPortOffset   = MAX_PATCHBAY_PLUGINS*3;

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

  1003. 

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

  1005. 

  1006. static inline

  1007. bool adjustPatchbayPortIdForJuce(uint& portId)

  1008. {

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

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

  1011. 

  1012.     if (portId == kMidiInputPortOffset)

  1013.     {

  1014.         portId = kMidiChannelIndex;

  1015.         return true;

  1016.     }

  1017.     if (portId == kMidiOutputPortOffset)

  1018.     {

  1019.         portId = kMidiChannelIndex;

  1020.         return true;

  1021.     }

  1022.     if (portId >= kAudioOutputPortOffset)

  1023.     {

  1024.         portId -= kAudioOutputPortOffset;

  1025.         return true;

  1026.     }

  1027.     if (portId >= kAudioInputPortOffset)

  1028.     {

  1029.         portId -= kAudioInputPortOffset;

  1030.         return true;

  1031.     }

  1032. 

  1033.     return false;

  1034. }

  1035. 

  1036. static inline

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

  1038. {

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

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

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

  1042. 

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

  1044. 

  1045.     if (portId == kMidiOutputPortOffset)

  1046.     {

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

  1048.     }

  1049.     else if (portId == kMidiInputPortOffset)

  1050.     {

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

  1052.     }

  1053.     else if (portId >= kAudioOutputPortOffset)

  1054.     {

  1055.         CARLA_SAFE_ASSERT_RETURN(proc->getTotalNumOutputChannels() > 0, String());

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

  1057.     }

  1058.     else if (portId >= kAudioInputPortOffset)

  1059.     {

  1060.         CARLA_SAFE_ASSERT_RETURN(proc->getTotalNumInputChannels() > 0, String());

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

  1062.     }

  1063.     else

  1064.     {

  1065.         return String();

  1066.     }

  1067. 

  1068.     return fullPortName;

  1069. }

  1070. 

  1071. static inline

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

  1073. {

  1074.     CARLA_SAFE_ASSERT_RETURN(engine != nullptr,);

  1075.     CARLA_SAFE_ASSERT_RETURN(proc != nullptr,);

  1076. 

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

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

  1079. 

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

  1081.     {

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

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

  1084.     }

  1085. 

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

  1087.     {

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

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

  1090.     }

  1091. 

  1092.     if (proc->acceptsMidi())

  1093.     {

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

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

  1096.     }

  1097. 

  1098.     if (proc->producesMidi())

  1099.     {

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

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

  1102.     }

  1103. }

  1104. 

  1105. static inline

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

  1107. {

  1108.     CARLA_SAFE_ASSERT_RETURN(engine != nullptr,);

  1109.     CARLA_SAFE_ASSERT_RETURN(proc != nullptr,);

  1110. 

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

  1112.     {

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

  1114.                          0, 0.0f, nullptr);

  1115.     }

  1116. 

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

  1118.     {

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

  1120.                          0, 0.0f, nullptr);

  1121.     }

  1122. 

  1123.     if (proc->acceptsMidi())

  1124.     {

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

  1126.                          0, 0.0f, nullptr);

  1127.     }

  1128. 

  1129.     if (proc->producesMidi())

  1130.     {

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

  1132.                          0, 0.0f, nullptr);

  1133.     }

  1134. 

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

  1136. }

  1137. 

  1138. // -----------------------------------------------------------------------

  1139. 

  1140. class CarlaPluginInstance : public AudioPluginInstance

  1141. {

  1142. public:

  1143.     CarlaPluginInstance(CarlaEngine* const engine, CarlaPlugin* const plugin)

  1144.         : kEngine(engine),

  1145.           fPlugin(plugin)

  1146.     {

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

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

  1149.                              getSampleRate(), getBlockSize());

  1150.     }

  1151. 

  1152.     ~CarlaPluginInstance() override

  1153.     {

  1154.     }

  1155. 

  1156.     void invalidatePlugin() noexcept

  1157.     {

  1158.         fPlugin = nullptr;

  1159.     }

  1160. 

  1161.     // -------------------------------------------------------------------

  1162. 

  1163.     void* getPlatformSpecificData() noexcept override

  1164.     {

  1165.         return fPlugin;

  1166.     }

  1167. 

  1168.     void fillInPluginDescription(PluginDescription& d) const override

  1169.     {

  1170.         d.pluginFormatName = "Carla";

  1171.         d.category = "Carla Plugin";

  1172.         d.version = "1.0";

  1173. 

  1174.         CARLA_SAFE_ASSERT_RETURN(fPlugin != nullptr,);

  1175. 

  1176.         char strBuf[STR_MAX+1];

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

  1178. 

  1179.         fPlugin->getRealName(strBuf);

  1180.         d.name = strBuf;

  1181. 

  1182.         fPlugin->getLabel(strBuf);

  1183.         d.descriptiveName = strBuf;

  1184. 

  1185.         fPlugin->getMaker(strBuf);

  1186.         d.manufacturerName = strBuf;

  1187. 

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

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

  1190. 

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

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

  1193.         //d.hasSharedContainer = true;

  1194.     }

  1195. 

  1196.     // -------------------------------------------------------------------

  1197. 

  1198.     const String getName() const override

  1199.     {

  1200.         return fPlugin->getName();

  1201.     }

  1202. 

  1203.     void processBlock(AudioSampleBuffer& audio, MidiBuffer& midi) override

  1204.     {

  1205.         if (fPlugin == nullptr || ! fPlugin->isEnabled())

  1206.         {

  1207.             audio.clear();

  1208.             midi.clear();

  1209.             return;

  1210.         }

  1211. 

  1212.         if (! fPlugin->tryLock(kEngine->isOffline()))

  1213.         {

  1214.             audio.clear();

  1215.             midi.clear();

  1216.             return;

  1217.         }

  1218. 

  1219.         fPlugin->initBuffers();

  1220. 

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

  1222.         {

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

  1224.             CARLA_SAFE_ASSERT_RETURN(engineEvents != nullptr,);

  1225. 

  1226.             carla_zeroStructs(engineEvents, kMaxEngineEventInternalCount);

  1227.             fillEngineEventsFromJuceMidiBuffer(engineEvents, midi);

  1228.         }

  1229. 

  1230.         midi.clear();

  1231. 

  1232.         // TODO - CV support

  1233. 

  1234.         const int numSamples(audio.getNumSamples());

  1235. 

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

  1237.         {

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

  1239.                 audio.clear();

  1240. 

  1241.             float* audioBuffers[numChan];

  1242. 

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

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

  1245. 

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

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

  1248.             juce::Range<float> range;

  1249. 

  1250.             for (int i=jmin(fPlugin->getAudioInCount(), 2U); --i>=0;)

  1251.             {

  1252.                 range = FloatVectorOperations::findMinAndMax(audioBuffers[i], numSamples);

  1253.                 inPeaks[i] = carla_maxLimited<float>(std::abs(range.getStart()), std::abs(range.getEnd()), 1.0f);

  1254.             }

  1255. 

  1256.             fPlugin->process(const_cast<const float**>(audioBuffers), audioBuffers, nullptr, nullptr, static_cast<uint32_t>(numSamples));

  1257. 

  1258.             for (int i=jmin(fPlugin->getAudioOutCount(), 2U); --i>=0;)

  1259.             {

  1260.                 range = FloatVectorOperations::findMinAndMax(audioBuffers[i], numSamples);

  1261.                 outPeaks[i] = carla_maxLimited<float>(std::abs(range.getStart()), std::abs(range.getEnd()), 1.0f);

  1262.             }

  1263. 

  1264.             kEngine->setPluginPeaks(fPlugin->getId(), inPeaks, outPeaks);

  1265.         }

  1266.         else

  1267.         {

  1268.             fPlugin->process(nullptr, nullptr, nullptr, nullptr, static_cast<uint32_t>(numSamples));

  1269.         }

  1270. 

  1271.         midi.clear();

  1272. 

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

  1274.         {

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

  1276.             CARLA_SAFE_ASSERT_RETURN(engineEvents != nullptr,);

  1277. 

  1278.             fillJuceMidiBufferFromEngineEvents(midi, engineEvents);

  1279.             carla_zeroStructs(engineEvents, kMaxEngineEventInternalCount);

  1280.         }

  1281. 

  1282.         fPlugin->unlock();

  1283.     }

  1284. 

  1285.     const String getInputChannelName(int i)  const override

  1286.     {

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

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

  1289.         return client->getAudioPortName(true, static_cast<uint>(i));

  1290.     }

  1291. 

  1292.     const String getOutputChannelName(int i) const override

  1293.     {

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

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

  1296.         return client->getAudioPortName(false, static_cast<uint>(i));

  1297.     }

  1298. 

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

  1300.     void releaseResources() override {}

  1301. 

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

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

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

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

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

  1307. 

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

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

  1310. 

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

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

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

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

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

  1316. 

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

  1318.     void setCurrentProgram(int)                override {}

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

  1320.     void getStateInformation(MemoryBlock&)     override {}

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

  1322. 

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

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

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

  1326. 

  1327. #ifndef JUCE_AUDIO_PROCESSOR_NO_GUI

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

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

  1330. #endif

  1331. 

  1332.     // -------------------------------------------------------------------

  1333. 

  1334. private:

  1335.     CarlaEngine* const kEngine;

  1336.     CarlaPlugin* fPlugin;

  1337. 

  1338.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaPluginInstance)

  1339. };

  1340. 

  1341. // -----------------------------------------------------------------------

  1342. // Patchbay Graph

  1343. 

  1344. class NamedAudioGraphIOProcessor : public AudioProcessorGraph::AudioGraphIOProcessor

  1345. {

  1346. public:

  1347.     NamedAudioGraphIOProcessor(const IODeviceType type)

  1348.         : AudioProcessorGraph::AudioGraphIOProcessor(type) {}

  1349. 

  1350.     const String getInputChannelName (int index) const override

  1351.     {

  1352.         if (index < inputNames.size())

  1353.             return inputNames[index];

  1354.         return String("Playback ") + String(index+1);

  1355.     }

  1356. 

  1357.     const String getOutputChannelName (int index) const override

  1358.     {

  1359.         if (index < outputNames.size())

  1360.             return outputNames[index];

  1361.         return String("Capture ") + String(index+1);

  1362.     }

  1363. 

  1364.     void setNames(const bool isInput, const StringArray& names)

  1365.     {

  1366.         if (isInput)

  1367.             inputNames = names;

  1368.         else

  1369.             outputNames = names;

  1370.     }

  1371. 

  1372. private:

  1373.     StringArray inputNames;

  1374.     StringArray outputNames;

  1375. };

  1376. 

  1377. PatchbayGraph::PatchbayGraph(CarlaEngine* const engine, const uint32_t ins, const uint32_t outs)

  1378.     : connections(),

  1379.       graph(),

  1380.       audioBuffer(),

  1381.       midiBuffer(),

  1382.       inputs(carla_fixedValue(0U, 32U, ins)),

  1383.       outputs(carla_fixedValue(0U, 32U, outs)),

  1384.       retCon(),

  1385.       usingExternal(false),

  1386.       extGraph(engine),

  1387.       kEngine(engine)

  1388. {

  1389.     const int    bufferSize(static_cast<int>(engine->getBufferSize()));

  1390.     const double sampleRate(engine->getSampleRate());

  1391. 

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

  1393.     graph.prepareToPlay(sampleRate, bufferSize);

  1394. 

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

  1396. 

  1397.     midiBuffer.ensureSize(kMaxEngineEventInternalCount*2);

  1398.     midiBuffer.clear();

  1399. 

  1400.     StringArray channelNames;

  1401. 

  1402.     switch (inputs)

  1403.     {

  1404.     case 2:

  1405.         channelNames = {

  1406.             "Left",

  1407.             "Right",

  1408.         };

  1409.         break;

  1410.     case 3:

  1411.         channelNames = {

  1412.             "Left",

  1413.             "Right",

  1414.             "Sidechain",

  1415.         };

  1416.         break;

  1417.     }

  1418. 

  1419.     {

  1420.         NamedAudioGraphIOProcessor* const proc(

  1421.             new NamedAudioGraphIOProcessor(NamedAudioGraphIOProcessor::audioInputNode));

  1422.         proc->setNames(false, channelNames);

  1423. 

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

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

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

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

  1428.         node->properties.set("isCV", false);

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

  1430.         node->properties.set("isOSC", false);

  1431.     }

  1432. 

  1433.     {

  1434.         NamedAudioGraphIOProcessor* const proc(

  1435.             new NamedAudioGraphIOProcessor(NamedAudioGraphIOProcessor::audioOutputNode));

  1436.         proc->setNames(true, channelNames);

  1437. 

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

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

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

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

  1442.         node->properties.set("isCV", false);

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

  1444.         node->properties.set("isOSC", false);

  1445.     }

  1446. 

  1447.     {

  1448.         NamedAudioGraphIOProcessor* const proc(

  1449.             new NamedAudioGraphIOProcessor(NamedAudioGraphIOProcessor::midiInputNode));

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

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

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

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

  1454.         node->properties.set("isCV", false);

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

  1456.         node->properties.set("isOSC", false);

  1457.     }

  1458. 

  1459.     {

  1460.         NamedAudioGraphIOProcessor* const proc(

  1461.             new NamedAudioGraphIOProcessor(NamedAudioGraphIOProcessor::midiOutputNode));

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

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

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

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

  1466.         node->properties.set("isCV", false);

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

  1468.         node->properties.set("isOSC", false);

  1469.     }

  1470. }

  1471. 

  1472. PatchbayGraph::~PatchbayGraph()

  1473. {

  1474.     connections.clear();

  1475.     extGraph.clear();

  1476. 

  1477.     graph.releaseResources();

  1478.     graph.clear();

  1479.     audioBuffer.clear();

  1480. }

  1481. 

  1482. void PatchbayGraph::setBufferSize(const uint32_t bufferSize)

  1483. {

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

  1485. 

  1486.     graph.releaseResources();

  1487.     graph.prepareToPlay(kEngine->getSampleRate(), bufferSizei);

  1488.     audioBuffer.setSize(audioBuffer.getNumChannels(), bufferSizei);

  1489. }

  1490. 

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

  1492. {

  1493.     graph.releaseResources();

  1494.     graph.prepareToPlay(sampleRate, static_cast<int>(kEngine->getBufferSize()));

  1495. }

  1496. 

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

  1498. {

  1499.     graph.setNonRealtime(offline);

  1500. }

  1501. 

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

  1503. {

  1504.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

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

  1506. 

  1507.     CarlaPluginInstance* const instance(new CarlaPluginInstance(kEngine, plugin));

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

  1509.     CARLA_SAFE_ASSERT_RETURN(node != nullptr,);

  1510. 

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

  1512. 

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

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

  1515. 

  1516.     if (! usingExternal)

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

  1518. }

  1519. 

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

  1521. {

  1522.     CARLA_SAFE_ASSERT_RETURN(oldPlugin != nullptr,);

  1523.     CARLA_SAFE_ASSERT_RETURN(newPlugin != nullptr,);

  1524.     CARLA_SAFE_ASSERT_RETURN(oldPlugin != newPlugin,);

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

  1526. 

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

  1528.     CARLA_SAFE_ASSERT_RETURN(oldNode != nullptr,);

  1529. 

  1530.     if (! usingExternal)

  1531.     {

  1532.         disconnectInternalGroup(oldNode->nodeId);

  1533.         removeNodeFromPatchbay(kEngine, oldNode->nodeId, oldNode->getProcessor());

  1534.     }

  1535. 

  1536.     ((CarlaPluginInstance*)oldNode->getProcessor())->invalidatePlugin();

  1537. 

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

  1539. 

  1540.     CarlaPluginInstance* const instance(new CarlaPluginInstance(kEngine, newPlugin));

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

  1542.     CARLA_SAFE_ASSERT_RETURN(node != nullptr,);

  1543. 

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

  1545. 

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

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

  1548. 

  1549.     if (! usingExternal)

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

  1551. }

  1552. 

  1553. void PatchbayGraph::renamePlugin(CarlaPlugin* const plugin, const char* const newName)

  1554. {

  1555.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1556.     carla_debug("PatchbayGraph::renamePlugin(%p)", plugin, newName);

  1557. 

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

  1559.     CARLA_SAFE_ASSERT_RETURN(node != nullptr,);

  1560. 

  1561.     if (! usingExternal)

  1562.         kEngine->callback(ENGINE_CALLBACK_PATCHBAY_CLIENT_RENAMED, node->nodeId, 0, 0, 0.0f, newName);

  1563. }

  1564. 

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

  1566. {

  1567.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

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

  1569. 

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

  1571.     CARLA_SAFE_ASSERT_RETURN(node != nullptr,);

  1572. 

  1573.     if (! usingExternal)

  1574.     {

  1575.         disconnectInternalGroup(node->nodeId);

  1576.         removeNodeFromPatchbay(kEngine, node->nodeId, node->getProcessor());

  1577.     }

  1578. 

  1579.     ((CarlaPluginInstance*)node->getProcessor())->invalidatePlugin();

  1580. 

  1581.     // Fix plugin Ids properties

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

  1583.     {

  1584.         CarlaPlugin* const plugin2(kEngine->getPlugin(i));

  1585.         CARLA_SAFE_ASSERT_BREAK(plugin2 != nullptr);

  1586. 

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

  1588.         {

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

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

  1591.         }

  1592.     }

  1593. 

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

  1595. }

  1596. 

  1597. void PatchbayGraph::removeAllPlugins()

  1598. {

  1599.     carla_debug("PatchbayGraph::removeAllPlugins()");

  1600. 

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

  1602.     {

  1603.         CarlaPlugin* const plugin(kEngine->getPlugin(i));

  1604.         CARLA_SAFE_ASSERT_CONTINUE(plugin != nullptr);

  1605. 

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

  1607.         CARLA_SAFE_ASSERT_CONTINUE(node != nullptr);

  1608. 

  1609.         if (! usingExternal)

  1610.         {

  1611.             disconnectInternalGroup(node->nodeId);

  1612.             removeNodeFromPatchbay(kEngine, node->nodeId, node->getProcessor());

  1613.         }

  1614. 

  1615.         ((CarlaPluginInstance*)node->getProcessor())->invalidatePlugin();

  1616. 

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

  1618.     }

  1619. }

  1620. 

  1621. bool PatchbayGraph::connect(const bool external, const uint groupA, const uint portA, const uint groupB, const uint portB, const bool sendCallback)

  1622. {

  1623.     if (external)

  1624.         return extGraph.connect(groupA, portA, groupB, portB, sendCallback);

  1625. 

  1626.     uint adjustedPortA = portA;

  1627.     uint adjustedPortB = portB;

  1628. 

  1629.     if (! adjustPatchbayPortIdForJuce(adjustedPortA))

  1630.         return false;

  1631.     if (! adjustPatchbayPortIdForJuce(adjustedPortB))

  1632.         return false;

  1633. 

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

  1635.     {

  1636.         kEngine->setLastError("Failed from juce");

  1637.         return false;

  1638.     }

  1639. 

  1640.     ConnectionToId connectionToId;

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

  1642. 

  1643.     char strBuf[STR_MAX+1];

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

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

  1646. 

  1647.     if (sendCallback)

  1648.         kEngine->callback(ENGINE_CALLBACK_PATCHBAY_CONNECTION_ADDED, connectionToId.id, 0, 0, 0.0f, strBuf);

  1649. 

  1650.     connections.list.append(connectionToId);

  1651.     return true;

  1652. }

  1653. 

  1654. bool PatchbayGraph::disconnect(const uint connectionId)

  1655. {

  1656.     if (usingExternal)

  1657.         return extGraph.disconnect(connectionId);

  1658. 

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

  1660.     {

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

  1662. 

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

  1664.         CARLA_SAFE_ASSERT_CONTINUE(connectionToId.id > 0);

  1665. 

  1666.         if (connectionToId.id != connectionId)

  1667.             continue;

  1668. 

  1669.         uint adjustedPortA = connectionToId.portA;

  1670.         uint adjustedPortB = connectionToId.portB;

  1671. 

  1672.         if (! adjustPatchbayPortIdForJuce(adjustedPortA))

  1673.             return false;

  1674.         if (! adjustPatchbayPortIdForJuce(adjustedPortB))

  1675.             return false;

  1676. 

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

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

  1679.             return false;

  1680. 

  1681.         kEngine->callback(ENGINE_CALLBACK_PATCHBAY_CONNECTION_REMOVED, connectionToId.id, 0, 0, 0.0f, nullptr);

  1682. 

  1683.         connections.list.remove(it);

  1684.         return true;

  1685.     }

  1686. 

  1687.     kEngine->setLastError("Failed to find connection");

  1688.     return false;

  1689. }

  1690. 

  1691. void PatchbayGraph::disconnectInternalGroup(const uint groupId) noexcept

  1692. {

  1693.     CARLA_SAFE_ASSERT(! usingExternal);

  1694. 

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

  1696.     {

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

  1698. 

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

  1700.         CARLA_SAFE_ASSERT_CONTINUE(connectionToId.id > 0);

  1701. 

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

  1703.             continue;

  1704. 

  1705.         /*

  1706.         uint adjustedPortA = connectionToId.portA;

  1707.         uint adjustedPortB = connectionToId.portB;

  1708. 

  1709.         if (! adjustPatchbayPortIdForJuce(adjustedPortA))

  1710.             return false;

  1711.         if (! adjustPatchbayPortIdForJuce(adjustedPortB))

  1712.             return false;

  1713. 

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

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

  1716.         */

  1717. 

  1718.         if (! usingExternal)

  1719.             kEngine->callback(ENGINE_CALLBACK_PATCHBAY_CONNECTION_REMOVED, connectionToId.id, 0, 0, 0.0f, nullptr);

  1720. 

  1721.         connections.list.remove(it);

  1722.     }

  1723. }

  1724. 

  1725. void PatchbayGraph::refresh(const char* const deviceName)

  1726. {

  1727.     if (usingExternal)

  1728.         return extGraph.refresh(deviceName);

  1729. 

  1730.     CARLA_SAFE_ASSERT_RETURN(deviceName != nullptr,);

  1731. 

  1732.     connections.clear();

  1733.     graph.removeIllegalConnections();

  1734. 

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

  1736.     {

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

  1738.         CARLA_SAFE_ASSERT_CONTINUE(node != nullptr);

  1739. 

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

  1741.         CARLA_SAFE_ASSERT_CONTINUE(proc != nullptr);

  1742. 

  1743.         int clientId = -1;

  1744. 

  1745.         // plugin node

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

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

  1748. 

  1749.         addNodeToPatchbay(kEngine, node->nodeId, clientId, proc);

  1750.     }

  1751. 

  1752.     char strBuf[STR_MAX+1];

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

  1754. 

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

  1756.     {

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

  1758.         CARLA_SAFE_ASSERT_CONTINUE(conn != nullptr);

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

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

  1761. 

  1762.         const uint groupA = conn->sourceNodeId;

  1763.         const uint groupB = conn->destNodeId;

  1764. 

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

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

  1767. 

  1768.         if (portA == kMidiChannelIndex)

  1769.             portA  = kMidiOutputPortOffset;

  1770.         else

  1771.             portA += kAudioOutputPortOffset;

  1772. 

  1773.         if (portB == kMidiChannelIndex)

  1774.             portB  = kMidiInputPortOffset;

  1775.         else

  1776.             portB += kAudioInputPortOffset;

  1777. 

  1778.         ConnectionToId connectionToId;

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

  1780. 

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

  1782. 

  1783.         kEngine->callback(ENGINE_CALLBACK_PATCHBAY_CONNECTION_ADDED, connectionToId.id, 0, 0, 0.0f, strBuf);

  1784. 

  1785.         connections.list.append(connectionToId);

  1786.     }

  1787. }

  1788. 

  1789. const char* const* PatchbayGraph::getConnections(const bool external) const

  1790. {

  1791.     if (external)

  1792.         return extGraph.getConnections();

  1793. 

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

  1795.         return nullptr;

  1796. 

  1797.     CarlaStringList connList;

  1798. 

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

  1800.     {

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

  1802. 

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

  1804.         CARLA_SAFE_ASSERT_CONTINUE(connectionToId.id > 0);

  1805. 

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

  1807.         CARLA_SAFE_ASSERT_CONTINUE(nodeA != nullptr);

  1808. 

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

  1810.         CARLA_SAFE_ASSERT_CONTINUE(nodeB != nullptr);

  1811. 

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

  1813.         CARLA_SAFE_ASSERT_CONTINUE(procA != nullptr);

  1814. 

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

  1816.         CARLA_SAFE_ASSERT_CONTINUE(procB != nullptr);

  1817. 

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

  1819.         CARLA_SAFE_ASSERT_CONTINUE(fullPortNameA.isNotEmpty());

  1820. 

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

  1822.         CARLA_SAFE_ASSERT_CONTINUE(fullPortNameB.isNotEmpty());

  1823. 

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

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

  1826.     }

  1827. 

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

  1829.         return nullptr;

  1830. 

  1831.     retCon = connList.toCharStringListPtr();

  1832. 

  1833.     return retCon;

  1834. }

  1835. 

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

  1837. {

  1838.     if (external)

  1839.         return extGraph.getGroupAndPortIdFromFullName(fullPortName, groupId, portId);

  1840. 

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

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

  1843. 

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

  1845.     {

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

  1847.         CARLA_SAFE_ASSERT_CONTINUE(node != nullptr);

  1848. 

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

  1850.         CARLA_SAFE_ASSERT_CONTINUE(proc != nullptr);

  1851. 

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

  1853.             continue;

  1854. 

  1855.         groupId = node->nodeId;

  1856. 

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

  1858.         {

  1859.             portId = kMidiInputPortOffset;

  1860.             return true;

  1861.         }

  1862. 

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

  1864.         {

  1865.             portId = kMidiOutputPortOffset;

  1866.             return true;

  1867.         }

  1868. 

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

  1870.         {

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

  1872.                 continue;

  1873. 

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

  1875.             return true;

  1876.         }

  1877. 

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

  1879.         {

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

  1881.                 continue;

  1882. 

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

  1884.             return true;

  1885.         }

  1886.     }

  1887. 

  1888.     return false;

  1889. }

  1890. 

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

  1892. {

  1893.     CARLA_SAFE_ASSERT_RETURN(data != nullptr,);

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

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

  1896.     CARLA_SAFE_ASSERT_RETURN(frames > 0,);

  1897. 

  1898.     // put events in juce buffer

  1899.     {

  1900.         midiBuffer.clear();

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

  1902.     }

  1903. 

  1904.     // put carla audio in juce buffer

  1905.     {

  1906.         int i=0;

  1907. 

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

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

  1910. 

  1911.         // clear remaining channels

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

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

  1914.     }

  1915. 

  1916.     graph.processBlock(audioBuffer, midiBuffer);

  1917. 

  1918.     // put juce audio in carla buffer

  1919.     {

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

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

  1922.     }

  1923. 

  1924.     // put juce events in carla buffer

  1925.     {

  1926.         carla_zeroStructs(data->events.out, kMaxEngineEventInternalCount);

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

  1928.         midiBuffer.clear();

  1929.     }

  1930. }

  1931. 

  1932. // -----------------------------------------------------------------------

  1933. // InternalGraph

  1934. 

  1935. EngineInternalGraph::EngineInternalGraph(CarlaEngine* const engine) noexcept

  1936.     : fIsRack(true),

  1937.       fIsReady(false),

  1938.       kEngine(engine)

  1939. {

  1940.     fRack = nullptr;

  1941. }

  1942. 

  1943. EngineInternalGraph::~EngineInternalGraph() noexcept

  1944. {

  1945.     CARLA_SAFE_ASSERT(! fIsReady);

  1946.     CARLA_SAFE_ASSERT(fRack == nullptr);

  1947. }

  1948. 

  1949. void EngineInternalGraph::create(const uint32_t inputs, const uint32_t outputs)

  1950. {

  1951.     fIsRack = (kEngine->getOptions().processMode == ENGINE_PROCESS_MODE_CONTINUOUS_RACK);

  1952. 

  1953.     if (fIsRack)

  1954.     {

  1955.         CARLA_SAFE_ASSERT_RETURN(fRack == nullptr,);

  1956.         fRack = new RackGraph(kEngine, inputs, outputs);

  1957.     }

  1958.     else

  1959.     {

  1960.         CARLA_SAFE_ASSERT_RETURN(fPatchbay == nullptr,);

  1961.         fPatchbay = new PatchbayGraph(kEngine, inputs, outputs);

  1962.     }

  1963. 

  1964.     fIsReady = true;

  1965. }

  1966. 

  1967. void EngineInternalGraph::destroy() noexcept

  1968. {

  1969.     if (! fIsReady)

  1970.     {

  1971.         CARLA_SAFE_ASSERT(fRack == nullptr);

  1972.         return;

  1973.     }

  1974. 

  1975.     if (fIsRack)

  1976.     {

  1977.         CARLA_SAFE_ASSERT_RETURN(fRack != nullptr,);

  1978.         delete fRack;

  1979.         fRack = nullptr;

  1980.     }

  1981.     else

  1982.     {

  1983.         CARLA_SAFE_ASSERT_RETURN(fPatchbay != nullptr,);

  1984.         delete fPatchbay;

  1985.         fPatchbay = nullptr;

  1986.     }

  1987. 

  1988.     fIsReady = false;

  1989. }

  1990. 

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

  1992. {

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

  1994. 

  1995.     if (fIsRack)

  1996.     {

  1997.         CARLA_SAFE_ASSERT_RETURN(fRack != nullptr,);

  1998.         fRack->setBufferSize(bufferSize);

  1999.     }

  2000.     else

  2001.     {

  2002.         CARLA_SAFE_ASSERT_RETURN(fPatchbay != nullptr,);

  2003.         fPatchbay->setBufferSize(bufferSize);

  2004.     }

  2005. }

  2006. 

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

  2008. {

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

  2010. 

  2011.     if (fIsRack)

  2012.     {

  2013.         CARLA_SAFE_ASSERT_RETURN(fRack != nullptr,);

  2014.     }

  2015.     else

  2016.     {

  2017.         CARLA_SAFE_ASSERT_RETURN(fPatchbay != nullptr,);

  2018.         fPatchbay->setSampleRate(sampleRate);

  2019.     }

  2020. }

  2021. 

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

  2023. {

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

  2025. 

  2026.     if (fIsRack)

  2027.     {

  2028.         CARLA_SAFE_ASSERT_RETURN(fRack != nullptr,);

  2029.         fRack->setOffline(offline);

  2030.     }

  2031.     else

  2032.     {

  2033.         CARLA_SAFE_ASSERT_RETURN(fPatchbay != nullptr,);

  2034.         fPatchbay->setOffline(offline);

  2035.     }

  2036. }

  2037. 

  2038. bool EngineInternalGraph::isReady() const noexcept

  2039. {

  2040.     return fIsReady;

  2041. }

  2042. 

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

  2044. {

  2045.     CARLA_SAFE_ASSERT_RETURN(fIsRack, nullptr);

  2046. 

  2047.     return fRack;

  2048. }

  2049. 

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

  2051. {

  2052.     CARLA_SAFE_ASSERT_RETURN(! fIsRack, nullptr);

  2053. 

  2054.     return fPatchbay;

  2055. }

  2056. 

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

  2058. {

  2059.     if (fIsRack)

  2060.     {

  2061.         CARLA_SAFE_ASSERT_RETURN(fRack != nullptr,);

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

  2063.     }

  2064.     else

  2065.     {

  2066.         CARLA_SAFE_ASSERT_RETURN(fPatchbay != nullptr,);

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

  2068.     }

  2069. }

  2070. 

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

  2072. {

  2073.     CARLA_SAFE_ASSERT_RETURN(fIsRack,);

  2074.     CARLA_SAFE_ASSERT_RETURN(fRack != nullptr,);

  2075. 

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

  2077. }

  2078. 

  2079. // -----------------------------------------------------------------------

  2080. // used for internal patchbay mode

  2081. 

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

  2083. {

  2084.     CARLA_SAFE_ASSERT_RETURN(fPatchbay != nullptr,);

  2085.     fPatchbay->addPlugin(plugin);

  2086. }

  2087. 

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

  2089. {

  2090.     CARLA_SAFE_ASSERT_RETURN(fPatchbay != nullptr,);

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

  2092. }

  2093. 

  2094. void EngineInternalGraph::renamePlugin(CarlaPlugin* const plugin, const char* const newName)

  2095. {

  2096.     CARLA_SAFE_ASSERT_RETURN(fPatchbay != nullptr,);

  2097.     fPatchbay->renamePlugin(plugin, newName);

  2098. }

  2099. 

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

  2101. {

  2102.     CARLA_SAFE_ASSERT_RETURN(fPatchbay != nullptr,);

  2103.     fPatchbay->removePlugin(plugin);

  2104. }

  2105. 

  2106. void EngineInternalGraph::removeAllPlugins()

  2107. {

  2108.     CARLA_SAFE_ASSERT_RETURN(fPatchbay != nullptr,);

  2109.     fPatchbay->removeAllPlugins();

  2110. }

  2111. 

  2112. bool EngineInternalGraph::isUsingExternal() const noexcept

  2113. {

  2114.     if (fIsRack)

  2115.         return true;

  2116. 

  2117.     CARLA_SAFE_ASSERT_RETURN(fPatchbay != nullptr, false);

  2118.     return fPatchbay->usingExternal;

  2119. }

  2120. 

  2121. void EngineInternalGraph::setUsingExternal(const bool usingExternal) noexcept

  2122. {

  2123.     CARLA_SAFE_ASSERT_RETURN(fPatchbay != nullptr,);

  2124.     fPatchbay->usingExternal = usingExternal;

  2125. }

  2126. 

  2127. // -----------------------------------------------------------------------

  2128. // CarlaEngine Patchbay stuff

  2129. 

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

  2131. {

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

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

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

  2135. 

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

  2137.     {

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

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

  2140. 

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

  2142.     }

  2143.     else

  2144.     {

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

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

  2147. 

  2148.         return graph->connect(graph->usingExternal, groupA, portA, groupB, portB, true);

  2149.     }

  2150. 

  2151.     return false;

  2152. }

  2153. 

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

  2155. {

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

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

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

  2159. 

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

  2161.     {

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

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

  2164. 

  2165.         return graph->disconnect(connectionId);

  2166.     }

  2167.     else

  2168.     {

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

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

  2171. 

  2172.         return graph->disconnect(connectionId);

  2173.     }

  2174. 

  2175.     return false;

  2176. }

  2177. 

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

  2179. {

  2180.     // subclasses should handle this

  2181.     CARLA_SAFE_ASSERT_RETURN(! external, false);

  2182. 

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

  2184.     {

  2185.         // This is implemented in engine subclasses

  2186.         setLastError("Unsupported operation");

  2187.         return false;

  2188.     }

  2189. 

  2190.     if (pData->options.processMode == ENGINE_PROCESS_MODE_PATCHBAY)

  2191.     {

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

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

  2194. 

  2195.         graph->refresh("");

  2196.         return true;

  2197.     }

  2198. 

  2199.     setLastError("Unsupported operation");

  2200.     return false;

  2201. }

  2202. 

  2203. // -----------------------------------------------------------------------

  2204. 

  2205. const char* const* CarlaEngine::getPatchbayConnections(const bool external) const

  2206. {

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

  2208.     carla_debug("CarlaEngine::getPatchbayConnections(%s)", bool2str(external));

  2209. 

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

  2211.     {

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

  2213.         CARLA_SAFE_ASSERT_RETURN(graph != nullptr, nullptr);

  2214.         CARLA_SAFE_ASSERT_RETURN(external, nullptr);

  2215. 

  2216.         return graph->getConnections();

  2217.     }

  2218.     else

  2219.     {

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

  2221.         CARLA_SAFE_ASSERT_RETURN(graph != nullptr, nullptr);

  2222. 

  2223.         return graph->getConnections(external);

  2224.     }

  2225. 

  2226.     return nullptr;

  2227. }

  2228. 

  2229. void CarlaEngine::restorePatchbayConnection(const bool external, const char* const sourcePort, const char* const targetPort, const bool sendCallback)

  2230. {

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

  2232.     CARLA_SAFE_ASSERT_RETURN(sourcePort != nullptr && sourcePort[0] != '\0',);

  2233.     CARLA_SAFE_ASSERT_RETURN(targetPort != nullptr && targetPort[0] != '\0',);

  2234.     carla_debug("CarlaEngine::restorePatchbayConnection(%s, \"%s\", \"%s\")", bool2str(external), sourcePort, targetPort);

  2235. 

  2236.     uint groupA, portA;

  2237.     uint groupB, portB;

  2238. 

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

  2240.     {

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

  2242.         CARLA_SAFE_ASSERT_RETURN(graph != nullptr,);

  2243.         CARLA_SAFE_ASSERT_RETURN(external,);

  2244. 

  2245.         if (! graph->getGroupAndPortIdFromFullName(sourcePort, groupA, portA))

  2246.             return;

  2247.         if (! graph->getGroupAndPortIdFromFullName(targetPort, groupB, portB))

  2248.             return;

  2249. 

  2250.         graph->connect(groupA, portA, groupB, portB);

  2251.     }

  2252.     else

  2253.     {

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

  2255.         CARLA_SAFE_ASSERT_RETURN(graph != nullptr,);

  2256. 

  2257.         if (! graph->getGroupAndPortIdFromFullName(external, sourcePort, groupA, portA))

  2258.             return;

  2259.         if (! graph->getGroupAndPortIdFromFullName(external, targetPort, groupB, portB))

  2260.             return;

  2261. 

  2262.         graph->connect(external, groupA, portA, groupB, portB, sendCallback);

  2263.     }

  2264. }

  2265. 

  2266. // -----------------------------------------------------------------------

  2267. 

  2268. bool CarlaEngine::connectExternalGraphPort(const uint connectionType, const uint portId, const char* const portName)

  2269. {

  2270.     CARLA_SAFE_ASSERT_RETURN(connectionType != 0 || (portName != nullptr && portName[0] != '\0'), false);

  2271.     CARLA_SAFE_ASSERT_RETURN(pData->options.processMode == ENGINE_PROCESS_MODE_CONTINUOUS_RACK, false);

  2272. 

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

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

  2275. 

  2276.     const CarlaRecursiveMutexLocker cml(graph->audioBuffers.mutex);

  2277. 

  2278.     switch (connectionType)

  2279.     {

  2280.     case kExternalGraphConnectionAudioIn1:

  2281.         return graph->audioBuffers.connectedIn1.append(portId);

  2282.     case kExternalGraphConnectionAudioIn2:

  2283.         return graph->audioBuffers.connectedIn2.append(portId);

  2284.     case kExternalGraphConnectionAudioOut1:

  2285.         return graph->audioBuffers.connectedOut1.append(portId);

  2286.     case kExternalGraphConnectionAudioOut2:

  2287.         return graph->audioBuffers.connectedOut2.append(portId);

  2288.     }

  2289. 

  2290.     return false;

  2291. }

  2292. 

  2293. bool CarlaEngine::disconnectExternalGraphPort(const uint connectionType, const uint portId, const char* const portName)

  2294. {

  2295.     CARLA_SAFE_ASSERT_RETURN(connectionType != 0 || (portName != nullptr && portName[0] != '\0'), false);

  2296.     CARLA_SAFE_ASSERT_RETURN(pData->options.processMode == ENGINE_PROCESS_MODE_CONTINUOUS_RACK, false);

  2297. 

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

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

  2300. 

  2301.     const CarlaRecursiveMutexLocker cml(graph->audioBuffers.mutex);

  2302. 

  2303.     switch (connectionType)

  2304.     {

  2305.     case kExternalGraphConnectionAudioIn1:

  2306.         return graph->audioBuffers.connectedIn1.removeOne(portId);

  2307.     case kExternalGraphConnectionAudioIn2:

  2308.         return graph->audioBuffers.connectedIn2.removeOne(portId);

  2309.     case kExternalGraphConnectionAudioOut1:

  2310.         return graph->audioBuffers.connectedOut1.removeOne(portId);

  2311.     case kExternalGraphConnectionAudioOut2:

  2312.         return graph->audioBuffers.connectedOut2.removeOne(portId);

  2313.     }

  2314. 

  2315.     return false;

  2316. }

  2317. 

  2318. // -----------------------------------------------------------------------

  2319. 

  2320. CARLA_BACKEND_END_NAMESPACE

  2321. 

  2322. // enable -Wdeprecated-declarations again

  2323. #if defined(__clang__)

  2324. # pragma clang diagnostic pop

  2325. #elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))

  2326. # pragma GCC diagnostic pop

  2327. #endif

  2328. 

  2329. // -----------------------------------------------------------------------