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.
3677 Commits
16 Branches
154MB
Tree: 0fc5553a49
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '0fc5553a49'
${ noResults }
Carla/source/backend/engine/CarlaEngineGraph.cpp

1172 lines
41KB
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. CARLA_BACKEND_START_NAMESPACE

  26. 

  27. // -----------------------------------------------------------------------

  28. // Fallback data

  29. 

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

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

  32. 

  33. // -----------------------------------------------------------------------

  34. // External Graph stuff

  35. 

  36. static inline

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

  38. {

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

  40.         return kExternalGraphCarlaPortAudioIn1;

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

  42.         return kExternalGraphCarlaPortAudioIn2;

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

  44.         return kExternalGraphCarlaPortAudioOut1;

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

  46.         return kExternalGraphCarlaPortAudioOut2;

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

  48.         return kExternalGraphCarlaPortMidiIn;

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

  50.         return kExternalGraphCarlaPortMidiOut;

  51. 

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

  53.     return kExternalGraphCarlaPortNull;

  54. }

  55. 

  56. static inline

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

  58. {

  59.     switch (portId)

  60.     {

  61.     case kExternalGraphCarlaPortAudioIn1:

  62.         return "Carla:AudioIn1";

  63.     case kExternalGraphCarlaPortAudioIn2:

  64.         return "Carla:AudioIn2";

  65.     case kExternalGraphCarlaPortAudioOut1:

  66.         return "Carla:AudioOut1";

  67.     case kExternalGraphCarlaPortAudioOut2:

  68.         return "Carla:AudioOut2";

  69.     case kExternalGraphCarlaPortMidiIn:

  70.         return "Carla:MidiIn";

  71.     case kExternalGraphCarlaPortMidiOut:

  72.         return "Carla:MidiOut";

  73.     //case kExternalGraphCarlaPortNull:

  74.     //case kExternalGraphCarlaPortMax:

  75.     //    break;

  76.     }

  77. 

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

  79.     return nullptr;

  80. }

  81. 

  82. // -----------------------------------------------------------------------

  83. 

  84. ExternalGraphPorts::ExternalGraphPorts() noexcept

  85.     : ins(),

  86.       outs() {}

  87. 

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

  89. {

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

  91.     {

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

  93.         CARLA_SAFE_ASSERT_CONTINUE(portNameToId.group > 0);

  94. 

  95.         if (portNameToId.port == portId)

  96.             return portNameToId.name;

  97.     }

  98. 

  99.     return nullptr;

  100. }

  101. 

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

  103. {

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

  105.     {

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

  107.         CARLA_SAFE_ASSERT_CONTINUE(portNameToId.group > 0);

  108. 

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

  110.         {

  111.             if (ok != nullptr)

  112.                 *ok = true;

  113.             return portNameToId.port;

  114.         }

  115.     }

  116. 

  117.     if (ok != nullptr)

  118.         *ok = false;

  119.     return 0;

  120. }

  121. 

  122. // -----------------------------------------------------------------------

  123. 

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

  125.     : connections(),

  126.       audioPorts(),

  127.       midiPorts(),

  128.       retCon(),

  129.       kEngine(engine) {}

  130. 

  131. void ExternalGraph::clear() noexcept

  132. {

  133.     connections.clear();

  134.     audioPorts.ins.clear();

  135.     audioPorts.outs.clear();

  136.     midiPorts.ins.clear();

  137.     midiPorts.outs.clear();

  138. }

  139. 

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

  141. {

  142.     uint otherGroup, otherPort, carlaPort;

  143. 

  144.     if (groupA == kExternalGraphGroupCarla)

  145.     {

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

  147. 

  148.         carlaPort  = portA;

  149.         otherGroup = groupB;

  150.         otherPort  = portB;

  151.     }

  152.     else

  153.     {

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

  155. 

  156.         carlaPort  = portB;

  157.         otherGroup = groupA;

  158.         otherPort  = portA;

  159.     }

  160. 

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

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

  163. 

  164.     bool makeConnection = false;

  165. 

  166.     switch (carlaPort)

  167.     {

  168.     case kExternalGraphCarlaPortAudioIn1:

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

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

  171.         break;

  172. 

  173.     case kExternalGraphCarlaPortAudioIn2:

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

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

  176.         break;

  177. 

  178.     case kExternalGraphCarlaPortAudioOut1:

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

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

  181.         break;

  182. 

  183.     case kExternalGraphCarlaPortAudioOut2:

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

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

  186.         break;

  187. 

  188.     case kExternalGraphCarlaPortMidiIn:

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

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

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

  192.         break;

  193. 

  194.     case kExternalGraphCarlaPortMidiOut:

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

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

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

  198.         break;

  199.     }

  200. 

  201.     if (! makeConnection)

  202.     {

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

  204.         return false;

  205.     }

  206. 

  207.     ConnectionToId connectionToId;

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

  209. 

  210.     char strBuf[STR_MAX+1];

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

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

  213. 

  214.     if (sendCallback)

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

  216. 

  217.     connections.list.append(connectionToId);

  218.     return true;

  219. }

  220. 

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

  222. {

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

  224. 

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

  226.     {

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

  228. 

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

  230.         CARLA_SAFE_ASSERT_CONTINUE(connectionToId.id > 0);

  231. 

  232.         if (connectionToId.id != connectionId)

  233.             continue;

  234. 

  235.         uint otherGroup, otherPort, carlaPort;

  236. 

  237.         if (connectionToId.groupA == kExternalGraphGroupCarla)

  238.         {

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

  240. 

  241.             carlaPort  = connectionToId.portA;

  242.             otherGroup = connectionToId.groupB;

  243.             otherPort  = connectionToId.portB;

  244.         }

  245.         else

  246.         {

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

  248. 

  249.             carlaPort  = connectionToId.portB;

  250.             otherGroup = connectionToId.groupA;

  251.             otherPort  = connectionToId.portA;

  252.         }

  253. 

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

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

  256. 

  257.         bool makeDisconnection = false;

  258. 

  259.         switch (carlaPort)

  260.         {

  261.         case kExternalGraphCarlaPortAudioIn1:

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

  263.             break;

  264. 

  265.         case kExternalGraphCarlaPortAudioIn2:

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

  267.             break;

  268. 

  269.         case kExternalGraphCarlaPortAudioOut1:

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

  271.             break;

  272. 

  273.         case kExternalGraphCarlaPortAudioOut2:

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

  275.             break;

  276. 

  277.         case kExternalGraphCarlaPortMidiIn:

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

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

  280.             break;

  281. 

  282.         case kExternalGraphCarlaPortMidiOut:

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

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

  285.             break;

  286.         }

  287. 

  288.         if (! makeDisconnection)

  289.         {

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

  291.             return false;

  292.         }

  293. 

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

  295. 

  296.         connections.list.remove(it);

  297.         return true;

  298.     }

  299. 

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

  301.     return false;

  302. }

  303. 

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

  305. {

  306.     CARLA_SAFE_ASSERT_RETURN(deviceName != nullptr,);

  307. 

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

  309. 

  310.     // Main

  311.     {

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

  313. 

  314.         if (isRack)

  315.         {

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

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

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

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

  320.         }

  321. 

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

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

  324.     }

  325. 

  326.     char strBuf[STR_MAX+1];

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

  328. 

  329.     if (isRack)

  330.     {

  331.         // Audio In

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

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

  334.         else

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

  336. 

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

  338. 

  339.         const CarlaString groupNameIn(strBuf);

  340. 

  341.         int h = 0;

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

  343.         {

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

  345.             CARLA_SAFE_ASSERT_CONTINUE(portNameToId.group > 0);

  346. 

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

  348. 

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

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

  351.         }

  352. 

  353.         // Audio Out

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

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

  356.         else

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

  358. 

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

  360. 

  361.         const CarlaString groupNameOut(strBuf);

  362. 

  363.         h = 0;

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

  365.         {

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

  367.             CARLA_SAFE_ASSERT_CONTINUE(portNameToId.group > 0);

  368. 

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

  370. 

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

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

  373.         }

  374.     }

  375. 

  376.     // MIDI In

  377.     {

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

  379. 

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

  381. 

  382.         int h = 0;

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

  384.         {

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

  386.             CARLA_SAFE_ASSERT_CONTINUE(portNameToId.group > 0);

  387. 

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

  389. 

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

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

  392.         }

  393.     }

  394. 

  395.     // MIDI Out

  396.     {

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

  398. 

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

  400. 

  401.         int h = 0;

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

  403.         {

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

  405.             CARLA_SAFE_ASSERT_CONTINUE(portNameToId.group > 0);

  406. 

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

  408. 

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

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

  411.         }

  412.     }

  413. }

  414. 

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

  416. {

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

  418.         return nullptr;

  419. 

  420.     CarlaStringList connList;

  421. 

  422.     char strBuf[STR_MAX+1];

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

  424. 

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

  426.     {

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

  428. 

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

  430.         CARLA_SAFE_ASSERT_CONTINUE(connectionToId.id > 0);

  431. 

  432.         uint otherGroup, otherPort, carlaPort;

  433. 

  434.         if (connectionToId.groupA == kExternalGraphGroupCarla)

  435.         {

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

  437. 

  438.             carlaPort  = connectionToId.portA;

  439.             otherGroup = connectionToId.groupB;

  440.             otherPort  = connectionToId.portB;

  441.         }

  442.         else

  443.         {

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

  445. 

  446.             carlaPort  = connectionToId.portB;

  447.             otherGroup = connectionToId.groupA;

  448.             otherPort  = connectionToId.portA;

  449.         }

  450. 

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

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

  453. 

  454.         switch (carlaPort)

  455.         {

  456.         case kExternalGraphCarlaPortAudioIn1:

  457.         case kExternalGraphCarlaPortAudioIn2:

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

  459.             connList.append(strBuf);

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

  461.             break;

  462. 

  463.         case kExternalGraphCarlaPortAudioOut1:

  464.         case kExternalGraphCarlaPortAudioOut2:

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

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

  467.             connList.append(strBuf);

  468.             break;

  469. 

  470.         case kExternalGraphCarlaPortMidiIn:

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

  472.             connList.append(strBuf);

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

  474.             break;

  475. 

  476.         case kExternalGraphCarlaPortMidiOut:

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

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

  479.             connList.append(strBuf);

  480.             break;

  481.         }

  482.     }

  483. 

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

  485.         return nullptr;

  486. 

  487.     retCon = connList.toCharStringListPtr();

  488. 

  489.     return retCon;

  490. }

  491. 

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

  493. {

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

  495. 

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

  497.     {

  498.         groupId = kExternalGraphGroupCarla;

  499.         portId  = getExternalGraphPortIdFromName(fullPortName+6);

  500. 

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

  502.             return true;

  503.     }

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

  505.     {

  506.         groupId = kExternalGraphGroupAudioIn;

  507. 

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

  509.         {

  510.             bool ok;

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

  512.             return ok;

  513.         }

  514.     }

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

  516.     {

  517.         groupId = kExternalGraphGroupAudioOut;

  518. 

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

  520.         {

  521.             bool ok;

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

  523.             return ok;

  524.         }

  525.     }

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

  527.     {

  528.         groupId = kExternalGraphGroupMidiIn;

  529. 

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

  531.         {

  532.             bool ok;

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

  534.             return ok;

  535.         }

  536.     }

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

  538.     {

  539.         groupId = kExternalGraphGroupMidiOut;

  540. 

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

  542.         {

  543.             bool ok;

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

  545.             return ok;

  546.         }

  547.     }

  548. 

  549.     return false;

  550. }

  551. 

  552. // -----------------------------------------------------------------------

  553. // RackGraph Buffers

  554. 

  555. RackGraph::Buffers::Buffers() noexcept

  556.     : mutex(),

  557.       connectedIn1(),

  558.       connectedIn2(),

  559.       connectedOut1(),

  560.       connectedOut2()

  561. #ifdef CARLA_PROPER_CPP11_SUPPORT

  562.     , inBuf{nullptr, nullptr},

  563.       inBufTmp{nullptr, nullptr},

  564.       outBuf{nullptr, nullptr} {}

  565. #else

  566.     {

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

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

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

  570.     }

  571. #endif

  572. 

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

  574. {

  575.     const CarlaRecursiveMutexLocker cml(mutex);

  576. 

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

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

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

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

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

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

  583. 

  584.     connectedIn1.clear();

  585.     connectedIn2.clear();

  586.     connectedOut1.clear();

  587.     connectedOut2.clear();

  588. }

  589. 

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

  591. {

  592.     const CarlaRecursiveMutexLocker cml(mutex);

  593. 

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

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

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

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

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

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

  600. 

  601.     CARLA_SAFE_ASSERT_RETURN(bufferSize > 0,);

  602. 

  603.     try {

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

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

  606. 

  607.         if (createBuffers)

  608.         {

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

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

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

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

  613.         }

  614.     }

  615.     catch(...) {

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

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

  618. 

  619.         if (createBuffers)

  620.         {

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

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

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

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

  625.         }

  626.         return;

  627.     }

  628. 

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

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

  631. 

  632.     if (createBuffers)

  633.     {

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

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

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

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

  638.     }

  639. }

  640. 

  641. // -----------------------------------------------------------------------

  642. // RackGraph

  643. 

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

  645.     : extGraph(engine),

  646.       inputs(ins),

  647.       outputs(outs),

  648.       isOffline(false),

  649.       audioBuffers(),

  650.       kEngine(engine)

  651. {

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

  653. }

  654. 

  655. RackGraph::~RackGraph() noexcept

  656. {

  657.     extGraph.clear();

  658. }

  659. 

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

  661. {

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

  663. }

  664. 

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

  666. {

  667.     isOffline = offline;

  668. }

  669. 

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

  671. {

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

  673. }

  674. 

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

  676. {

  677.     return extGraph.disconnect(connectionId);

  678. }

  679. 

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

  681. {

  682.     extGraph.refresh(deviceName);

  683. 

  684.     char strBuf[STR_MAX+1];

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

  686. 

  687.     // Connections

  688.     const CarlaRecursiveMutexLocker cml(audioBuffers.mutex);

  689. 

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

  691.     {

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

  693.         CARLA_SAFE_ASSERT_CONTINUE(portId > 0);

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

  695. 

  696.         ConnectionToId connectionToId;

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

  698. 

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

  700. 

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

  702. 

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

  704.     }

  705. 

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

  707.     {

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

  709.         CARLA_SAFE_ASSERT_CONTINUE(portId > 0);

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

  711. 

  712.         ConnectionToId connectionToId;

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

  714. 

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

  716. 

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

  718. 

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

  720.     }

  721. 

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

  723.     {

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

  725.         CARLA_SAFE_ASSERT_CONTINUE(portId > 0);

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

  727. 

  728.         ConnectionToId connectionToId;

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

  730. 

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

  732. 

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

  734. 

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

  736.     }

  737. 

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

  739.     {

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

  741.         CARLA_SAFE_ASSERT_CONTINUE(portId > 0);

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

  743. 

  744.         ConnectionToId connectionToId;

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

  746. 

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

  748. 

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

  750. 

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

  752.     }

  753. }

  754. 

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

  756. {

  757.     return extGraph.getConnections();

  758. }

  759. 

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

  761. {

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

  763. }

  764. 

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

  766. {

  767.     CARLA_SAFE_ASSERT_RETURN(data != nullptr,);

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

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

  770. 

  771.     // safe copy

  772.     float inBuf0[frames];

  773.     float inBuf1[frames];

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

  775. 

  776.     // initialize audio inputs

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

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

  779. 

  780.     // initialize audio outputs (zero)

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

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

  783. 

  784.     // initialize event outputs (zero)

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

  786. 

  787.     uint32_t oldAudioInCount  = 0;

  788.     uint32_t oldAudioOutCount = 0;

  789.     uint32_t oldMidiOutCount  = 0;

  790.     bool processed = false;

  791. 

  792.     // process plugins

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

  794.     {

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

  796. 

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

  798.             continue;

  799. 

  800.         if (processed)

  801.         {

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

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

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

  805. 

  806.             // initialize audio outputs (zero)

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

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

  809. 

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

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

  812.             {

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

  814.                 {

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

  816.                 }

  817.                 // else nothing needed

  818.             }

  819.             else

  820.             {

  821.                 // initialize event inputs from previous outputs

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

  823. 

  824.                 // initialize event outputs (zero)

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

  826.             }

  827.         }

  828. 

  829.         oldAudioInCount  = plugin->getAudioInCount();

  830.         oldAudioOutCount = plugin->getAudioOutCount();

  831.         oldMidiOutCount  = plugin->getMidiOutCount();

  832. 

  833.         // process

  834.         plugin->initBuffers();

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

  836.         plugin->unlock();

  837. 

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

  839.         if (oldAudioInCount == 0)

  840.         {

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

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

  843.         }

  844. 

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

  846.         if (oldAudioOutCount == 1)

  847.         {

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

  849.         }

  850. 

  851.         // set peaks

  852.         {

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

  854. 

  855.             if (oldAudioInCount > 0)

  856.             {

  857.                 pluginData.insPeak[0] = carla_findMaxNormalizedFloat(inBuf0, frames);

  858.                 pluginData.insPeak[1] = carla_findMaxNormalizedFloat(inBuf1, frames);

  859.             }

  860.             else

  861.             {

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

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

  864.             }

  865. 

  866.             if (oldAudioOutCount > 0)

  867.             {

  868.                 pluginData.outsPeak[0] = carla_findMaxNormalizedFloat(outBuf[0], frames);

  869.                 pluginData.outsPeak[1] = carla_findMaxNormalizedFloat(outBuf[1], frames);

  870.             }

  871.             else

  872.             {

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

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

  875.             }

  876.         }

  877. 

  878.         processed = true;

  879.     }

  880. }

  881. 

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

  883. {

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

  885. 

  886.     const CarlaRecursiveMutexLocker _cml(audioBuffers.mutex);

  887. 

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

  889.     {

  890.         bool noConnections = true;

  891. 

  892.         // connect input buffers

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

  894.         {

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

  896.             CARLA_SAFE_ASSERT_CONTINUE(port > 0);

  897.             CARLA_SAFE_ASSERT_CONTINUE(port <= inputs);

  898. 

  899.             if (noConnections)

  900.             {

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

  902.                 noConnections = false;

  903.             }

  904.             else

  905.             {

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

  907.             }

  908.         }

  909. 

  910.         if (noConnections)

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

  912. 

  913.         noConnections = true;

  914. 

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

  916.         {

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

  918.             CARLA_SAFE_ASSERT_CONTINUE(port > 0);

  919.             CARLA_SAFE_ASSERT_CONTINUE(port <= inputs);

  920. 

  921.             if (noConnections)

  922.             {

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

  924.                 noConnections = false;

  925.             }

  926.             else

  927.             {

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

  929.             }

  930.         }

  931. 

  932.         if (noConnections)

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

  934.     }

  935.     else

  936.     {

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

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

  939.     }

  940. 

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

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

  943. 

  944.     // process

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

  946. 

  947.     // connect output buffers

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

  949.     {

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

  951.         {

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

  953.             CARLA_SAFE_ASSERT_CONTINUE(port > 0);

  954.             CARLA_SAFE_ASSERT_CONTINUE(port <= outputs);

  955. 

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

  957.         }

  958.     }

  959. 

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

  961.     {

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

  963.         {

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

  965.             CARLA_SAFE_ASSERT_CONTINUE(port > 0);

  966.             CARLA_SAFE_ASSERT_CONTINUE(port <= outputs);

  967. 

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

  969.         }

  970.     }

  971. }

  972. 

  973. // -----------------------------------------------------------------------

  974. // InternalGraph

  975. 

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

  977.     : fIsReady(false),

  978.       fRack(nullptr),

  979.       kEngine(engine) {}

  980. 

  981. EngineInternalGraph::~EngineInternalGraph() noexcept

  982. {

  983.     CARLA_SAFE_ASSERT(! fIsReady);

  984.     CARLA_SAFE_ASSERT(fRack == nullptr);

  985. }

  986. 

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

  988. {

  989.     CARLA_SAFE_ASSERT_RETURN(fRack == nullptr,);

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

  991.     fIsReady = true;

  992. }

  993. 

  994. void EngineInternalGraph::destroy() noexcept

  995. {

  996.     if (! fIsReady)

  997.     {

  998.         CARLA_SAFE_ASSERT(fRack == nullptr);

  999.         return;

  1000.     }

  1001. 

  1002.     CARLA_SAFE_ASSERT_RETURN(fRack != nullptr,);

  1003.     delete fRack;

  1004.     fRack = nullptr;

  1005. 

  1006.     fIsReady = false;

  1007. }

  1008. 

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

  1010. {

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

  1012. 

  1013.     CARLA_SAFE_ASSERT_RETURN(fRack != nullptr,);

  1014.     fRack->setBufferSize(bufferSize);

  1015. }

  1016. 

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

  1018. {

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

  1020. 

  1021.     CARLA_SAFE_ASSERT_RETURN(fRack != nullptr,);

  1022.     fRack->setOffline(offline);

  1023. }

  1024. 

  1025. bool EngineInternalGraph::isReady() const noexcept

  1026. {

  1027.     return fIsReady;

  1028. }

  1029. 

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

  1031. {

  1032.     return fRack;

  1033. }

  1034. 

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

  1036. {

  1037.     CARLA_SAFE_ASSERT_RETURN(fRack != nullptr,);

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

  1039. }

  1040. 

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

  1042. {

  1043.     CARLA_SAFE_ASSERT_RETURN(fRack != nullptr,);

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

  1045. }

  1046. 

  1047. // -----------------------------------------------------------------------

  1048. // CarlaEngine Patchbay stuff

  1049. 

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

  1051. {

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

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

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

  1055. 

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

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

  1058. 

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

  1060. }

  1061. 

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

  1063. {

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

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

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

  1067. 

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

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

  1070. 

  1071.     return graph->disconnect(connectionId);

  1072. }

  1073. 

  1074. bool CarlaEngine::patchbayRefresh()

  1075. {

  1076.     // This is implemented in engine subclasses

  1077.     setLastError("Unsupported operation");

  1078.     return false;

  1079. }

  1080. 

  1081. // -----------------------------------------------------------------------

  1082. 

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

  1084. {

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

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

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

  1088. 

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

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

  1091. 

  1092.     return graph->getConnections();

  1093. }

  1094. 

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

  1096. {

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

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

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

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

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

  1102. 

  1103.     uint groupA, portA;

  1104.     uint groupB, portB;

  1105. 

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

  1107.     CARLA_SAFE_ASSERT_RETURN(graph != nullptr,);

  1108. 

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

  1110.         return;

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

  1112.         return;

  1113. 

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

  1115. }

  1116. 

  1117. // -----------------------------------------------------------------------

  1118. 

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

  1120. {

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

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

  1123. 

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

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

  1126. 

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

  1128. 

  1129.     switch (connectionType)

  1130.     {

  1131.     case kExternalGraphConnectionAudioIn1:

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

  1133.     case kExternalGraphConnectionAudioIn2:

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

  1135.     case kExternalGraphConnectionAudioOut1:

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

  1137.     case kExternalGraphConnectionAudioOut2:

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

  1139.     }

  1140. 

  1141.     return false;

  1142. }

  1143. 

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

  1145. {

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

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

  1148. 

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

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

  1151. 

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

  1153. 

  1154.     switch (connectionType)

  1155.     {

  1156.     case kExternalGraphConnectionAudioIn1:

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

  1158.     case kExternalGraphConnectionAudioIn2:

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

  1160.     case kExternalGraphConnectionAudioOut1:

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

  1162.     case kExternalGraphConnectionAudioOut2:

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

  1164.     }

  1165. 

  1166.     return false;

  1167. }

  1168. 

  1169. // -----------------------------------------------------------------------

  1170. 

  1171. CARLA_BACKEND_END_NAMESPACE