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.

1290 lines
41KB

  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. #include "CarlaEngineGraph.hpp"
  18. #include "CarlaEngineInternal.hpp"
  19. #include "CarlaPlugin.hpp"
  20. #include "CarlaMathUtils.hpp"
  21. #include "CarlaMIDI.h"
  22. #include "juce_audio_processors.h"
  23. //#include "JuceInternalFilters.hpp"
  24. using juce::jmax;
  25. using juce::AudioPluginInstance;
  26. using juce::AudioProcessor;
  27. using juce::AudioProcessorEditor;
  28. using juce::FloatVectorOperations;
  29. using juce::MemoryBlock;
  30. using juce::PluginDescription;
  31. using juce::String;
  32. CARLA_BACKEND_START_NAMESPACE
  33. // -----------------------------------------------------------------------
  34. // Rack Graph stuff
  35. static inline
  36. uint getCarlaRackPortIdFromName(const char* const shortname) noexcept
  37. {
  38. if (std::strcmp(shortname, "AudioIn1") == 0 || std::strcmp(shortname, "audio-in1") == 0)
  39. return RACK_GRAPH_CARLA_PORT_AUDIO_IN1;
  40. if (std::strcmp(shortname, "AudioIn2") == 0 || std::strcmp(shortname, "audio-in2") == 0)
  41. return RACK_GRAPH_CARLA_PORT_AUDIO_IN2;
  42. if (std::strcmp(shortname, "AudioOut1") == 0 || std::strcmp(shortname, "audio-out1") == 0)
  43. return RACK_GRAPH_CARLA_PORT_AUDIO_OUT1;
  44. if (std::strcmp(shortname, "AudioOut2") == 0 || std::strcmp(shortname, "audio-out2") == 0)
  45. return RACK_GRAPH_CARLA_PORT_AUDIO_OUT2;
  46. if (std::strcmp(shortname, "MidiIn") == 0 || std::strcmp(shortname, "midi-in") == 0)
  47. return RACK_GRAPH_CARLA_PORT_MIDI_IN;
  48. if (std::strcmp(shortname, "MidiOut") == 0 || std::strcmp(shortname, "midi-out") == 0)
  49. return RACK_GRAPH_CARLA_PORT_MIDI_OUT;
  50. carla_stderr("CarlaBackend::getCarlaRackPortIdFromName(%s) - invalid short name", shortname);
  51. return RACK_GRAPH_CARLA_PORT_NULL;
  52. }
  53. static inline
  54. const char* getCarlaRackFullPortNameFromId(const /*RackGraphCarlaPortIds*/ uint portId)
  55. {
  56. switch (portId)
  57. {
  58. case RACK_GRAPH_CARLA_PORT_AUDIO_IN1:
  59. return "Carla:AudioIn1";
  60. case RACK_GRAPH_CARLA_PORT_AUDIO_IN2:
  61. return "Carla:AudioIn2";
  62. case RACK_GRAPH_CARLA_PORT_AUDIO_OUT1:
  63. return "Carla:AudioOut1";
  64. case RACK_GRAPH_CARLA_PORT_AUDIO_OUT2:
  65. return "Carla:AudioOut2";
  66. case RACK_GRAPH_CARLA_PORT_MIDI_IN:
  67. return "Carla:MidiIn";
  68. case RACK_GRAPH_CARLA_PORT_MIDI_OUT:
  69. return "Carla:MidiOut";
  70. //case RACK_GRAPH_CARLA_PORT_NULL:
  71. //case RACK_GRAPH_CARLA_PORT_MAX:
  72. // break;
  73. }
  74. carla_stderr("CarlaBackend::getCarlaRackFullPortNameFromId(%i) - invalid port id", portId);
  75. return nullptr;
  76. }
  77. // -----------------------------------------------------------------------
  78. // RackGraph MIDI
  79. const char* RackGraph::MIDI::getName(const bool isInput, const uint portId) const noexcept
  80. {
  81. for (LinkedList<PortNameToId>::Itenerator it = isInput ? ins.begin() : outs.begin(); it.valid(); it.next())
  82. {
  83. const PortNameToId& port(it.getValue());
  84. if (port.port == portId)
  85. return port.name;
  86. }
  87. return nullptr;
  88. }
  89. uint RackGraph::MIDI::getPortId(const bool isInput, const char portName[], bool* const ok) const noexcept
  90. {
  91. for (LinkedList<PortNameToId>::Itenerator it = isInput ? ins.begin() : outs.begin(); it.valid(); it.next())
  92. {
  93. const PortNameToId& port(it.getValue());
  94. if (std::strcmp(port.name, portName) == 0)
  95. {
  96. if (ok != nullptr)
  97. *ok = true;
  98. return port.port;
  99. }
  100. }
  101. if (ok != nullptr)
  102. *ok = false;
  103. return 0;
  104. }
  105. // -----------------------------------------------------------------------
  106. // RackGraph
  107. RackGraph::RackGraph(const uint32_t bufferSize, const uint32_t ins, const uint32_t outs) noexcept
  108. : inputs(ins),
  109. outputs(outs),
  110. isOffline(false)
  111. {
  112. audio.inBuf[0] = audio.inBuf[1] = nullptr;
  113. audio.inBufTmp[0] = audio.inBufTmp[1] = nullptr;
  114. audio.outBuf[0] = audio.outBuf[1] = nullptr;
  115. setBufferSize(bufferSize);
  116. }
  117. RackGraph::~RackGraph() noexcept
  118. {
  119. clearConnections();
  120. }
  121. void RackGraph::setBufferSize(const uint32_t bufferSize) noexcept
  122. {
  123. const int bufferSizei(static_cast<int>(bufferSize));
  124. if (audio.inBuf[0] != nullptr) { delete[] audio.inBuf[0]; audio.inBuf[0] = nullptr; }
  125. if (audio.inBuf[1] != nullptr) { delete[] audio.inBuf[1]; audio.inBuf[1] = nullptr; }
  126. if (audio.inBufTmp[0] != nullptr) { delete[] audio.inBufTmp[0]; audio.inBufTmp[0] = nullptr; }
  127. if (audio.inBufTmp[1] != nullptr) { delete[] audio.inBufTmp[1]; audio.inBufTmp[1] = nullptr; }
  128. if (audio.outBuf[0] != nullptr) { delete[] audio.outBuf[0]; audio.outBuf[0] = nullptr; }
  129. if (audio.outBuf[1] != nullptr) { delete[] audio.outBuf[1]; audio.outBuf[1] = nullptr; }
  130. try {
  131. audio.inBufTmp[0] = new float[bufferSize];
  132. audio.inBufTmp[1] = new float[bufferSize];
  133. if (inputs > 0 || outputs > 0)
  134. {
  135. audio.inBuf[0] = new float[bufferSize];
  136. audio.inBuf[1] = new float[bufferSize];
  137. audio.outBuf[0] = new float[bufferSize];
  138. audio.outBuf[1] = new float[bufferSize];
  139. }
  140. }
  141. catch(...) {
  142. if (audio.inBufTmp[0] != nullptr) { delete[] audio.inBufTmp[0]; audio.inBufTmp[0] = nullptr; }
  143. if (audio.inBufTmp[1] != nullptr) { delete[] audio.inBufTmp[1]; audio.inBufTmp[1] = nullptr; }
  144. if (inputs > 0 || outputs > 0)
  145. {
  146. if (audio.inBuf[0] != nullptr) { delete[] audio.inBuf[0]; audio.inBuf[0] = nullptr; }
  147. if (audio.inBuf[1] != nullptr) { delete[] audio.inBuf[1]; audio.inBuf[1] = nullptr; }
  148. if (audio.outBuf[0] != nullptr) { delete[] audio.outBuf[0]; audio.outBuf[0] = nullptr; }
  149. if (audio.outBuf[1] != nullptr) { delete[] audio.outBuf[1]; audio.outBuf[1] = nullptr; }
  150. }
  151. return;
  152. }
  153. FloatVectorOperations::clear(audio.inBufTmp[0], bufferSizei);
  154. FloatVectorOperations::clear(audio.inBufTmp[1], bufferSizei);
  155. if (inputs > 0 || outputs > 0)
  156. {
  157. FloatVectorOperations::clear(audio.inBuf[0], bufferSizei);
  158. FloatVectorOperations::clear(audio.inBuf[1], bufferSizei);
  159. FloatVectorOperations::clear(audio.outBuf[0], bufferSizei);
  160. FloatVectorOperations::clear(audio.outBuf[1], bufferSizei);
  161. }
  162. }
  163. void RackGraph::setOffline(const bool offline) noexcept
  164. {
  165. isOffline = offline;
  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. uint otherGroup, otherPort, carlaPort;
  171. if (groupA == RACK_GRAPH_GROUP_CARLA)
  172. {
  173. CARLA_SAFE_ASSERT_RETURN(groupB != RACK_GRAPH_GROUP_CARLA, false);
  174. carlaPort = portA;
  175. otherGroup = groupB;
  176. otherPort = portB;
  177. }
  178. else
  179. {
  180. CARLA_SAFE_ASSERT_RETURN(groupB == RACK_GRAPH_GROUP_CARLA, false);
  181. carlaPort = portB;
  182. otherGroup = groupA;
  183. otherPort = portA;
  184. }
  185. CARLA_SAFE_ASSERT_RETURN(carlaPort > RACK_GRAPH_CARLA_PORT_NULL && carlaPort < RACK_GRAPH_CARLA_PORT_MAX, false);
  186. CARLA_SAFE_ASSERT_RETURN(otherGroup > RACK_GRAPH_GROUP_CARLA && otherGroup < RACK_GRAPH_GROUP_MAX, false);
  187. bool makeConnection = false;
  188. switch (carlaPort)
  189. {
  190. case RACK_GRAPH_CARLA_PORT_AUDIO_IN1:
  191. CARLA_SAFE_ASSERT_RETURN(otherGroup == RACK_GRAPH_GROUP_AUDIO_IN, false);
  192. audio.mutex.lock();
  193. makeConnection = audio.connectedIn1.append(otherPort);
  194. audio.mutex.unlock();
  195. break;
  196. case RACK_GRAPH_CARLA_PORT_AUDIO_IN2:
  197. CARLA_SAFE_ASSERT_RETURN(otherGroup == RACK_GRAPH_GROUP_AUDIO_IN, false);
  198. audio.mutex.lock();
  199. makeConnection = audio.connectedIn2.append(otherPort);
  200. audio.mutex.unlock();
  201. break;
  202. case RACK_GRAPH_CARLA_PORT_AUDIO_OUT1:
  203. CARLA_SAFE_ASSERT_RETURN(otherGroup == RACK_GRAPH_GROUP_AUDIO_OUT, false);
  204. audio.mutex.lock();
  205. makeConnection = audio.connectedOut1.append(otherPort);
  206. audio.mutex.unlock();
  207. break;
  208. case RACK_GRAPH_CARLA_PORT_AUDIO_OUT2:
  209. CARLA_SAFE_ASSERT_RETURN(otherGroup == RACK_GRAPH_GROUP_AUDIO_OUT, false);
  210. audio.mutex.lock();
  211. makeConnection = audio.connectedOut2.append(otherPort);
  212. audio.mutex.unlock();
  213. break;
  214. case RACK_GRAPH_CARLA_PORT_MIDI_IN:
  215. CARLA_SAFE_ASSERT_RETURN(otherGroup == RACK_GRAPH_GROUP_MIDI_IN, false);
  216. if (const char* const portName = midi.getName(true, otherPort))
  217. makeConnection = engine->connectRackMidiInPort(portName);
  218. break;
  219. case RACK_GRAPH_CARLA_PORT_MIDI_OUT:
  220. CARLA_SAFE_ASSERT_RETURN(otherGroup == RACK_GRAPH_GROUP_MIDI_OUT, false);
  221. if (const char* const portName = midi.getName(false, otherPort))
  222. makeConnection = engine->connectRackMidiOutPort(portName);
  223. break;
  224. }
  225. if (! makeConnection)
  226. {
  227. engine->setLastError("Invalid rack connection");
  228. return false;
  229. }
  230. ConnectionToId connectionToId;
  231. connectionToId.setData(++connections.lastId, groupA, portA, groupB, portB);
  232. char strBuf[STR_MAX+1];
  233. strBuf[STR_MAX] = '\0';
  234. std::snprintf(strBuf, STR_MAX, "%u:%u:%u:%u", groupA, portA, groupB, portB);
  235. engine->callback(ENGINE_CALLBACK_PATCHBAY_CONNECTION_ADDED, connectionToId.id, 0, 0, 0.0f, strBuf);
  236. connections.list.append(connectionToId);
  237. return true;
  238. }
  239. bool RackGraph::disconnect(CarlaEngine* const engine, const uint connectionId) noexcept
  240. {
  241. CARLA_SAFE_ASSERT_RETURN(engine != nullptr, false);
  242. CARLA_SAFE_ASSERT_RETURN(connections.list.count() > 0, false);
  243. for (LinkedList<ConnectionToId>::Itenerator it=connections.list.begin(); it.valid(); it.next())
  244. {
  245. const ConnectionToId& connection(it.getValue());
  246. if (connection.id != connectionId)
  247. continue;
  248. uint otherGroup, otherPort, carlaPort;
  249. if (connection.groupA == RACK_GRAPH_GROUP_CARLA)
  250. {
  251. CARLA_SAFE_ASSERT_RETURN(connection.groupB != RACK_GRAPH_GROUP_CARLA, false);
  252. carlaPort = connection.portA;
  253. otherGroup = connection.groupB;
  254. otherPort = connection.portB;
  255. }
  256. else
  257. {
  258. CARLA_SAFE_ASSERT_RETURN(connection.groupB == RACK_GRAPH_GROUP_CARLA, false);
  259. carlaPort = connection.portB;
  260. otherGroup = connection.groupA;
  261. otherPort = connection.portA;
  262. }
  263. CARLA_SAFE_ASSERT_RETURN(carlaPort > RACK_GRAPH_CARLA_PORT_NULL && carlaPort < RACK_GRAPH_CARLA_PORT_MAX, false);
  264. CARLA_SAFE_ASSERT_RETURN(otherGroup > RACK_GRAPH_GROUP_CARLA && otherGroup < RACK_GRAPH_GROUP_MAX, false);
  265. bool makeDisconnection = false;
  266. switch (carlaPort)
  267. {
  268. case RACK_GRAPH_CARLA_PORT_AUDIO_IN1:
  269. audio.mutex.lock();
  270. makeDisconnection = audio.connectedIn1.removeOne(otherPort);
  271. audio.mutex.unlock();
  272. break;
  273. case RACK_GRAPH_CARLA_PORT_AUDIO_IN2:
  274. audio.mutex.lock();
  275. makeDisconnection = audio.connectedIn2.removeOne(otherPort);
  276. audio.mutex.unlock();
  277. break;
  278. case RACK_GRAPH_CARLA_PORT_AUDIO_OUT1:
  279. audio.mutex.lock();
  280. makeDisconnection = audio.connectedOut1.removeOne(otherPort);
  281. audio.mutex.unlock();
  282. break;
  283. case RACK_GRAPH_CARLA_PORT_AUDIO_OUT2:
  284. audio.mutex.lock();
  285. makeDisconnection = audio.connectedOut2.removeOne(otherPort);
  286. audio.mutex.unlock();
  287. break;
  288. case RACK_GRAPH_CARLA_PORT_MIDI_IN:
  289. if (const char* const portName = midi.getName(true, otherPort))
  290. makeDisconnection = engine->disconnectRackMidiInPort(portName);
  291. break;
  292. case RACK_GRAPH_CARLA_PORT_MIDI_OUT:
  293. if (const char* const portName = midi.getName(false, otherPort))
  294. makeDisconnection = engine->disconnectRackMidiOutPort(portName);
  295. break;
  296. }
  297. if (! makeDisconnection)
  298. {
  299. engine->setLastError("Invalid rack connection");
  300. return false;
  301. }
  302. engine->callback(ENGINE_CALLBACK_PATCHBAY_CONNECTION_REMOVED, connection.id, 0, 0, 0.0f, nullptr);
  303. connections.list.remove(it);
  304. return true;
  305. }
  306. engine->setLastError("Failed to find connection");
  307. return false;
  308. }
  309. void RackGraph::clearConnections() noexcept
  310. {
  311. connections.clear();
  312. audio.mutex.lock();
  313. audio.connectedIn1.clear();
  314. audio.connectedIn2.clear();
  315. audio.connectedOut1.clear();
  316. audio.connectedOut2.clear();
  317. audio.mutex.unlock();
  318. midi.ins.clear();
  319. midi.outs.clear();
  320. }
  321. const char* const* RackGraph::getConnections() const noexcept
  322. {
  323. if (connections.list.count() == 0)
  324. return nullptr;
  325. CarlaStringList connList;
  326. char strBuf[STR_MAX+1];
  327. strBuf[STR_MAX] = '\0';
  328. for (LinkedList<ConnectionToId>::Itenerator it=connections.list.begin(); it.valid(); it.next())
  329. {
  330. const ConnectionToId& connection(it.getValue());
  331. uint otherGroup, otherPort, carlaPort;
  332. if (connection.groupA == RACK_GRAPH_GROUP_CARLA)
  333. {
  334. CARLA_SAFE_ASSERT_CONTINUE(connection.groupB != RACK_GRAPH_GROUP_CARLA);
  335. carlaPort = connection.portA;
  336. otherGroup = connection.groupB;
  337. otherPort = connection.portB;
  338. }
  339. else
  340. {
  341. CARLA_SAFE_ASSERT_CONTINUE(connection.groupB == RACK_GRAPH_GROUP_CARLA);
  342. carlaPort = connection.portB;
  343. otherGroup = connection.groupA;
  344. otherPort = connection.portA;
  345. }
  346. CARLA_SAFE_ASSERT_CONTINUE(carlaPort > RACK_GRAPH_CARLA_PORT_NULL && carlaPort < RACK_GRAPH_CARLA_PORT_MAX);
  347. CARLA_SAFE_ASSERT_CONTINUE(otherGroup > RACK_GRAPH_GROUP_CARLA && otherGroup < RACK_GRAPH_GROUP_MAX);
  348. switch (carlaPort)
  349. {
  350. case RACK_GRAPH_CARLA_PORT_AUDIO_IN1:
  351. case RACK_GRAPH_CARLA_PORT_AUDIO_IN2:
  352. std::snprintf(strBuf, STR_MAX, "AudioIn:%i", otherPort+1);
  353. connList.append(strBuf);
  354. connList.append(getCarlaRackFullPortNameFromId(carlaPort));
  355. break;
  356. case RACK_GRAPH_CARLA_PORT_AUDIO_OUT1:
  357. case RACK_GRAPH_CARLA_PORT_AUDIO_OUT2:
  358. std::snprintf(strBuf, STR_MAX, "AudioOut:%i", otherPort+1);
  359. connList.append(getCarlaRackFullPortNameFromId(carlaPort));
  360. connList.append(strBuf);
  361. break;
  362. case RACK_GRAPH_CARLA_PORT_MIDI_IN:
  363. std::snprintf(strBuf, STR_MAX, "MidiIn:%s", midi.getName(true, otherPort));
  364. connList.append(strBuf);
  365. connList.append(getCarlaRackFullPortNameFromId(carlaPort));
  366. break;
  367. case RACK_GRAPH_CARLA_PORT_MIDI_OUT:
  368. std::snprintf(strBuf, STR_MAX, "MidiOut:%s", midi.getName(false, otherPort));
  369. connList.append(getCarlaRackFullPortNameFromId(carlaPort));
  370. connList.append(strBuf);
  371. break;
  372. }
  373. }
  374. if (connList.count() == 0)
  375. return nullptr;
  376. retCon = connList.toCharStringListPtr();
  377. return retCon;
  378. }
  379. bool RackGraph::getGroupAndPortIdFromFullName(const char* const fullPortName, uint& groupId, uint& portId) const noexcept
  380. {
  381. CARLA_SAFE_ASSERT_RETURN(fullPortName != nullptr && fullPortName[0] != '\0', false);
  382. if (std::strncmp(fullPortName, "Carla:", 6) == 0)
  383. {
  384. groupId = RACK_GRAPH_GROUP_CARLA;
  385. portId = getCarlaRackPortIdFromName(fullPortName+6);
  386. if (portId > RACK_GRAPH_CARLA_PORT_NULL && portId < RACK_GRAPH_CARLA_PORT_MAX)
  387. return true;
  388. }
  389. else if (std::strncmp(fullPortName, "AudioIn:", 8) == 0)
  390. {
  391. groupId = RACK_GRAPH_GROUP_AUDIO_IN;
  392. if (const int portTest = std::atoi(fullPortName+8))
  393. {
  394. portId = static_cast<uint>(portTest-1);
  395. return true;
  396. }
  397. }
  398. else if (std::strncmp(fullPortName, "AudioOut:", 9) == 0)
  399. {
  400. groupId = RACK_GRAPH_GROUP_AUDIO_OUT;
  401. if (const int portTest = std::atoi(fullPortName+9))
  402. {
  403. portId = static_cast<uint>(portTest-1);
  404. return true;
  405. }
  406. }
  407. else if (std::strncmp(fullPortName, "MidiIn:", 7) == 0)
  408. {
  409. groupId = RACK_GRAPH_GROUP_MIDI_IN;
  410. if (const char* const portName = fullPortName+7)
  411. {
  412. bool ok;
  413. portId = midi.getPortId(true, portName, &ok);
  414. return ok;
  415. }
  416. }
  417. else if (std::strncmp(fullPortName, "MidiOut:", 8) == 0)
  418. {
  419. groupId = RACK_GRAPH_GROUP_MIDI_OUT;
  420. if (const char* const portName = fullPortName+8)
  421. {
  422. bool ok;
  423. portId = midi.getPortId(false, portName, &ok);
  424. return ok;
  425. }
  426. }
  427. return false;
  428. }
  429. void RackGraph::process(CarlaEngine::ProtectedData* const data, const float* inBufReal[2], float* outBuf[2], const uint32_t frames)
  430. {
  431. CARLA_SAFE_ASSERT_RETURN(data != nullptr,);
  432. CARLA_SAFE_ASSERT_RETURN(data->events.in != nullptr,);
  433. CARLA_SAFE_ASSERT_RETURN(data->events.out != nullptr,);
  434. const int iframes(static_cast<int>(frames));
  435. // safe copy
  436. float inBuf0[frames];
  437. float inBuf1[frames];
  438. float* inBuf[2] = { inBuf0, inBuf1 };
  439. // initialize audio inputs
  440. FloatVectorOperations::copy(inBuf0, inBufReal[0], iframes);
  441. FloatVectorOperations::copy(inBuf1, inBufReal[1], iframes);
  442. // initialize audio outputs (zero)
  443. FloatVectorOperations::clear(outBuf[0], iframes);
  444. FloatVectorOperations::clear(outBuf[1], iframes);
  445. // initialize event outputs (zero)
  446. carla_zeroStruct<EngineEvent>(data->events.out, kMaxEngineEventInternalCount);
  447. bool processed = false;
  448. uint32_t oldAudioInCount = 0;
  449. uint32_t oldMidiOutCount = 0;
  450. // process plugins
  451. for (uint i=0; i < data->curPluginCount; ++i)
  452. {
  453. CarlaPlugin* const plugin = data->plugins[i].plugin;
  454. if (plugin == nullptr || ! plugin->isEnabled() || ! plugin->tryLock(isOffline))
  455. continue;
  456. if (processed)
  457. {
  458. // initialize audio inputs (from previous outputs)
  459. FloatVectorOperations::copy(inBuf0, outBuf[0], iframes);
  460. FloatVectorOperations::copy(inBuf1, outBuf[1], iframes);
  461. // initialize audio outputs (zero)
  462. FloatVectorOperations::clear(outBuf[0], iframes);
  463. FloatVectorOperations::clear(outBuf[1], iframes);
  464. // if plugin has no midi out, add previous events
  465. if (oldMidiOutCount == 0 && data->events.in[0].type != kEngineEventTypeNull)
  466. {
  467. if (data->events.out[0].type != kEngineEventTypeNull)
  468. {
  469. // TODO: carefully add to input, sorted events
  470. }
  471. // else nothing needed
  472. }
  473. else
  474. {
  475. // initialize event inputs from previous outputs
  476. carla_copyStruct<EngineEvent>(data->events.in, data->events.out, kMaxEngineEventInternalCount);
  477. // initialize event outputs (zero)
  478. carla_zeroStruct<EngineEvent>(data->events.out, kMaxEngineEventInternalCount);
  479. }
  480. }
  481. oldAudioInCount = plugin->getAudioInCount();
  482. oldMidiOutCount = plugin->getMidiOutCount();
  483. // process
  484. plugin->initBuffers();
  485. plugin->process(inBuf, outBuf, frames);
  486. plugin->unlock();
  487. // if plugin has no audio inputs, add input buffer
  488. if (oldAudioInCount == 0)
  489. {
  490. FloatVectorOperations::add(outBuf[0], inBuf0, iframes);
  491. FloatVectorOperations::add(outBuf[1], inBuf1, iframes);
  492. }
  493. // set peaks
  494. {
  495. EnginePluginData& pluginData(data->plugins[i]);
  496. juce::Range<float> range;
  497. if (oldAudioInCount > 0)
  498. {
  499. range = FloatVectorOperations::findMinAndMax(inBuf0, iframes);
  500. pluginData.insPeak[0] = carla_max<float>(std::abs(range.getStart()), std::abs(range.getEnd()), 1.0f);
  501. range = FloatVectorOperations::findMinAndMax(inBuf1, iframes);
  502. pluginData.insPeak[1] = carla_max<float>(std::abs(range.getStart()), std::abs(range.getEnd()), 1.0f);
  503. }
  504. else
  505. {
  506. pluginData.insPeak[0] = 0.0f;
  507. pluginData.insPeak[1] = 0.0f;
  508. }
  509. if (plugin->getAudioOutCount() > 0)
  510. {
  511. range = FloatVectorOperations::findMinAndMax(outBuf[0], iframes);
  512. pluginData.outsPeak[0] = carla_max<float>(std::abs(range.getStart()), std::abs(range.getEnd()), 1.0f);
  513. range = FloatVectorOperations::findMinAndMax(outBuf[1], iframes);
  514. pluginData.outsPeak[1] = carla_max<float>(std::abs(range.getStart()), std::abs(range.getEnd()), 1.0f);
  515. }
  516. else
  517. {
  518. pluginData.outsPeak[0] = 0.0f;
  519. pluginData.outsPeak[1] = 0.0f;
  520. }
  521. }
  522. processed = true;
  523. }
  524. }
  525. void RackGraph::processHelper(CarlaEngine::ProtectedData* const data, const float* const* const inBuf, float* const* const outBuf, const uint32_t frames)
  526. {
  527. CARLA_SAFE_ASSERT_RETURN(audio.outBuf[1] != nullptr,);
  528. const int iframes(static_cast<int>(frames));
  529. const CarlaRecursiveMutexLocker _cml(audio.mutex);
  530. if (inBuf != nullptr && inputs > 0)
  531. {
  532. bool noConnections = true;
  533. // connect input buffers
  534. for (LinkedList<uint>::Itenerator it = audio.connectedIn1.begin(); it.valid(); it.next())
  535. {
  536. const uint& port(it.getValue());
  537. CARLA_SAFE_ASSERT_CONTINUE(port < inputs);
  538. if (noConnections)
  539. {
  540. FloatVectorOperations::copy(audio.inBuf[0], inBuf[port], iframes);
  541. noConnections = false;
  542. }
  543. else
  544. {
  545. FloatVectorOperations::add(audio.inBuf[0], inBuf[port], iframes);
  546. }
  547. }
  548. if (noConnections)
  549. FloatVectorOperations::clear(audio.inBuf[0], iframes);
  550. noConnections = true;
  551. for (LinkedList<uint>::Itenerator it = audio.connectedIn2.begin(); it.valid(); it.next())
  552. {
  553. const uint& port(it.getValue());
  554. CARLA_SAFE_ASSERT_CONTINUE(port < inputs);
  555. if (noConnections)
  556. {
  557. FloatVectorOperations::copy(audio.inBuf[1], inBuf[port], iframes);
  558. noConnections = false;
  559. }
  560. else
  561. {
  562. FloatVectorOperations::add(audio.inBuf[1], inBuf[port], iframes);
  563. }
  564. }
  565. if (noConnections)
  566. FloatVectorOperations::clear(audio.inBuf[1], iframes);
  567. }
  568. else
  569. {
  570. FloatVectorOperations::clear(audio.inBuf[0], iframes);
  571. FloatVectorOperations::clear(audio.inBuf[1], iframes);
  572. }
  573. FloatVectorOperations::clear(audio.outBuf[0], iframes);
  574. FloatVectorOperations::clear(audio.outBuf[1], iframes);
  575. // process
  576. process(data, const_cast<const float**>(audio.inBuf), audio.outBuf, frames);
  577. // connect output buffers
  578. if (audio.connectedOut1.count() != 0)
  579. {
  580. for (LinkedList<uint>::Itenerator it = audio.connectedOut1.begin(); it.valid(); it.next())
  581. {
  582. const uint& port(it.getValue());
  583. CARLA_SAFE_ASSERT_CONTINUE(port < outputs);
  584. FloatVectorOperations::add(outBuf[port], audio.outBuf[0], iframes);
  585. }
  586. }
  587. if (audio.connectedOut2.count() != 0)
  588. {
  589. for (LinkedList<uint>::Itenerator it = audio.connectedOut2.begin(); it.valid(); it.next())
  590. {
  591. const uint& port(it.getValue());
  592. CARLA_SAFE_ASSERT_CONTINUE(port < outputs);
  593. FloatVectorOperations::add(outBuf[port], audio.outBuf[1], iframes);
  594. }
  595. }
  596. }
  597. // -----------------------------------------------------------------------
  598. class CarlaPluginInstance : public AudioPluginInstance
  599. {
  600. public:
  601. CarlaPluginInstance(CarlaPlugin* const plugin)
  602. : fPlugin(plugin),
  603. fGraph(nullptr) {}
  604. ~CarlaPluginInstance() override
  605. {
  606. }
  607. // -------------------------------------------------------------------
  608. AudioProcessorGraph* getParentGraph() const noexcept
  609. {
  610. return fGraph;
  611. }
  612. void setParentGraph(AudioProcessorGraph*)
  613. {
  614. }
  615. void* getPlatformSpecificData() noexcept override
  616. {
  617. return fPlugin;
  618. }
  619. void fillInPluginDescription(PluginDescription& d) const override
  620. {
  621. d.pluginFormatName = "Carla";
  622. d.category = "Carla Plugin";
  623. d.version = "1.0";
  624. CARLA_SAFE_ASSERT_RETURN(fPlugin != nullptr,);
  625. char strBuf[STR_MAX+1];
  626. strBuf[STR_MAX] = '\0';
  627. fPlugin->getRealName(strBuf);
  628. d.name = strBuf;
  629. fPlugin->getLabel(strBuf);
  630. d.descriptiveName = strBuf;
  631. fPlugin->getMaker(strBuf);
  632. d.manufacturerName = strBuf;
  633. d.uid = d.name.hashCode();
  634. d.isInstrument = (fPlugin->getHints() & PLUGIN_IS_SYNTH);
  635. d.numInputChannels = static_cast<int>(fPlugin->getAudioInCount());
  636. d.numOutputChannels = static_cast<int>(fPlugin->getAudioOutCount());
  637. //d.hasSharedContainer = true;
  638. }
  639. // -------------------------------------------------------------------
  640. const String getName() const override
  641. {
  642. return fPlugin->getName();
  643. }
  644. void processBlock(AudioSampleBuffer& audio, MidiBuffer& midi)
  645. {
  646. if (CarlaEngineEventPort* const port = fPlugin->getDefaultEventInPort())
  647. {
  648. EngineEvent* const engineEvents(port->fBuffer);
  649. CARLA_SAFE_ASSERT_RETURN(engineEvents != nullptr,);
  650. carla_zeroStruct<EngineEvent>(engineEvents, kMaxEngineEventInternalCount);
  651. fillEngineEventsFromJuceMidiBuffer(engineEvents, midi);
  652. }
  653. const uint32_t bufferSize(static_cast<uint32_t>(audio.getNumSamples()));
  654. if (const int numChan = audio.getNumChannels())
  655. {
  656. float* audioBuffers[numChan];
  657. for (int i=0; i<numChan; ++i)
  658. audioBuffers[i] = audio.getWritePointer(i);
  659. fPlugin->process(audioBuffers, audioBuffers, bufferSize);
  660. }
  661. else
  662. {
  663. fPlugin->process(nullptr, nullptr, bufferSize);
  664. }
  665. midi.clear();
  666. if (CarlaEngineEventPort* const port = fPlugin->getDefaultEventOutPort())
  667. {
  668. const EngineEvent* const engineEvents(port->fBuffer);
  669. CARLA_SAFE_ASSERT_RETURN(engineEvents != nullptr,);
  670. fillJuceMidiBufferFromEngineEvents(midi, engineEvents);
  671. }
  672. }
  673. void prepareToPlay(double, int) override {}
  674. void releaseResources() override {}
  675. const String getInputChannelName(int) const override { return String(); }
  676. const String getOutputChannelName(int) const override { return String(); }
  677. const String getParameterName(int) override { return String(); }
  678. String getParameterName(int, int) override { return String(); }
  679. const String getParameterText(int) override { return String(); }
  680. String getParameterText(int, int) override { return String(); }
  681. const String getProgramName(int) override { return String(); }
  682. double getTailLengthSeconds() const override { return 0.0; }
  683. float getParameter(int) override { return 0.0f; }
  684. bool isInputChannelStereoPair(int) const override { return true; }
  685. bool isOutputChannelStereoPair(int) const override { return true; }
  686. bool silenceInProducesSilenceOut() const override { return true; }
  687. bool hasEditor() const override { return false; }
  688. bool acceptsMidi() const override { return fPlugin->getMidiInCount() > 0; }
  689. bool producesMidi() const override { return fPlugin->getMidiOutCount() > 0; }
  690. void setParameter(int, float) override {}
  691. void setCurrentProgram(int) override {}
  692. void changeProgramName(int, const String&) override {}
  693. void getStateInformation(MemoryBlock&) override {}
  694. void setStateInformation(const void*, int) override {}
  695. int getNumParameters() override { return 0; }
  696. int getNumPrograms() override { return 0; }
  697. int getCurrentProgram() override { return 0; }
  698. AudioProcessorEditor* createEditor() override { return nullptr; }
  699. // -------------------------------------------------------------------
  700. private:
  701. CarlaPlugin* const fPlugin;
  702. AudioProcessorGraph* fGraph;
  703. };
  704. // -----------------------------------------------------------------------
  705. // PatchbayGraph
  706. static const int kMidiInputNodeId = MAX_PATCHBAY_PLUGINS*3+1;
  707. static const int kMidiOutputNodeId = MAX_PATCHBAY_PLUGINS*3+2;
  708. PatchbayGraph::PatchbayGraph(const int bufferSize, const double sampleRate, const uint32_t ins, const uint32_t outs)
  709. : inputs(static_cast<int>(ins)),
  710. outputs(static_cast<int>(outs))
  711. {
  712. graph.setPlayConfigDetails(inputs, outputs, sampleRate, bufferSize);
  713. graph.prepareToPlay(sampleRate, bufferSize);
  714. audioBuffer.setSize(jmax(inputs, outputs), bufferSize);
  715. midiBuffer.ensureSize(kMaxEngineEventInternalCount*2);
  716. midiBuffer.clear();
  717. for (uint32_t i=0; i<ins && i<MAX_PATCHBAY_PLUGINS; ++i)
  718. {
  719. AudioProcessorGraph::AudioGraphIOProcessor* const proc(new AudioProcessorGraph::AudioGraphIOProcessor(AudioProcessorGraph::AudioGraphIOProcessor::audioInputNode));
  720. graph.addNode(proc, MAX_PATCHBAY_PLUGINS + i);
  721. }
  722. for (uint32_t i=0; i<outs && i<MAX_PATCHBAY_PLUGINS; ++i)
  723. {
  724. AudioProcessorGraph::AudioGraphIOProcessor* const proc(new AudioProcessorGraph::AudioGraphIOProcessor(AudioProcessorGraph::AudioGraphIOProcessor::audioOutputNode));
  725. graph.addNode(proc, MAX_PATCHBAY_PLUGINS*2 + i);
  726. }
  727. {
  728. AudioProcessorGraph::AudioGraphIOProcessor* const proc(new AudioProcessorGraph::AudioGraphIOProcessor(AudioProcessorGraph::AudioGraphIOProcessor::midiInputNode));
  729. graph.addNode(proc, kMidiInputNodeId);
  730. }
  731. {
  732. AudioProcessorGraph::AudioGraphIOProcessor* const proc(new AudioProcessorGraph::AudioGraphIOProcessor(AudioProcessorGraph::AudioGraphIOProcessor::midiOutputNode));
  733. graph.addNode(proc, kMidiOutputNodeId);
  734. }
  735. }
  736. PatchbayGraph::~PatchbayGraph()
  737. {
  738. graph.releaseResources();
  739. graph.clear();
  740. audioBuffer.clear();
  741. }
  742. void PatchbayGraph::setBufferSize(const int bufferSize)
  743. {
  744. graph.releaseResources();
  745. graph.prepareToPlay(graph.getSampleRate(), bufferSize);
  746. audioBuffer.setSize(audioBuffer.getNumChannels(), bufferSize);
  747. }
  748. void PatchbayGraph::setSampleRate(const double sampleRate)
  749. {
  750. graph.releaseResources();
  751. graph.prepareToPlay(sampleRate, graph.getBlockSize());
  752. }
  753. void PatchbayGraph::setOffline(const bool offline)
  754. {
  755. graph.setNonRealtime(offline);
  756. }
  757. void PatchbayGraph::addPlugin(CarlaPlugin* const plugin)
  758. {
  759. CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);
  760. CarlaPluginInstance* const instance(new CarlaPluginInstance(plugin));
  761. graph.addNode(instance, plugin->getId());
  762. }
  763. void PatchbayGraph::replacePlugin(CarlaPlugin* const oldPlugin, CarlaPlugin* const newPlugin)
  764. {
  765. CARLA_SAFE_ASSERT_RETURN(oldPlugin != nullptr,);
  766. CARLA_SAFE_ASSERT_RETURN(newPlugin != nullptr,);
  767. CARLA_SAFE_ASSERT_RETURN(oldPlugin != newPlugin,);
  768. CARLA_SAFE_ASSERT_RETURN(oldPlugin->getId() == newPlugin->getId(),);
  769. CarlaPluginInstance* const instance(new CarlaPluginInstance(newPlugin));
  770. graph.addNode(instance, newPlugin->getId());
  771. }
  772. void PatchbayGraph::removePlugin(CarlaPlugin* const plugin)
  773. {
  774. CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);
  775. graph.removeNode(plugin->getId());
  776. // move all plugins 1 spot backwards
  777. for (uint i=plugin->getId(); i<MAX_PATCHBAY_PLUGINS; ++i)
  778. {
  779. if (AudioProcessorGraph::Node* const node = graph.getNodeForId(i+1))
  780. {
  781. if (AudioProcessor* const proc = node->getProcessor())
  782. graph.addNode(proc, i);
  783. continue;
  784. }
  785. break;
  786. }
  787. }
  788. void PatchbayGraph::removeAllPlugins()
  789. {
  790. graph.clear();
  791. // TODO
  792. }
  793. #if 0
  794. bool PatchbayGraph::connect(CarlaEngine* const engine, const uint /*groupA*/, const uint /*portA*/, const uint /*groupB*/, const uint /*portB*/) noexcept
  795. {
  796. CARLA_SAFE_ASSERT_RETURN(engine != nullptr, false);
  797. return false;
  798. }
  799. bool PatchbayGraph::disconnect(CarlaEngine* const engine, const uint /*connectionId*/) noexcept
  800. {
  801. CARLA_SAFE_ASSERT_RETURN(engine != nullptr, false);
  802. return false;
  803. }
  804. const char* const* PatchbayGraph::getConnections() const noexcept
  805. {
  806. return nullptr;
  807. }
  808. bool PatchbayGraph::getPortIdFromFullName(const char* const /*fillPortName*/, uint& /*groupId*/, uint& /*portId*/) const noexcept
  809. {
  810. return false;
  811. }
  812. #endif
  813. void PatchbayGraph::process(CarlaEngine::ProtectedData* const data, const float* const* const inBuf, float* const* const outBuf, const int frames)
  814. {
  815. CARLA_SAFE_ASSERT_RETURN(data != nullptr,);
  816. CARLA_SAFE_ASSERT_RETURN(data->events.in != nullptr,);
  817. CARLA_SAFE_ASSERT_RETURN(data->events.out != nullptr,);
  818. CARLA_SAFE_ASSERT_RETURN(frames > 0,);
  819. // put events in juce buffer
  820. {
  821. midiBuffer.clear();
  822. fillJuceMidiBufferFromEngineEvents(midiBuffer, data->events.in);
  823. }
  824. // put carla audio in juce buffer
  825. {
  826. int i=0;
  827. for (; i<inputs; ++i)
  828. FloatVectorOperations::copy(audioBuffer.getWritePointer(i), inBuf[i], frames);
  829. // clear remaining channels
  830. for (int count=audioBuffer.getNumChannels(); i<count; ++i)
  831. audioBuffer.clear(i, 0, frames);
  832. }
  833. graph.processBlock(audioBuffer, midiBuffer);
  834. // put juce audio in carla buffer
  835. {
  836. for (int i=0; i<outputs; ++i)
  837. FloatVectorOperations::copy(outBuf[i], audioBuffer.getReadPointer(i), frames);
  838. }
  839. // put juce events in carla buffer
  840. {
  841. carla_zeroStruct<EngineEvent>(data->events.out, kMaxEngineEventInternalCount);
  842. fillEngineEventsFromJuceMidiBuffer(data->events.out, midiBuffer);
  843. }
  844. }
  845. // -----------------------------------------------------------------------
  846. // InternalGraph
  847. EngineInternalGraph::EngineInternalGraph() noexcept
  848. : fIsRack(true),
  849. fIsReady(false)
  850. {
  851. fRack = nullptr;
  852. }
  853. EngineInternalGraph::~EngineInternalGraph() noexcept
  854. {
  855. CARLA_SAFE_ASSERT(! fIsReady);
  856. CARLA_SAFE_ASSERT(fRack == nullptr);
  857. }
  858. void EngineInternalGraph::create(const bool isRack, const double sampleRate, const uint32_t bufferSize, const uint32_t inputs, const uint32_t outputs)
  859. {
  860. fIsRack = isRack;
  861. if (isRack)
  862. {
  863. CARLA_SAFE_ASSERT_RETURN(fRack == nullptr,);
  864. fRack = new RackGraph(bufferSize, inputs, outputs);
  865. }
  866. else
  867. {
  868. CARLA_SAFE_ASSERT_RETURN(fPatchbay == nullptr,);
  869. fPatchbay = new PatchbayGraph(static_cast<int>(bufferSize), sampleRate, inputs, outputs);
  870. }
  871. fIsReady = true;
  872. }
  873. void EngineInternalGraph::destroy() noexcept
  874. {
  875. if (! fIsReady)
  876. {
  877. CARLA_SAFE_ASSERT(fRack == nullptr);
  878. return;
  879. }
  880. fIsReady = false;
  881. if (fIsRack)
  882. {
  883. CARLA_SAFE_ASSERT_RETURN(fRack != nullptr,);
  884. delete fRack;
  885. fRack = nullptr;
  886. }
  887. else
  888. {
  889. CARLA_SAFE_ASSERT_RETURN(fPatchbay != nullptr,);
  890. delete fPatchbay;
  891. fPatchbay = nullptr;
  892. }
  893. }
  894. void EngineInternalGraph::setBufferSize(const uint32_t bufferSize)
  895. {
  896. ScopedValueSetter<bool> svs(fIsReady, false, true);
  897. if (fIsRack)
  898. {
  899. CARLA_SAFE_ASSERT_RETURN(fRack != nullptr,);
  900. fRack->setBufferSize(bufferSize);
  901. }
  902. else
  903. {
  904. CARLA_SAFE_ASSERT_RETURN(fPatchbay != nullptr,);
  905. fPatchbay->setBufferSize(static_cast<int>(bufferSize));
  906. }
  907. }
  908. void EngineInternalGraph::setSampleRate(const double sampleRate)
  909. {
  910. ScopedValueSetter<bool> svs(fIsReady, false, true);
  911. if (fIsRack)
  912. {
  913. CARLA_SAFE_ASSERT_RETURN(fRack != nullptr,);
  914. }
  915. else
  916. {
  917. CARLA_SAFE_ASSERT_RETURN(fPatchbay != nullptr,);
  918. fPatchbay->setSampleRate(sampleRate);
  919. }
  920. }
  921. void EngineInternalGraph::setOffline(const bool offline)
  922. {
  923. ScopedValueSetter<bool> svs(fIsReady, false, true);
  924. if (fIsRack)
  925. {
  926. CARLA_SAFE_ASSERT_RETURN(fRack != nullptr,);
  927. fRack->setOffline(offline);
  928. }
  929. else
  930. {
  931. CARLA_SAFE_ASSERT_RETURN(fPatchbay != nullptr,);
  932. fPatchbay->setOffline(offline);
  933. }
  934. }
  935. bool EngineInternalGraph::isReady() const noexcept
  936. {
  937. return fIsReady;
  938. }
  939. RackGraph* EngineInternalGraph::getRackGraph() const noexcept
  940. {
  941. CARLA_SAFE_ASSERT_RETURN(fIsRack, nullptr);
  942. return fRack;
  943. }
  944. PatchbayGraph* EngineInternalGraph::getPatchbayGraph() const noexcept
  945. {
  946. CARLA_SAFE_ASSERT_RETURN(! fIsRack, nullptr);
  947. return fPatchbay;
  948. }
  949. void EngineInternalGraph::process(CarlaEngine::ProtectedData* const data, const float* const* const inBuf, float* const* const outBuf, const uint32_t frames)
  950. {
  951. if (fIsRack)
  952. {
  953. CARLA_SAFE_ASSERT_RETURN(fRack != nullptr,);
  954. fRack->processHelper(data, inBuf, outBuf, frames);
  955. }
  956. else
  957. {
  958. CARLA_SAFE_ASSERT_RETURN(fPatchbay != nullptr,);
  959. fPatchbay->process(data, inBuf, outBuf, static_cast<int>(frames));
  960. }
  961. }
  962. void EngineInternalGraph::processRack(CarlaEngine::ProtectedData* const data, const float* inBuf[2], float* outBuf[2], const uint32_t frames)
  963. {
  964. CARLA_SAFE_ASSERT_RETURN(fIsRack,);
  965. CARLA_SAFE_ASSERT_RETURN(fRack != nullptr,);
  966. fRack->process(data, inBuf, outBuf, frames);
  967. }
  968. // -----------------------------------------------------------------------
  969. // CarlaEngine Patchbay stuff
  970. bool CarlaEngine::patchbayConnect(const uint groupA, const uint portA, const uint groupB, const uint portB)
  971. {
  972. CARLA_SAFE_ASSERT_RETURN(pData->options.processMode == ENGINE_PROCESS_MODE_CONTINUOUS_RACK || pData->options.processMode == ENGINE_PROCESS_MODE_PATCHBAY, false);
  973. CARLA_SAFE_ASSERT_RETURN(pData->graph.isReady(), false);
  974. carla_stdout("CarlaEngine::patchbayConnect(%u, %u, %u, %u)", groupA, portA, groupB, portB);
  975. if (pData->options.processMode == ENGINE_PROCESS_MODE_CONTINUOUS_RACK)
  976. {
  977. if (RackGraph* const graph = pData->graph.getRackGraph())
  978. return graph->connect(this, groupA, portA, groupB, portB);
  979. }
  980. else
  981. {
  982. }
  983. return false;
  984. }
  985. bool CarlaEngine::patchbayDisconnect(const uint connectionId)
  986. {
  987. CARLA_SAFE_ASSERT_RETURN(pData->options.processMode == ENGINE_PROCESS_MODE_CONTINUOUS_RACK || pData->options.processMode == ENGINE_PROCESS_MODE_PATCHBAY, false);
  988. CARLA_SAFE_ASSERT_RETURN(pData->graph.isReady(), false);
  989. carla_stdout("CarlaEngine::patchbayDisconnect(%u)", connectionId);
  990. if (pData->options.processMode == ENGINE_PROCESS_MODE_CONTINUOUS_RACK)
  991. {
  992. if (RackGraph* const graph = pData->graph.getRackGraph())
  993. return graph->disconnect(this, connectionId);
  994. }
  995. else
  996. {
  997. }
  998. return false;
  999. }
  1000. bool CarlaEngine::patchbayRefresh()
  1001. {
  1002. setLastError("Unsupported operation");
  1003. return false;
  1004. }
  1005. // -----------------------------------------------------------------------
  1006. const char* const* CarlaEngine::getPatchbayConnections() const
  1007. {
  1008. CARLA_SAFE_ASSERT_RETURN(pData->graph.isReady(), nullptr);
  1009. carla_debug("CarlaEngine::getPatchbayConnections()");
  1010. if (pData->options.processMode == ENGINE_PROCESS_MODE_CONTINUOUS_RACK)
  1011. {
  1012. if (RackGraph* const graph = pData->graph.getRackGraph())
  1013. return graph->getConnections();
  1014. }
  1015. else
  1016. {
  1017. }
  1018. return nullptr;
  1019. }
  1020. void CarlaEngine::restorePatchbayConnection(const char* const connSource, const char* const connTarget)
  1021. {
  1022. CARLA_SAFE_ASSERT_RETURN(pData->graph.isReady(),);
  1023. CARLA_SAFE_ASSERT_RETURN(connSource != nullptr && connSource[0] != '\0',);
  1024. CARLA_SAFE_ASSERT_RETURN(connTarget != nullptr && connTarget[0] != '\0',);
  1025. carla_debug("CarlaEngine::restorePatchbayConnection(\"%s\", \"%s\")", connSource, connTarget);
  1026. uint groupA, portA;
  1027. uint groupB, portB;
  1028. if (pData->options.processMode == ENGINE_PROCESS_MODE_CONTINUOUS_RACK)
  1029. {
  1030. RackGraph* const graph = pData->graph.getRackGraph();
  1031. CARLA_SAFE_ASSERT_RETURN(graph != nullptr,);
  1032. if (! graph->getGroupAndPortIdFromFullName(connSource, groupA, portA))
  1033. return;
  1034. if (! graph->getGroupAndPortIdFromFullName(connTarget, groupB, portB))
  1035. return;
  1036. }
  1037. else
  1038. {
  1039. return;
  1040. }
  1041. patchbayConnect(groupA, portA, groupB, portB);
  1042. }
  1043. // -----------------------------------------------------------------------
  1044. CARLA_BACKEND_END_NAMESPACE