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

1191 lines
42KB
Raw Blame History 

  1. /*

  2.  * Carla Plugin Host

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

  4.  *

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

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

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

  8.  * the License, or any later version.

  9.  *

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

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

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

  13.  * GNU General Public License for more details.

  14.  *

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

  16.  */

  17. 

  18. #include "CarlaEngineGraph.hpp"

  19. #include "CarlaEngineInternal.hpp"

  20. #include "CarlaPlugin.hpp"

  21. 

  22. #include "CarlaMathUtils.hpp"

  23. #include "CarlaMIDI.h"

  24. 

  25. using juce::AudioBuffer;

  26. using juce::FloatVectorOperations;

  27. using juce::MemoryBlock;

  28. using juce::String;

  29. using juce::StringArray;

  30. using juce::jmin;

  31. using juce::jmax;

  32. 

  33. CARLA_BACKEND_START_NAMESPACE

  34. 

  35. // -----------------------------------------------------------------------

  36. // Fallback data

  37. 

  38. static const PortNameToId kPortNameToIdFallback   = { 0, 0, { '\0' }, { '\0' } };

  39. static /* */ PortNameToId kPortNameToIdFallbackNC = { 0, 0, { '\0' }, { '\0' } };

  40. 

  41. // -----------------------------------------------------------------------

  42. // External Graph stuff

  43. 

  44. static inline

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

  46. {

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

  48.         return kExternalGraphCarlaPortAudioIn1;

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

  50.         return kExternalGraphCarlaPortAudioIn2;

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

  52.         return kExternalGraphCarlaPortAudioOut1;

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

  54.         return kExternalGraphCarlaPortAudioOut2;

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

  56.         return kExternalGraphCarlaPortMidiIn;

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

  58.         return kExternalGraphCarlaPortMidiOut;

  59. 

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

  61.     return kExternalGraphCarlaPortNull;

  62. }

  63. 

  64. static inline

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

  66. {

  67.     switch (portId)

  68.     {

  69.     case kExternalGraphCarlaPortAudioIn1:

  70.         return "Carla:AudioIn1";

  71.     case kExternalGraphCarlaPortAudioIn2:

  72.         return "Carla:AudioIn2";

  73.     case kExternalGraphCarlaPortAudioOut1:

  74.         return "Carla:AudioOut1";

  75.     case kExternalGraphCarlaPortAudioOut2:

  76.         return "Carla:AudioOut2";

  77.     case kExternalGraphCarlaPortMidiIn:

  78.         return "Carla:MidiIn";

  79.     case kExternalGraphCarlaPortMidiOut:

  80.         return "Carla:MidiOut";

  81.     //case kExternalGraphCarlaPortNull:

  82.     //case kExternalGraphCarlaPortMax:

  83.     //    break;

  84.     }

  85. 

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

  87.     return nullptr;

  88. }

  89. 

  90. // -----------------------------------------------------------------------

  91. 

  92. ExternalGraphPorts::ExternalGraphPorts() noexcept

  93.     : ins(),

  94.       outs() {}

  95. 

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

  97. {

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

  99.     {

  100.         const PortNameToId& portNameToId(it.getValue(kPortNameToIdFallback));

  101.         CARLA_SAFE_ASSERT_CONTINUE(portNameToId.group > 0);

  102. 

  103.         if (portNameToId.port == portId)

  104.             return portNameToId.name;

  105.     }

  106. 

  107.     return nullptr;

  108. }

  109. 

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

  111. {

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

  113.     {

  114.         const PortNameToId& portNameToId(it.getValue(kPortNameToIdFallback));

  115.         CARLA_SAFE_ASSERT_CONTINUE(portNameToId.group > 0);

  116. 

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

  118.         {

  119.             if (ok != nullptr)

  120.                 *ok = true;

  121.             return portNameToId.port;

  122.         }

  123.     }

  124. 

  125.     if (ok != nullptr)

  126.         *ok = false;

  127.     return 0;

  128. }

  129. 

  130. // -----------------------------------------------------------------------

  131. 

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

  133.     : connections(),

  134.       audioPorts(),

  135.       midiPorts(),

  136.       retCon(),

  137.       kEngine(engine) {}

  138. 

  139. void ExternalGraph::clear() noexcept

  140. {

  141.     connections.clear();

  142.     audioPorts.ins.clear();

  143.     audioPorts.outs.clear();

  144.     midiPorts.ins.clear();

  145.     midiPorts.outs.clear();

  146. }

  147. 

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

  149. {

  150.     uint otherGroup, otherPort, carlaPort;

  151. 

  152.     if (groupA == kExternalGraphGroupCarla)

  153.     {

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

  155. 

  156.         carlaPort  = portA;

  157.         otherGroup = groupB;

  158.         otherPort  = portB;

  159.     }

  160.     else

  161.     {

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

  163. 

  164.         carlaPort  = portB;

  165.         otherGroup = groupA;

  166.         otherPort  = portA;

  167.     }

  168. 

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

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

  171. 

  172.     bool makeConnection = false;

  173. 

  174.     switch (carlaPort)

  175.     {

  176.     case kExternalGraphCarlaPortAudioIn1:

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

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

  179.         break;

  180. 

  181.     case kExternalGraphCarlaPortAudioIn2:

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

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

  184.         break;

  185. 

  186.     case kExternalGraphCarlaPortAudioOut1:

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

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

  189.         break;

  190. 

  191.     case kExternalGraphCarlaPortAudioOut2:

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

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

  194.         break;

  195. 

  196.     case kExternalGraphCarlaPortMidiIn:

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

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

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

  200.         break;

  201. 

  202.     case kExternalGraphCarlaPortMidiOut:

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

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

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

  206.         break;

  207.     }

  208. 

  209.     if (! makeConnection)

  210.     {

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

  212.         return false;

  213.     }

  214. 

  215.     ConnectionToId connectionToId;

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

  217. 

  218.     char strBuf[STR_MAX+1];

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

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

  221. 

  222.     if (sendCallback)

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

  224. 

  225.     connections.list.append(connectionToId);

  226.     return true;

  227. }

  228. 

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

  230. {

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

  232. 

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

  234.     {

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

  236. 

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

  238.         CARLA_SAFE_ASSERT_CONTINUE(connectionToId.id > 0);

  239. 

  240.         if (connectionToId.id != connectionId)

  241.             continue;

  242. 

  243.         uint otherGroup, otherPort, carlaPort;

  244. 

  245.         if (connectionToId.groupA == kExternalGraphGroupCarla)

  246.         {

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

  248. 

  249.             carlaPort  = connectionToId.portA;

  250.             otherGroup = connectionToId.groupB;

  251.             otherPort  = connectionToId.portB;

  252.         }

  253.         else

  254.         {

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

  256. 

  257.             carlaPort  = connectionToId.portB;

  258.             otherGroup = connectionToId.groupA;

  259.             otherPort  = connectionToId.portA;

  260.         }

  261. 

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

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

  264. 

  265.         bool makeDisconnection = false;

  266. 

  267.         switch (carlaPort)

  268.         {

  269.         case kExternalGraphCarlaPortAudioIn1:

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

  271.             break;

  272. 

  273.         case kExternalGraphCarlaPortAudioIn2:

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

  275.             break;

  276. 

  277.         case kExternalGraphCarlaPortAudioOut1:

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

  279.             break;

  280. 

  281.         case kExternalGraphCarlaPortAudioOut2:

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

  283.             break;

  284. 

  285.         case kExternalGraphCarlaPortMidiIn:

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

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

  288.             break;

  289. 

  290.         case kExternalGraphCarlaPortMidiOut:

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

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

  293.             break;

  294.         }

  295. 

  296.         if (! makeDisconnection)

  297.         {

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

  299.             return false;

  300.         }

  301. 

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

  303. 

  304.         connections.list.remove(it);

  305.         return true;

  306.     }

  307. 

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

  309.     return false;

  310. }

  311. 

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

  313. {

  314.     CARLA_SAFE_ASSERT_RETURN(deviceName != nullptr,);

  315. 

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

  317. 

  318.     // Main

  319.     {

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

  321. 

  322.         if (isRack)

  323.         {

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

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

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

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

  328.         }

  329. 

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

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

  332.     }

  333. 

  334.     char strBuf[STR_MAX+1];

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

  336. 

  337.     if (isRack)

  338.     {

  339.         // Audio In

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

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

  342.         else

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

  344. 

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

  346. 

  347.         const CarlaString groupNameIn(strBuf);

  348. 

  349.         int h = 0;

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

  351.         {

  352.             PortNameToId& portNameToId(it.getValue(kPortNameToIdFallbackNC));

  353.             CARLA_SAFE_ASSERT_CONTINUE(portNameToId.group > 0);

  354. 

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

  356. 

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

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

  359.         }

  360. 

  361.         // Audio Out

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

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

  364.         else

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

  366. 

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

  368. 

  369.         const CarlaString groupNameOut(strBuf);

  370. 

  371.         h = 0;

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

  373.         {

  374.             PortNameToId& portNameToId(it.getValue(kPortNameToIdFallbackNC));

  375.             CARLA_SAFE_ASSERT_CONTINUE(portNameToId.group > 0);

  376. 

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

  378. 

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

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

  381.         }

  382.     }

  383. 

  384.     // MIDI In

  385.     {

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

  387. 

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

  389. 

  390.         int h = 0;

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

  392.         {

  393.             PortNameToId& portNameToId(it.getValue(kPortNameToIdFallbackNC));

  394.             CARLA_SAFE_ASSERT_CONTINUE(portNameToId.group > 0);

  395. 

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

  397. 

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

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

  400.         }

  401.     }

  402. 

  403.     // MIDI Out

  404.     {

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

  406. 

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

  408. 

  409.         int h = 0;

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

  411.         {

  412.             PortNameToId& portNameToId(it.getValue(kPortNameToIdFallbackNC));

  413.             CARLA_SAFE_ASSERT_CONTINUE(portNameToId.group > 0);

  414. 

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

  416. 

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

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

  419.         }

  420.     }

  421. }

  422. 

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

  424. {

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

  426.         return nullptr;

  427. 

  428.     CarlaStringList connList;

  429. 

  430.     char strBuf[STR_MAX+1];

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

  432. 

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

  434.     {

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

  436. 

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

  438.         CARLA_SAFE_ASSERT_CONTINUE(connectionToId.id > 0);

  439. 

  440.         uint otherGroup, otherPort, carlaPort;

  441. 

  442.         if (connectionToId.groupA == kExternalGraphGroupCarla)

  443.         {

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

  445. 

  446.             carlaPort  = connectionToId.portA;

  447.             otherGroup = connectionToId.groupB;

  448.             otherPort  = connectionToId.portB;

  449.         }

  450.         else

  451.         {

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

  453. 

  454.             carlaPort  = connectionToId.portB;

  455.             otherGroup = connectionToId.groupA;

  456.             otherPort  = connectionToId.portA;

  457.         }

  458. 

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

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

  461. 

  462.         switch (carlaPort)

  463.         {

  464.         case kExternalGraphCarlaPortAudioIn1:

  465.         case kExternalGraphCarlaPortAudioIn2:

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

  467.             connList.append(strBuf);

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

  469.             break;

  470. 

  471.         case kExternalGraphCarlaPortAudioOut1:

  472.         case kExternalGraphCarlaPortAudioOut2:

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

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

  475.             connList.append(strBuf);

  476.             break;

  477. 

  478.         case kExternalGraphCarlaPortMidiIn:

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

  480.             connList.append(strBuf);

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

  482.             break;

  483. 

  484.         case kExternalGraphCarlaPortMidiOut:

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

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

  487.             connList.append(strBuf);

  488.             break;

  489.         }

  490.     }

  491. 

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

  493.         return nullptr;

  494. 

  495.     retCon = connList.toCharStringListPtr();

  496. 

  497.     return retCon;

  498. }

  499. 

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

  501. {

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

  503. 

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

  505.     {

  506.         groupId = kExternalGraphGroupCarla;

  507.         portId  = getExternalGraphPortIdFromName(fullPortName+6);

  508. 

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

  510.             return true;

  511.     }

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

  513.     {

  514.         groupId = kExternalGraphGroupAudioIn;

  515. 

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

  517.         {

  518.             bool ok;

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

  520.             return ok;

  521.         }

  522.     }

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

  524.     {

  525.         groupId = kExternalGraphGroupAudioOut;

  526. 

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

  528.         {

  529.             bool ok;

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

  531.             return ok;

  532.         }

  533.     }

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

  535.     {

  536.         groupId = kExternalGraphGroupMidiIn;

  537. 

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

  539.         {

  540.             bool ok;

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

  542.             return ok;

  543.         }

  544.     }

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

  546.     {

  547.         groupId = kExternalGraphGroupMidiOut;

  548. 

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

  550.         {

  551.             bool ok;

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

  553.             return ok;

  554.         }

  555.     }

  556. 

  557.     return false;

  558. }

  559. 

  560. // -----------------------------------------------------------------------

  561. // RackGraph Buffers

  562. 

  563. RackGraph::Buffers::Buffers() noexcept

  564.     : mutex(),

  565.       connectedIn1(),

  566.       connectedIn2(),

  567.       connectedOut1(),

  568.       connectedOut2()

  569. #ifdef CARLA_PROPER_CPP11_SUPPORT

  570.     , inBuf{nullptr, nullptr},

  571.       inBufTmp{nullptr, nullptr},

  572.       outBuf{nullptr, nullptr} {}

  573. #else

  574.     {

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

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

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

  578.     }

  579. #endif

  580. 

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

  582. {

  583.     const CarlaRecursiveMutexLocker cml(mutex);

  584. 

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

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

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

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

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

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

  591. 

  592.     connectedIn1.clear();

  593.     connectedIn2.clear();

  594.     connectedOut1.clear();

  595.     connectedOut2.clear();

  596. }

  597. 

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

  599. {

  600.     const CarlaRecursiveMutexLocker cml(mutex);

  601. 

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

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

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

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

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

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

  608. 

  609.     CARLA_SAFE_ASSERT_RETURN(bufferSize > 0,);

  610. 

  611.     try {

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

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

  614. 

  615.         if (createBuffers)

  616.         {

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

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

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

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

  621.         }

  622.     }

  623.     catch(...) {

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

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

  626. 

  627.         if (createBuffers)

  628.         {

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

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

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

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

  633.         }

  634.         return;

  635.     }

  636. 

  637.     carla_zeroFloats(inBufTmp[0], bufferSize);

  638.     carla_zeroFloats(inBufTmp[1], bufferSize);

  639. 

  640.     if (createBuffers)

  641.     {

  642.         carla_zeroFloats(inBuf[0],  bufferSize);

  643.         carla_zeroFloats(inBuf[1],  bufferSize);

  644.         carla_zeroFloats(outBuf[0], bufferSize);

  645.         carla_zeroFloats(outBuf[1], bufferSize);

  646.     }

  647. }

  648. 

  649. // -----------------------------------------------------------------------

  650. // RackGraph

  651. 

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

  653.     : extGraph(engine),

  654.       inputs(ins),

  655.       outputs(outs),

  656.       isOffline(false),

  657.       audioBuffers(),

  658.       kEngine(engine)

  659. {

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

  661. }

  662. 

  663. RackGraph::~RackGraph() noexcept

  664. {

  665.     extGraph.clear();

  666. }

  667. 

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

  669. {

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

  671. }

  672. 

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

  674. {

  675.     isOffline = offline;

  676. }

  677. 

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

  679. {

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

  681. }

  682. 

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

  684. {

  685.     return extGraph.disconnect(connectionId);

  686. }

  687. 

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

  689. {

  690.     extGraph.refresh(deviceName);

  691. 

  692.     char strBuf[STR_MAX+1];

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

  694. 

  695.     // Connections

  696.     const CarlaRecursiveMutexLocker cml(audioBuffers.mutex);

  697. 

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

  699.     {

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

  701.         CARLA_SAFE_ASSERT_CONTINUE(portId > 0);

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

  703. 

  704.         ConnectionToId connectionToId;

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

  706. 

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

  708. 

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

  710. 

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

  712.     }

  713. 

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

  715.     {

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

  717.         CARLA_SAFE_ASSERT_CONTINUE(portId > 0);

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

  719. 

  720.         ConnectionToId connectionToId;

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

  722. 

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

  724. 

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

  726. 

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

  728.     }

  729. 

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

  731.     {

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

  733.         CARLA_SAFE_ASSERT_CONTINUE(portId > 0);

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

  735. 

  736.         ConnectionToId connectionToId;

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

  738. 

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

  740. 

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

  742. 

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

  744.     }

  745. 

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

  747.     {

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

  749.         CARLA_SAFE_ASSERT_CONTINUE(portId > 0);

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

  751. 

  752.         ConnectionToId connectionToId;

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

  754. 

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

  756. 

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

  758. 

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

  760.     }

  761. }

  762. 

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

  764. {

  765.     return extGraph.getConnections();

  766. }

  767. 

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

  769. {

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

  771. }

  772. 

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

  774. {

  775.     CARLA_SAFE_ASSERT_RETURN(data != nullptr,);

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

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

  778. 

  779.     // safe copy

  780.     float inBuf0[frames];

  781.     float inBuf1[frames];

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

  783. 

  784.     // initialize audio inputs

  785.     carla_copyFloats(inBuf0, inBufReal[0], frames);

  786.     carla_copyFloats(inBuf1, inBufReal[1], frames);

  787. 

  788.     // initialize audio outputs (zero)

  789.     carla_zeroFloats(outBuf[0], frames);

  790.     carla_zeroFloats(outBuf[1], frames);

  791. 

  792.     // initialize event outputs (zero)

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

  794. 

  795.     uint32_t oldAudioInCount  = 0;

  796.     uint32_t oldAudioOutCount = 0;

  797.     uint32_t oldMidiOutCount  = 0;

  798.     bool processed = false;

  799.     juce::Range<float> range;

  800. 

  801.     // process plugins

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

  803.     {

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

  805. 

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

  807.             continue;

  808. 

  809.         if (processed)

  810.         {

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

  812.             carla_copyFloats(inBuf0, outBuf[0], frames);

  813.             carla_copyFloats(inBuf1, outBuf[1], frames);

  814. 

  815.             // initialize audio outputs (zero)

  816.             carla_zeroFloats(outBuf[0], frames);

  817.             carla_zeroFloats(outBuf[1], frames);

  818. 

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

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

  821.             {

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

  823.                 {

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

  825.                 }

  826.                 // else nothing needed

  827.             }

  828.             else

  829.             {

  830.                 // initialize event inputs from previous outputs

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

  832. 

  833.                 // initialize event outputs (zero)

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

  835.             }

  836.         }

  837. 

  838.         oldAudioInCount  = plugin->getAudioInCount();

  839.         oldAudioOutCount = plugin->getAudioOutCount();

  840.         oldMidiOutCount  = plugin->getMidiOutCount();

  841. 

  842.         // process

  843.         plugin->initBuffers();

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

  845.         plugin->unlock();

  846. 

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

  848.         if (oldAudioInCount == 0)

  849.         {

  850.             carla_addFloats(outBuf[0], inBuf0, frames);

  851.             carla_addFloats(outBuf[1], inBuf1, frames);

  852.         }

  853. 

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

  855.         if (oldAudioOutCount == 1)

  856.         {

  857.             carla_copyFloats(outBuf[1], outBuf[0], frames);

  858.         }

  859. 

  860.         // set peaks

  861.         {

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

  863. 

  864.             if (oldAudioInCount > 0)

  865.             {

  866.                 range = FloatVectorOperations::findMinAndMax(inBuf0, frames);

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

  868. 

  869.                 range = FloatVectorOperations::findMinAndMax(inBuf1, frames);

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

  871.             }

  872.             else

  873.             {

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

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

  876.             }

  877. 

  878.             if (oldAudioOutCount > 0)

  879.             {

  880.                 range = FloatVectorOperations::findMinAndMax(outBuf[0], frames);

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

  882. 

  883.                 range = FloatVectorOperations::findMinAndMax(outBuf[1], frames);

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

  885.             }

  886.             else

  887.             {

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

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

  890.             }

  891.         }

  892. 

  893.         processed = true;

  894.     }

  895. }

  896. 

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

  898. {

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

  900. 

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

  902. 

  903.     const CarlaRecursiveMutexLocker _cml(audioBuffers.mutex);

  904. 

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

  906.     {

  907.         bool noConnections = true;

  908. 

  909.         // connect input buffers

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

  911.         {

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

  913.             CARLA_SAFE_ASSERT_CONTINUE(port > 0);

  914.             CARLA_SAFE_ASSERT_CONTINUE(port <= inputs);

  915. 

  916.             if (noConnections)

  917.             {

  918.                 carla_copyFloats(audioBuffers.inBuf[0], inBuf[port], frames);

  919.                 noConnections = false;

  920.             }

  921.             else

  922.             {

  923.                 carla_addFloats(audioBuffers.inBuf[0], inBuf[port], frames);

  924.             }

  925.         }

  926. 

  927.         if (noConnections)

  928.             carla_zeroFloats(audioBuffers.inBuf[0], iframes);

  929. 

  930.         noConnections = true;

  931. 

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

  933.         {

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

  935.             CARLA_SAFE_ASSERT_CONTINUE(port > 0);

  936.             CARLA_SAFE_ASSERT_CONTINUE(port <= inputs);

  937. 

  938.             if (noConnections)

  939.             {

  940.                 carla_copyFloats(audioBuffers.inBuf[1], inBuf[port-1], frames);

  941.                 noConnections = false;

  942.             }

  943.             else

  944.             {

  945.                 carla_addFloats(audioBuffers.inBuf[1], inBuf[port-1], frames);

  946.             }

  947.         }

  948. 

  949.         if (noConnections)

  950.             carla_zeroFloats(audioBuffers.inBuf[1], frames);

  951.     }

  952.     else

  953.     {

  954.         carla_zeroFloats(audioBuffers.inBuf[0], frames);

  955.         carla_zeroFloats(audioBuffers.inBuf[1], frames);

  956.     }

  957. 

  958.     carla_zeroFloats(audioBuffers.outBuf[0], frames);

  959.     carla_zeroFloats(audioBuffers.outBuf[1], frames);

  960. 

  961.     // process

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

  963. 

  964.     // connect output buffers

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

  966.     {

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

  968.         {

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

  970.             CARLA_SAFE_ASSERT_CONTINUE(port > 0);

  971.             CARLA_SAFE_ASSERT_CONTINUE(port <= outputs);

  972. 

  973.             carla_addFloats(outBuf[port-1], audioBuffers.outBuf[0], frames);

  974.         }

  975.     }

  976. 

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

  978.     {

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

  980.         {

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

  982.             CARLA_SAFE_ASSERT_CONTINUE(port > 0);

  983.             CARLA_SAFE_ASSERT_CONTINUE(port <= outputs);

  984. 

  985.             carla_addFloats(outBuf[port-1], audioBuffers.outBuf[1], frames);

  986.         }

  987.     }

  988. }

  989. 

  990. // -----------------------------------------------------------------------

  991. // InternalGraph

  992. 

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

  994.     : fIsReady(false),

  995.       kEngine(engine)

  996. {

  997.     fRack = nullptr;

  998. }

  999. 

  1000. EngineInternalGraph::~EngineInternalGraph() noexcept

  1001. {

  1002.     CARLA_SAFE_ASSERT(! fIsReady);

  1003.     CARLA_SAFE_ASSERT(fRack == nullptr);

  1004. }

  1005. 

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

  1007. {

  1008.     CARLA_SAFE_ASSERT_RETURN(fRack == nullptr,);

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

  1010.     fIsReady = true;

  1011. }

  1012. 

  1013. void EngineInternalGraph::destroy() noexcept

  1014. {

  1015.     if (! fIsReady)

  1016.     {

  1017.         CARLA_SAFE_ASSERT(fRack == nullptr);

  1018.         return;

  1019.     }

  1020. 

  1021.     CARLA_SAFE_ASSERT_RETURN(fRack != nullptr,);

  1022.     delete fRack;

  1023.     fRack = nullptr;

  1024. 

  1025.     fIsReady = false;

  1026. }

  1027. 

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

  1029. {

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

  1031. 

  1032.     CARLA_SAFE_ASSERT_RETURN(fRack != nullptr,);

  1033.     fRack->setBufferSize(bufferSize);

  1034. }

  1035. 

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

  1037. {

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

  1039. 

  1040.     CARLA_SAFE_ASSERT_RETURN(fRack != nullptr,);

  1041.     fRack->setOffline(offline);

  1042. }

  1043. 

  1044. bool EngineInternalGraph::isReady() const noexcept

  1045. {

  1046.     return fIsReady;

  1047. }

  1048. 

  1049. RackGraph* EngineInternalGraph::getGraph() const noexcept

  1050. {

  1051.     return fRack;

  1052. }

  1053. 

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

  1055. {

  1056.     CARLA_SAFE_ASSERT_RETURN(fRack != nullptr,);

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

  1058. }

  1059. 

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

  1061. {

  1062.     CARLA_SAFE_ASSERT_RETURN(fRack != nullptr,);

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

  1064. }

  1065. 

  1066. // -----------------------------------------------------------------------

  1067. // CarlaEngine Patchbay stuff

  1068. 

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

  1070. {

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

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

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

  1074. 

  1075.     RackGraph* const graph = pData->graph.getGraph();

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

  1077. 

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

  1079. }

  1080. 

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

  1082. {

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

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

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

  1086. 

  1087.     RackGraph* const graph = pData->graph.getGraph();

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

  1089. 

  1090.     return graph->disconnect(connectionId);

  1091. }

  1092. 

  1093. bool CarlaEngine::patchbayRefresh()

  1094. {

  1095.     // This is implemented in engine subclasses

  1096.     setLastError("Unsupported operation");

  1097.     return false;

  1098. }

  1099. 

  1100. // -----------------------------------------------------------------------

  1101. 

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

  1103. {

  1104.     CARLA_SAFE_ASSERT_RETURN(pData->options.processMode == ENGINE_PROCESS_MODE_CONTINUOUS_RACK, nullptr);

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

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

  1107. 

  1108.     RackGraph* const graph = pData->graph.getGraph();

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

  1110. 

  1111.     return graph->getConnections();

  1112. }

  1113. 

  1114. void CarlaEngine::restorePatchbayConnection(const char* const sourcePort, const char* const targetPort)

  1115. {

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

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

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

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

  1120.     carla_debug("CarlaEngine::restorePatchbayConnection(\"%s\", \"%s\")", sourcePort, targetPort);

  1121. 

  1122.     uint groupA, portA;

  1123.     uint groupB, portB;

  1124. 

  1125.     RackGraph* const graph = pData->graph.getGraph();

  1126.     CARLA_SAFE_ASSERT_RETURN(graph != nullptr,);

  1127. 

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

  1129.         return;

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

  1131.         return;

  1132. 

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

  1134. }

  1135. 

  1136. // -----------------------------------------------------------------------

  1137. 

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

  1139. {

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

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

  1142. 

  1143.     RackGraph* const graph(pData->graph.getGraph());

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

  1145. 

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

  1147. 

  1148.     switch (connectionType)

  1149.     {

  1150.     case kExternalGraphConnectionAudioIn1:

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

  1152.     case kExternalGraphConnectionAudioIn2:

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

  1154.     case kExternalGraphConnectionAudioOut1:

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

  1156.     case kExternalGraphConnectionAudioOut2:

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

  1158.     }

  1159. 

  1160.     return false;

  1161. }

  1162. 

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

  1164. {

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

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

  1167. 

  1168.     RackGraph* const graph(pData->graph.getGraph());

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

  1170. 

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

  1172. 

  1173.     switch (connectionType)

  1174.     {

  1175.     case kExternalGraphConnectionAudioIn1:

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

  1177.     case kExternalGraphConnectionAudioIn2:

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

  1179.     case kExternalGraphConnectionAudioOut1:

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

  1181.     case kExternalGraphConnectionAudioOut2:

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

  1183.     }

  1184. 

  1185.     return false;

  1186. }

  1187. 

  1188. // -----------------------------------------------------------------------

  1189. 

  1190. CARLA_BACKEND_END_NAMESPACE