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

830 lines
26KB
Raw Blame History 

  1. /*

  2.  * Carla Plugin Host

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

  4.  *

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

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

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

  8.  * the License, or any later version.

  9.  *

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

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

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

  13.  * GNU General Public License for more details.

  14.  *

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

  16.  */

  17. 

  18. #include "CarlaEngineGraph.hpp"

  19. #include "CarlaEngineInternal.hpp"

  20. 

  21. #include "juce_audio_basics.h"

  22. using juce::FloatVectorOperations;

  23. 

  24. CARLA_BACKEND_START_NAMESPACE

  25. 

  26. // -----------------------------------------------------------------------

  27. // Rack Graph stuff

  28. 

  29. static inline

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

  31. {

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

  33.         return RACK_GRAPH_CARLA_PORT_AUDIO_IN1;

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

  35.         return RACK_GRAPH_CARLA_PORT_AUDIO_IN2;

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

  37.         return RACK_GRAPH_CARLA_PORT_AUDIO_OUT1;

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

  39.         return RACK_GRAPH_CARLA_PORT_AUDIO_OUT2;

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

  41.         return RACK_GRAPH_CARLA_PORT_MIDI_IN;

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

  43.         return RACK_GRAPH_CARLA_PORT_MIDI_OUT;

  44. 

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

  46.     return RACK_GRAPH_CARLA_PORT_NULL;

  47. }

  48. 

  49. // -----------------------------------------------------------------------

  50. // RackGraph MIDI

  51. 

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

  53. {

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

  55.     {

  56.         const PortNameToId& port(it.getValue());

  57. 

  58.         if (port.port == portId)

  59.             return port.name;

  60.     }

  61. 

  62.     return nullptr;

  63. }

  64. 

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

  66. {

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

  68.     {

  69.         const PortNameToId& port(it.getValue());

  70. 

  71.         if (std::strcmp(port.name, portName) == 0)

  72.             return port.port;

  73.     }

  74. 

  75.     return 0;

  76. }

  77. 

  78. // -----------------------------------------------------------------------

  79. // RackGraph

  80. 

  81. RackGraph::RackGraph(const uint32_t bufferSize) noexcept

  82. {

  83.     audio.inBuf[0]  = audio.inBuf[1]  = nullptr;

  84.     audio.outBuf[0] = audio.outBuf[1] = nullptr;

  85.     resize(bufferSize);

  86. }

  87. 

  88. RackGraph::~RackGraph() noexcept

  89. {

  90.     clear();

  91. }

  92. 

  93. void RackGraph::clear() noexcept

  94. {

  95.     connections.clear();

  96. 

  97.     audio.mutex.lock();

  98.     audio.connectedIn1.clear();

  99.     audio.connectedIn2.clear();

  100.     audio.connectedOut1.clear();

  101.     audio.connectedOut2.clear();

  102.     audio.mutex.unlock();

  103. 

  104.     midi.ins.clear();

  105.     midi.outs.clear();

  106. }

  107. 

  108. void RackGraph::resize(const uint32_t bufferSize) noexcept

  109. {

  110.     if (audio.inBuf[0] != nullptr)

  111.     {

  112.         delete[] audio.inBuf[0];

  113.         audio.inBuf[0] = nullptr;

  114.     }

  115.     if (audio.inBuf[1] != nullptr)

  116.     {

  117.         delete[] audio.inBuf[1];

  118.         audio.inBuf[1] = nullptr;

  119.     }

  120.     if (audio.outBuf[0] != nullptr)

  121.     {

  122.         delete[] audio.outBuf[0];

  123.         audio.outBuf[0] = nullptr;

  124.     }

  125.     if (audio.outBuf[1] != nullptr)

  126.     {

  127.         delete[] audio.outBuf[1];

  128.         audio.outBuf[1] = nullptr;

  129.     }

  130. 

  131.     try {

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

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

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

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

  136.     }

  137.     catch(...) {

  138.         if (audio.inBuf[0] != nullptr)

  139.         {

  140.             delete[] audio.inBuf[0];

  141.             audio.inBuf[0] = nullptr;

  142.         }

  143.         if (audio.inBuf[1] != nullptr)

  144.         {

  145.             delete[] audio.inBuf[1];

  146.             audio.inBuf[1] = nullptr;

  147.         }

  148.         if (audio.outBuf[0] != nullptr)

  149.         {

  150.             delete[] audio.outBuf[0];

  151.             audio.outBuf[0] = nullptr;

  152.         }

  153.         if (audio.outBuf[1] != nullptr)

  154.         {

  155.             delete[] audio.outBuf[1];

  156.             audio.outBuf[1] = nullptr;

  157.         }

  158.         return;

  159.     }

  160. 

  161.     FloatVectorOperations::clear(audio.inBuf[0], bufferSize);

  162.     FloatVectorOperations::clear(audio.inBuf[1], bufferSize);

  163.     FloatVectorOperations::clear(audio.outBuf[0], bufferSize);

  164.     FloatVectorOperations::clear(audio.outBuf[1], bufferSize);

  165. }

  166. 

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

  168. {

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

  170. 

  171.     uint otherGroup, otherPort, carlaPort;

  172. 

  173.     if (groupA == RACK_GRAPH_GROUP_CARLA)

  174.     {

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

  176. 

  177.         carlaPort  = portA;

  178.         otherGroup = groupB;

  179.         otherPort  = portB;

  180.     }

  181.     else

  182.     {

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

  184. 

  185.         carlaPort  = portB;

  186.         otherGroup = groupA;

  187.         otherPort  = portA;

  188.     }

  189. 

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

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

  192. 

  193.     bool makeConnection = false;

  194. 

  195.     switch (carlaPort)

  196.     {

  197.     case RACK_GRAPH_CARLA_PORT_AUDIO_IN1:

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

  199.         audio.mutex.lock();

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

  201.         audio.mutex.unlock();

  202.         break;

  203. 

  204.     case RACK_GRAPH_CARLA_PORT_AUDIO_IN2:

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

  206.         audio.mutex.lock();

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

  208.         audio.mutex.unlock();

  209.         break;

  210. 

  211.     case RACK_GRAPH_CARLA_PORT_AUDIO_OUT1:

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

  213.         audio.mutex.lock();

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

  215.         audio.mutex.unlock();

  216.         break;

  217. 

  218.     case RACK_GRAPH_CARLA_PORT_AUDIO_OUT2:

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

  220.         audio.mutex.lock();

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

  222.         audio.mutex.unlock();

  223.         break;

  224. 

  225.     case RACK_GRAPH_CARLA_PORT_MIDI_IN:

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

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

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

  229.         break;

  230. 

  231.     case RACK_GRAPH_CARLA_PORT_MIDI_OUT:

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

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

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

  235.         break;

  236.     }

  237. 

  238.     if (! makeConnection)

  239.     {

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

  241.         return false;

  242.     }

  243. 

  244.     ConnectionToId connectionToId;

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

  246. 

  247.     char strBuf[STR_MAX+1];

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

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

  250. 

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

  252. 

  253.     connections.list.append(connectionToId);

  254.     return true;

  255. }

  256. 

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

  258. {

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

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

  261. 

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

  263.     {

  264.         const ConnectionToId& connection(it.getValue());

  265. 

  266.         if (connection.id != connectionId)

  267.             continue;

  268. 

  269.         uint otherGroup, otherPort, carlaPort;

  270. 

  271.         if (connection.groupA == RACK_GRAPH_GROUP_CARLA)

  272.         {

  273.             CARLA_SAFE_ASSERT_RETURN(connection.groupB != RACK_GRAPH_GROUP_CARLA, false);

  274. 

  275.             carlaPort  = connection.portA;

  276.             otherGroup = connection.groupB;

  277.             otherPort  = connection.portB;

  278.         }

  279.         else

  280.         {

  281.             CARLA_SAFE_ASSERT_RETURN(connection.groupB == RACK_GRAPH_GROUP_CARLA, false);

  282. 

  283.             carlaPort  = connection.portB;

  284.             otherGroup = connection.groupA;

  285.             otherPort  = connection.portA;

  286.         }

  287. 

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

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

  290. 

  291.         bool makeDisconnection = false;

  292. 

  293.         switch (carlaPort)

  294.         {

  295.         case RACK_GRAPH_CARLA_PORT_AUDIO_IN1:

  296.             audio.mutex.lock();

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

  298.             audio.mutex.unlock();

  299.             break;

  300. 

  301.         case RACK_GRAPH_CARLA_PORT_AUDIO_IN2:

  302.             audio.mutex.lock();

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

  304.             audio.mutex.unlock();

  305.             break;

  306. 

  307.         case RACK_GRAPH_CARLA_PORT_AUDIO_OUT1:

  308.             audio.mutex.lock();

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

  310.             audio.mutex.unlock();

  311.             break;

  312. 

  313.         case RACK_GRAPH_CARLA_PORT_AUDIO_OUT2:

  314.             audio.mutex.lock();

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

  316.             audio.mutex.unlock();

  317.             break;

  318. 

  319.         case RACK_GRAPH_CARLA_PORT_MIDI_IN:

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

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

  322.             break;

  323. 

  324.         case RACK_GRAPH_CARLA_PORT_MIDI_OUT:

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

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

  327.             break;

  328.         }

  329. 

  330.         if (! makeDisconnection)

  331.         {

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

  333.             return false;

  334.         }

  335. 

  336.         engine->callback(ENGINE_CALLBACK_PATCHBAY_CONNECTION_REMOVED, connection.id, 0, 0, 0.0f, nullptr);

  337. 

  338.         connections.list.remove(it);

  339.         return true;

  340.     }

  341. 

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

  343.     return false;

  344. }

  345. 

  346. const char* const* RackGraph::getConnections() const

  347. {

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

  349.         return nullptr;

  350. 

  351.     LinkedList<const char*> connList;

  352.     char strBuf[STR_MAX+1];

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

  354. 

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

  356.     {

  357.         const ConnectionToId& connection(it.getValue());

  358. 

  359.         uint otherGroup, otherPort, carlaPort;

  360. 

  361.         if (connection.groupA == RACK_GRAPH_GROUP_CARLA)

  362.         {

  363.             CARLA_SAFE_ASSERT_CONTINUE(connection.groupB != RACK_GRAPH_GROUP_CARLA);

  364. 

  365.             carlaPort  = connection.portA;

  366.             otherGroup = connection.groupB;

  367.             otherPort  = connection.portB;

  368.         }

  369.         else

  370.         {

  371.             CARLA_SAFE_ASSERT_CONTINUE(connection.groupB == RACK_GRAPH_GROUP_CARLA);

  372. 

  373.             carlaPort  = connection.portB;

  374.             otherGroup = connection.groupA;

  375.             otherPort  = connection.portA;

  376.         }

  377. 

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

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

  380. 

  381.         switch (carlaPort)

  382.         {

  383.         case RACK_GRAPH_CARLA_PORT_AUDIO_IN1:

  384.         case RACK_GRAPH_CARLA_PORT_AUDIO_IN2:

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

  386.             connList.append(carla_strdup(strBuf));

  387.             connList.append(carla_strdup((carlaPort == RACK_GRAPH_CARLA_PORT_AUDIO_IN1) ? "Carla:AudioIn1" : "Carla:AudioIn2"));

  388.             break;

  389. 

  390.         case RACK_GRAPH_CARLA_PORT_AUDIO_OUT1:

  391.         case RACK_GRAPH_CARLA_PORT_AUDIO_OUT2:

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

  393.             connList.append(carla_strdup((carlaPort == RACK_GRAPH_CARLA_PORT_AUDIO_OUT1) ? "Carla:AudioOut1" : "Carla:AudioOut2"));

  394.             connList.append(carla_strdup(strBuf));

  395.             break;

  396. 

  397.         case RACK_GRAPH_CARLA_PORT_MIDI_IN:

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

  399.             connList.append(carla_strdup(strBuf));

  400.             connList.append(carla_strdup("Carla:MidiIn"));

  401.             break;

  402. 

  403.         case RACK_GRAPH_CARLA_PORT_MIDI_OUT:

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

  405.             connList.append(carla_strdup("Carla:MidiOut"));

  406.             connList.append(carla_strdup(strBuf));

  407.             break;

  408.         }

  409.     }

  410. 

  411.     const size_t connCount(connList.count());

  412. 

  413.     if (connCount == 0)

  414.         return nullptr;

  415. 

  416.     const char** const retConns = new const char*[connCount+1];

  417. 

  418.     for (size_t i=0; i < connCount; ++i)

  419.     {

  420.         retConns[i] = connList.getAt(i, nullptr);

  421. 

  422.         if (retConns[i] == nullptr)

  423.             retConns[i] = carla_strdup("(unknown)");

  424.     }

  425. 

  426.     retConns[connCount] = nullptr;

  427.     connList.clear();

  428. 

  429.     return retConns;

  430. }

  431. 

  432. bool RackGraph::getPortIdFromFullName(const char* const fullPortName, uint& groupId, uint& portId) const

  433. {

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

  435. 

  436.     int portTest;

  437. 

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

  439.     {

  440.         groupId = RACK_GRAPH_GROUP_CARLA;

  441.         portId  = getCarlaRackPortIdFromName(fullPortName+6);

  442.         CARLA_SAFE_ASSERT_RETURN(portId > RACK_GRAPH_CARLA_PORT_NULL && portId < RACK_GRAPH_CARLA_PORT_MAX, false);

  443.     }

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

  445.     {

  446.         groupId  = RACK_GRAPH_GROUP_AUDIO_IN;

  447.         portTest = std::atoi(fullPortName+8) - 1;

  448.         CARLA_SAFE_ASSERT_RETURN(portTest >= 0, false);

  449.         portId   = static_cast<uint>(portTest);

  450.     }

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

  452.     {

  453.         groupId  = RACK_GRAPH_GROUP_AUDIO_OUT;

  454.         portTest = std::atoi(fullPortName+9) - 1;

  455.         CARLA_SAFE_ASSERT_RETURN(portTest >= 0, false);

  456.         portId   = static_cast<uint>(portTest);

  457.     }

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

  459.     {

  460.         groupId = RACK_GRAPH_GROUP_MIDI_IN;

  461.         //portId  = std::atoi(fullPortName+7) - 1;

  462.     }

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

  464.     {

  465.         groupId = RACK_GRAPH_GROUP_MIDI_OUT;

  466.         //portId  = std::atoi(fullPortName+8) - 1;

  467.     }

  468.     else

  469.     {

  470.         return false;

  471.     }

  472. 

  473.     return true;

  474. }

  475. 

  476. // -----------------------------------------------------------------------

  477. // PatchbayGraph

  478. 

  479. // TODO

  480. 

  481. PatchbayGraph::PatchbayGraph() noexcept

  482. {

  483. }

  484. 

  485. PatchbayGraph::~PatchbayGraph() noexcept

  486. {

  487.     clear();

  488. }

  489. 

  490. void PatchbayGraph::clear() noexcept

  491. {

  492. }

  493. 

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

  495. {

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

  497. 

  498.     return false;

  499. }

  500. 

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

  502. {

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

  504. 

  505.     return false;

  506. }

  507. 

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

  509. {

  510.     return nullptr;

  511. }

  512. 

  513. bool PatchbayGraph::getPortIdFromFullName(const char* const /*fillPortName*/, uint& /*groupId*/, uint& /*portId*/) const

  514. {

  515.     return false;

  516. }

  517. 

  518. // -----------------------------------------------------------------------

  519. // InternalGraph

  520. 

  521. EngineInternalGraph::EngineInternalGraph() noexcept

  522.     : isRack(true),

  523.       isReady(false),

  524.       graph(nullptr) {}

  525. 

  526. EngineInternalGraph::~EngineInternalGraph() noexcept

  527. {

  528.     CARLA_SAFE_ASSERT(graph == nullptr);

  529. }

  530. 

  531. void EngineInternalGraph::create(const uint32_t bufferSize)

  532. {

  533.     CARLA_SAFE_ASSERT_RETURN(graph == nullptr,);

  534. 

  535.     if (isRack)

  536.         graph = new RackGraph(bufferSize);

  537.     else

  538.         graph = new PatchbayGraph();

  539. 

  540.     //isReady = true;

  541. }

  542. 

  543. void EngineInternalGraph::resize(const uint32_t bufferSize) noexcept

  544. {

  545.     CARLA_SAFE_ASSERT_RETURN(graph != nullptr,);

  546. 

  547.     if (isRack)

  548.       ((RackGraph*)graph)->resize(bufferSize);

  549. }

  550. 

  551. void EngineInternalGraph::clear() noexcept

  552. {

  553.     CARLA_SAFE_ASSERT_RETURN(graph != nullptr,);

  554. 

  555.     delete graph;

  556.     graph = nullptr;

  557. }

  558. 

  559. // -----------------------------------------------------------------------

  560. // CarlaEngine Patchbay stuff

  561. 

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

  563. {

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

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

  566.     CARLA_SAFE_ASSERT_RETURN(pData->graph.graph != nullptr, false);

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

  568. 

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

  570. }

  571. 

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

  573. {

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

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

  576.     CARLA_SAFE_ASSERT_RETURN(pData->graph.graph != nullptr, false);

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

  578. 

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

  580. }

  581. 

  582. bool CarlaEngine::patchbayRefresh()

  583. {

  584.     setLastError("Unsupported operation");

  585.     return false;

  586. }

  587. 

  588. // -----------------------------------------------------------------------

  589. 

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

  591. {

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

  593.     CARLA_SAFE_ASSERT_RETURN(pData->graph.graph != nullptr, nullptr);

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

  595. 

  596.     return pData->graph.graph->getConnections();

  597. }

  598. 

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

  600. {

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

  602.     CARLA_SAFE_ASSERT_RETURN(pData->graph.graph != nullptr,);

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

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

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

  606. 

  607.     uint groupA, portA;

  608.     uint groupB, portB;

  609. 

  610.     if (! pData->graph.graph->getPortIdFromFullName(connSource, groupA, portA))

  611.         return;

  612.     if (! pData->graph.graph->getPortIdFromFullName(connTarget, groupB, portB))

  613.         return;

  614. 

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

  616. }

  617. 

  618. 

  619. void CarlaEngine::ProtectedData::processRack(const float* inBufReal[2], float* outBuf[2], const uint32_t frames, const bool isOffline)

  620. {

  621.     CARLA_SAFE_ASSERT_RETURN(events.in != nullptr,);

  622.     CARLA_SAFE_ASSERT_RETURN(events.out != nullptr,);

  623. 

  624. #if 0

  625.     // safe copy

  626.     float inBuf0[frames];

  627.     float inBuf1[frames];

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

  629. 

  630.     // initialize audio inputs

  631.     FloatVectorOperations::copy(inBuf0, inBufReal[0], frames);

  632.     FloatVectorOperations::copy(inBuf1, inBufReal[1], frames);

  633. 

  634.     // initialize audio outputs (zero)

  635.     FloatVectorOperations::clear(outBuf[0], frames);

  636.     FloatVectorOperations::clear(outBuf[1], frames);

  637. 

  638.     // initialize event outputs (zero)

  639.     carla_zeroStruct<EngineEvent>(events.out, kMaxEngineEventInternalCount);

  640. 

  641.     bool processed = false;

  642. 

  643.     uint32_t oldAudioInCount = 0;

  644.     uint32_t oldMidiOutCount = 0;

  645. 

  646.     // process plugins

  647.     for (uint i=0; i < curPluginCount; ++i)

  648.     {

  649.         CarlaPlugin* const plugin = plugins[i].plugin;

  650. 

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

  652.             continue;

  653. 

  654.         if (processed)

  655.         {

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

  657.             FloatVectorOperations::copy(inBuf0, outBuf[0], frames);

  658.             FloatVectorOperations::copy(inBuf1, outBuf[1], frames);

  659. 

  660.             // initialize audio outputs (zero)

  661.             FloatVectorOperations::clear(outBuf[0], frames);

  662.             FloatVectorOperations::clear(outBuf[1], frames);

  663. 

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

  665.             if (oldMidiOutCount == 0 && events.in[0].type != kEngineEventTypeNull)

  666.             {

  667.                 if (events.out[0].type != kEngineEventTypeNull)

  668.                 {

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

  670.                 }

  671.                 // else nothing needed

  672.             }

  673.             else

  674.             {

  675.                 // initialize event inputs from previous outputs

  676.                 carla_copyStruct<EngineEvent>(events.in, events.out, kMaxEngineEventInternalCount);

  677. 

  678.                 // initialize event outputs (zero)

  679.                 carla_zeroStruct<EngineEvent>(events.out, kMaxEngineEventInternalCount);

  680.             }

  681.         }

  682. 

  683.         oldAudioInCount = plugin->getAudioInCount();

  684.         oldMidiOutCount = plugin->getMidiOutCount();

  685. 

  686.         // process

  687.         plugin->initBuffers();

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

  689.         plugin->unlock();

  690. 

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

  692.         if (oldAudioInCount == 0)

  693.         {

  694.             FloatVectorOperations::add(outBuf[0], inBuf0, frames);

  695.             FloatVectorOperations::add(outBuf[1], inBuf1, frames);

  696.         }

  697. 

  698.         // set peaks

  699.         {

  700.             EnginePluginData& pluginData(plugins[i]);

  701. 

  702.             juce::Range<float> range;

  703. 

  704.             if (oldAudioInCount > 0)

  705.             {

  706.                 range = FloatVectorOperations::findMinAndMax(inBuf0, static_cast<int>(frames));

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

  708. 

  709.                 range = FloatVectorOperations::findMinAndMax(inBuf1, static_cast<int>(frames));

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

  711.             }

  712.             else

  713.             {

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

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

  716.             }

  717. 

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

  719.             {

  720.                 range = FloatVectorOperations::findMinAndMax(outBuf[0], static_cast<int>(frames));

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

  722. 

  723.                 range = FloatVectorOperations::findMinAndMax(outBuf[1], static_cast<int>(frames));

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

  725.             }

  726.             else

  727.             {

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

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

  730.             }

  731.         }

  732. 

  733.         processed = true;

  734.     }

  735. #endif

  736. }

  737. 

  738. void CarlaEngine::ProtectedData::processRackFull(const float* const* const inBuf, const uint32_t inCount, float* const* const outBuf, const uint32_t outCount, const uint32_t nframes, const bool isOffline)

  739. {

  740. #if 0

  741.     RackGraph::Audio& rackAudio(graph.rack->audio);

  742. 

  743.     const CarlaMutexLocker _cml(rackAudio.mutex);

  744. 

  745.     if (inBuf != nullptr && inCount > 0)

  746.     {

  747.         bool noConnections = true;

  748. 

  749.         // connect input buffers

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

  751.         {

  752.             const uint& port(it.getValue());

  753.             CARLA_SAFE_ASSERT_CONTINUE(port < inCount);

  754. 

  755.             if (noConnections)

  756.             {

  757.                 FloatVectorOperations::copy(audio.inBuf[0], inBuf[port], nframes);

  758.                 noConnections = false;

  759.             }

  760.             else

  761.             {

  762.                 FloatVectorOperations::add(audio.inBuf[0], inBuf[port], nframes);

  763.             }

  764.         }

  765. 

  766.         if (noConnections)

  767.             FloatVectorOperations::clear(audio.inBuf[0], nframes);

  768. 

  769.         noConnections = true;

  770. 

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

  772.         {

  773.             const uint& port(it.getValue());

  774.             CARLA_SAFE_ASSERT_CONTINUE(port < inCount);

  775. 

  776.             if (noConnections)

  777.             {

  778.                 FloatVectorOperations::copy(audio.inBuf[1], inBuf[port], nframes);

  779.                 noConnections = false;

  780.             }

  781.             else

  782.             {

  783.                 FloatVectorOperations::add(audio.inBuf[1], inBuf[port], nframes);

  784.             }

  785.         }

  786. 

  787.         if (noConnections)

  788.             FloatVectorOperations::clear(audio.inBuf[1], nframes);

  789.     }

  790.     else

  791.     {

  792.         FloatVectorOperations::clear(audio.inBuf[0], nframes);

  793.         FloatVectorOperations::clear(audio.inBuf[1], nframes);

  794.     }

  795. 

  796.     FloatVectorOperations::clear(audio.outBuf[0], nframes);

  797.     FloatVectorOperations::clear(audio.outBuf[1], nframes);

  798. 

  799.     // process

  800.     processRack(const_cast<const float**>(audio.inBuf), audio.outBuf, nframes, isOffline);

  801. 

  802.     // connect output buffers

  803.     if (rackAudio.connectedOut1.count() != 0)

  804.     {

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

  806.         {

  807.             const uint& port(it.getValue());

  808.             CARLA_SAFE_ASSERT_CONTINUE(port < outCount);

  809. 

  810.             FloatVectorOperations::add(outBuf[port], audio.outBuf[0], nframes);

  811.         }

  812.     }

  813. 

  814.     if (rackAudio.connectedOut2.count() != 0)

  815.     {

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

  817.         {

  818.             const uint& port(it.getValue());

  819.             CARLA_SAFE_ASSERT_CONTINUE(port < outCount);

  820. 

  821.             FloatVectorOperations::add(outBuf[port], audio.outBuf[1], nframes);

  822.         }

  823.     }

  824. #endif

  825. }

  826. 

  827. // -----------------------------------------------------------------------

  828. 

  829. CARLA_BACKEND_END_NAMESPACE