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

849 lines
27KB
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. 

  86.     setBufferSize(bufferSize);

  87. }

  88. 

  89. RackGraph::~RackGraph() noexcept

  90. {

  91.     clear();

  92. }

  93. 

  94. void RackGraph::clear() noexcept

  95. {

  96.     connections.clear();

  97. 

  98.     audio.mutex.lock();

  99.     audio.connectedIn1.clear();

  100.     audio.connectedIn2.clear();

  101.     audio.connectedOut1.clear();

  102.     audio.connectedOut2.clear();

  103.     audio.mutex.unlock();

  104. 

  105.     midi.ins.clear();

  106.     midi.outs.clear();

  107. }

  108. 

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

  110. {

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

  112.     {

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

  114.         audio.inBuf[0] = nullptr;

  115.     }

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

  117.     {

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

  119.         audio.inBuf[1] = nullptr;

  120.     }

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

  122.     {

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

  124.         audio.outBuf[0] = nullptr;

  125.     }

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

  127.     {

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

  129.         audio.outBuf[1] = nullptr;

  130.     }

  131. 

  132.     try {

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

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

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

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

  137.     }

  138.     catch(...) {

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

  140.         {

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

  142.             audio.inBuf[0] = nullptr;

  143.         }

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

  145.         {

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

  147.             audio.inBuf[1] = nullptr;

  148.         }

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

  150.         {

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

  152.             audio.outBuf[0] = nullptr;

  153.         }

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

  155.         {

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

  157.             audio.outBuf[1] = nullptr;

  158.         }

  159.         return;

  160.     }

  161. 

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

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

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

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

  166. }

  167. 

  168. void RackGraph::setSampleRate(const double) noexcept

  169. {

  170. }

  171. 

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

  173. {

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

  175. 

  176.     uint otherGroup, otherPort, carlaPort;

  177. 

  178.     if (groupA == RACK_GRAPH_GROUP_CARLA)

  179.     {

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

  181. 

  182.         carlaPort  = portA;

  183.         otherGroup = groupB;

  184.         otherPort  = portB;

  185.     }

  186.     else

  187.     {

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

  189. 

  190.         carlaPort  = portB;

  191.         otherGroup = groupA;

  192.         otherPort  = portA;

  193.     }

  194. 

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

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

  197. 

  198.     bool makeConnection = false;

  199. 

  200.     switch (carlaPort)

  201.     {

  202.     case RACK_GRAPH_CARLA_PORT_AUDIO_IN1:

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

  204.         audio.mutex.lock();

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

  206.         audio.mutex.unlock();

  207.         break;

  208. 

  209.     case RACK_GRAPH_CARLA_PORT_AUDIO_IN2:

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

  211.         audio.mutex.lock();

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

  213.         audio.mutex.unlock();

  214.         break;

  215. 

  216.     case RACK_GRAPH_CARLA_PORT_AUDIO_OUT1:

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

  218.         audio.mutex.lock();

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

  220.         audio.mutex.unlock();

  221.         break;

  222. 

  223.     case RACK_GRAPH_CARLA_PORT_AUDIO_OUT2:

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

  225.         audio.mutex.lock();

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

  227.         audio.mutex.unlock();

  228.         break;

  229. 

  230.     case RACK_GRAPH_CARLA_PORT_MIDI_IN:

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

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

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

  234.         break;

  235. 

  236.     case RACK_GRAPH_CARLA_PORT_MIDI_OUT:

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

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

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

  240.         break;

  241.     }

  242. 

  243.     if (! makeConnection)

  244.     {

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

  246.         return false;

  247.     }

  248. 

  249.     ConnectionToId connectionToId;

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

  251. 

  252.     char strBuf[STR_MAX+1];

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

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

  255. 

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

  257. 

  258.     connections.list.append(connectionToId);

  259.     return true;

  260. }

  261. 

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

  263. {

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

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

  266. 

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

  268.     {

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

  270. 

  271.         if (connection.id != connectionId)

  272.             continue;

  273. 

  274.         uint otherGroup, otherPort, carlaPort;

  275. 

  276.         if (connection.groupA == RACK_GRAPH_GROUP_CARLA)

  277.         {

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

  279. 

  280.             carlaPort  = connection.portA;

  281.             otherGroup = connection.groupB;

  282.             otherPort  = connection.portB;

  283.         }

  284.         else

  285.         {

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

  287. 

  288.             carlaPort  = connection.portB;

  289.             otherGroup = connection.groupA;

  290.             otherPort  = connection.portA;

  291.         }

  292. 

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

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

  295. 

  296.         bool makeDisconnection = false;

  297. 

  298.         switch (carlaPort)

  299.         {

  300.         case RACK_GRAPH_CARLA_PORT_AUDIO_IN1:

  301.             audio.mutex.lock();

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

  303.             audio.mutex.unlock();

  304.             break;

  305. 

  306.         case RACK_GRAPH_CARLA_PORT_AUDIO_IN2:

  307.             audio.mutex.lock();

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

  309.             audio.mutex.unlock();

  310.             break;

  311. 

  312.         case RACK_GRAPH_CARLA_PORT_AUDIO_OUT1:

  313.             audio.mutex.lock();

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

  315.             audio.mutex.unlock();

  316.             break;

  317. 

  318.         case RACK_GRAPH_CARLA_PORT_AUDIO_OUT2:

  319.             audio.mutex.lock();

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

  321.             audio.mutex.unlock();

  322.             break;

  323. 

  324.         case RACK_GRAPH_CARLA_PORT_MIDI_IN:

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

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

  327.             break;

  328. 

  329.         case RACK_GRAPH_CARLA_PORT_MIDI_OUT:

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

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

  332.             break;

  333.         }

  334. 

  335.         if (! makeDisconnection)

  336.         {

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

  338.             return false;

  339.         }

  340. 

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

  342. 

  343.         connections.list.remove(it);

  344.         return true;

  345.     }

  346. 

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

  348.     return false;

  349. }

  350. 

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

  352. {

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

  354.         return nullptr;

  355. 

  356.     LinkedList<const char*> connList;

  357.     char strBuf[STR_MAX+1];

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

  359. 

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

  361.     {

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

  363. 

  364.         uint otherGroup, otherPort, carlaPort;

  365. 

  366.         if (connection.groupA == RACK_GRAPH_GROUP_CARLA)

  367.         {

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

  369. 

  370.             carlaPort  = connection.portA;

  371.             otherGroup = connection.groupB;

  372.             otherPort  = connection.portB;

  373.         }

  374.         else

  375.         {

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

  377. 

  378.             carlaPort  = connection.portB;

  379.             otherGroup = connection.groupA;

  380.             otherPort  = connection.portA;

  381.         }

  382. 

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

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

  385. 

  386.         switch (carlaPort)

  387.         {

  388.         case RACK_GRAPH_CARLA_PORT_AUDIO_IN1:

  389.         case RACK_GRAPH_CARLA_PORT_AUDIO_IN2:

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

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

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

  393.             break;

  394. 

  395.         case RACK_GRAPH_CARLA_PORT_AUDIO_OUT1:

  396.         case RACK_GRAPH_CARLA_PORT_AUDIO_OUT2:

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

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

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

  400.             break;

  401. 

  402.         case RACK_GRAPH_CARLA_PORT_MIDI_IN:

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

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

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

  406.             break;

  407. 

  408.         case RACK_GRAPH_CARLA_PORT_MIDI_OUT:

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

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

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

  412.             break;

  413.         }

  414.     }

  415. 

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

  417. 

  418.     if (connCount == 0)

  419.         return nullptr;

  420. 

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

  422. 

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

  424.     {

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

  426. 

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

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

  429.     }

  430. 

  431.     retConns[connCount] = nullptr;

  432.     connList.clear();

  433. 

  434.     return retConns;

  435. }

  436. 

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

  438. {

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

  440. 

  441.     int portTest;

  442. 

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

  444.     {

  445.         groupId = RACK_GRAPH_GROUP_CARLA;

  446.         portId  = getCarlaRackPortIdFromName(fullPortName+6);

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

  448.     }

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

  450.     {

  451.         groupId  = RACK_GRAPH_GROUP_AUDIO_IN;

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

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

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

  455.     }

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

  457.     {

  458.         groupId  = RACK_GRAPH_GROUP_AUDIO_OUT;

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

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

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

  462.     }

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

  464.     {

  465.         groupId = RACK_GRAPH_GROUP_MIDI_IN;

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

  467.     }

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

  469.     {

  470.         groupId = RACK_GRAPH_GROUP_MIDI_OUT;

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

  472.     }

  473.     else

  474.     {

  475.         return false;

  476.     }

  477. 

  478.     return true;

  479. }

  480. 

  481. // -----------------------------------------------------------------------

  482. // PatchbayGraph

  483. 

  484. // TODO

  485. 

  486. PatchbayGraph::PatchbayGraph() noexcept

  487. {

  488. }

  489. 

  490. PatchbayGraph::~PatchbayGraph() noexcept

  491. {

  492.     clear();

  493. }

  494. 

  495. void PatchbayGraph::clear() noexcept

  496. {

  497. }

  498. 

  499. void PatchbayGraph::setBufferSize(const uint32_t) noexcept

  500. {

  501. }

  502. 

  503. void PatchbayGraph::setSampleRate(const double) noexcept

  504. {

  505. }

  506. 

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

  508. {

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

  510. 

  511.     return false;

  512. }

  513. 

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

  515. {

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

  517. 

  518.     return false;

  519. }

  520. 

  521. const char* const* PatchbayGraph::getConnections() const noexcept

  522. {

  523.     return nullptr;

  524. }

  525. 

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

  527. {

  528.     return false;

  529. }

  530. 

  531. // -----------------------------------------------------------------------

  532. // InternalGraph

  533. 

  534. EngineInternalGraph::EngineInternalGraph() noexcept

  535.     : isRack(true),

  536.       isReady(false),

  537.       graph(nullptr) {}

  538. 

  539. EngineInternalGraph::~EngineInternalGraph() noexcept

  540. {

  541.     CARLA_SAFE_ASSERT(graph == nullptr);

  542. }

  543. 

  544. void EngineInternalGraph::create(const double /*sampleRate*/, const uint32_t bufferSize)

  545. {

  546.     CARLA_SAFE_ASSERT_RETURN(graph == nullptr,);

  547. 

  548.     if (isRack)

  549.         graph = new RackGraph(bufferSize);

  550.     else

  551.         graph = new PatchbayGraph();

  552. }

  553. 

  554. void EngineInternalGraph::clear() noexcept

  555. {

  556.     //CARLA_SAFE_ASSERT_RETURN(graph != nullptr,);

  557.     if (graph != nullptr)

  558.     {

  559.         delete graph;

  560.         graph = nullptr;

  561.     }

  562. }

  563. 

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

  565. {

  566.     CARLA_SAFE_ASSERT_RETURN(graph != nullptr,);

  567. 

  568.     graph->setBufferSize(bufferSize);

  569. }

  570. 

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

  572. {

  573.     CARLA_SAFE_ASSERT_RETURN(graph != nullptr,);

  574. 

  575.     graph->setSampleRate(sampleRate);

  576. }

  577. 

  578. // -----------------------------------------------------------------------

  579. // CarlaEngine Patchbay stuff

  580. 

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

  582. {

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

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

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

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

  587. 

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

  589. }

  590. 

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

  592. {

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

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

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

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

  597. 

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

  599. }

  600. 

  601. bool CarlaEngine::patchbayRefresh()

  602. {

  603.     setLastError("Unsupported operation");

  604.     return false;

  605. }

  606. 

  607. // -----------------------------------------------------------------------

  608. 

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

  610. {

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

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

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

  614. 

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

  616. }

  617. 

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

  619. {

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

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

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

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

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

  625. 

  626.     uint groupA, portA;

  627.     uint groupB, portB;

  628. 

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

  630.         return;

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

  632.         return;

  633. 

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

  635. }

  636. 

  637. 

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

  639. {

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

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

  642. 

  643. #if 0

  644.     // safe copy

  645.     float inBuf0[frames];

  646.     float inBuf1[frames];

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

  648. 

  649.     // initialize audio inputs

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

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

  652. 

  653.     // initialize audio outputs (zero)

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

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

  656. 

  657.     // initialize event outputs (zero)

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

  659. 

  660.     bool processed = false;

  661. 

  662.     uint32_t oldAudioInCount = 0;

  663.     uint32_t oldMidiOutCount = 0;

  664. 

  665.     // process plugins

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

  667.     {

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

  669. 

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

  671.             continue;

  672. 

  673.         if (processed)

  674.         {

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

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

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

  678. 

  679.             // initialize audio outputs (zero)

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

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

  682. 

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

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

  685.             {

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

  687.                 {

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

  689.                 }

  690.                 // else nothing needed

  691.             }

  692.             else

  693.             {

  694.                 // initialize event inputs from previous outputs

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

  696. 

  697.                 // initialize event outputs (zero)

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

  699.             }

  700.         }

  701. 

  702.         oldAudioInCount = plugin->getAudioInCount();

  703.         oldMidiOutCount = plugin->getMidiOutCount();

  704. 

  705.         // process

  706.         plugin->initBuffers();

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

  708.         plugin->unlock();

  709. 

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

  711.         if (oldAudioInCount == 0)

  712.         {

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

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

  715.         }

  716. 

  717.         // set peaks

  718.         {

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

  720. 

  721.             juce::Range<float> range;

  722. 

  723.             if (oldAudioInCount > 0)

  724.             {

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

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

  727. 

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

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

  730.             }

  731.             else

  732.             {

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

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

  735.             }

  736. 

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

  738.             {

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

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

  741. 

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

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

  744.             }

  745.             else

  746.             {

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

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

  749.             }

  750.         }

  751. 

  752.         processed = true;

  753.     }

  754. #endif

  755. }

  756. 

  757. 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)

  758. {

  759. #if 0

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

  761. 

  762.     const CarlaMutexLocker _cml(rackAudio.mutex);

  763. 

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

  765.     {

  766.         bool noConnections = true;

  767. 

  768.         // connect input buffers

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

  770.         {

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

  772.             CARLA_SAFE_ASSERT_CONTINUE(port < inCount);

  773. 

  774.             if (noConnections)

  775.             {

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

  777.                 noConnections = false;

  778.             }

  779.             else

  780.             {

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

  782.             }

  783.         }

  784. 

  785.         if (noConnections)

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

  787. 

  788.         noConnections = true;

  789. 

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

  791.         {

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

  793.             CARLA_SAFE_ASSERT_CONTINUE(port < inCount);

  794. 

  795.             if (noConnections)

  796.             {

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

  798.                 noConnections = false;

  799.             }

  800.             else

  801.             {

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

  803.             }

  804.         }

  805. 

  806.         if (noConnections)

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

  808.     }

  809.     else

  810.     {

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

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

  813.     }

  814. 

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

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

  817. 

  818.     // process

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

  820. 

  821.     // connect output buffers

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

  823.     {

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

  825.         {

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

  827.             CARLA_SAFE_ASSERT_CONTINUE(port < outCount);

  828. 

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

  830.         }

  831.     }

  832. 

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

  834.     {

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

  836.         {

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

  838.             CARLA_SAFE_ASSERT_CONTINUE(port < outCount);

  839. 

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

  841.         }

  842.     }

  843. #endif

  844. }

  845. 

  846. // -----------------------------------------------------------------------

  847. 

  848. CARLA_BACKEND_END_NAMESPACE