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.

2519 lines
84KB

  1. /*
  2. * Carla Plugin Host
  3. * Copyright (C) 2011-2019 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 "CarlaDefines.h"
  18. #ifdef BUILD_BRIDGE_ALTERNATIVE_ARCH
  19. # error This file should not be compiled if building alternative-arch bridges
  20. #endif
  21. #include "CarlaEngineInternal.hpp"
  22. #include "CarlaPlugin.hpp"
  23. #include "CarlaBackendUtils.hpp"
  24. #include "CarlaBase64Utils.hpp"
  25. #include "CarlaBinaryUtils.hpp"
  26. #include "CarlaMathUtils.hpp"
  27. #include "CarlaStateUtils.hpp"
  28. #include "CarlaExternalUI.hpp"
  29. #include "CarlaHost.h"
  30. #include "CarlaNative.hpp"
  31. #include "CarlaNativePlugin.h"
  32. #if defined(USING_JUCE) && ! (defined(CARLA_OS_MAC) || defined(CARLA_OS_WIN))
  33. # if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
  34. # pragma GCC diagnostic push
  35. # pragma GCC diagnostic ignored "-Wconversion"
  36. # pragma GCC diagnostic ignored "-Weffc++"
  37. # pragma GCC diagnostic ignored "-Wsign-conversion"
  38. # pragma GCC diagnostic ignored "-Wundef"
  39. # pragma GCC diagnostic ignored "-Wzero-as-null-pointer-constant"
  40. # endif
  41. # include "AppConfig.h"
  42. # include "juce_events/juce_events.h"
  43. # define USE_JUCE_MESSAGE_THREAD
  44. # if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
  45. # pragma GCC diagnostic pop
  46. # endif
  47. #endif
  48. #include "water/files/File.h"
  49. #include "water/streams/MemoryOutputStream.h"
  50. #include "water/xml/XmlDocument.h"
  51. #include "water/xml/XmlElement.h"
  52. using water::File;
  53. using water::MemoryOutputStream;
  54. using water::String;
  55. using water::XmlDocument;
  56. using water::XmlElement;
  57. CARLA_BACKEND_START_NAMESPACE
  58. // -----------------------------------------------------------------------
  59. #ifdef USE_JUCE_MESSAGE_THREAD
  60. static int numScopedInitInstances = 0;
  61. class SharedJuceMessageThread : public juce::Thread
  62. {
  63. public:
  64. SharedJuceMessageThread()
  65. : juce::Thread ("SharedJuceMessageThread"),
  66. initialised (false) {}
  67. ~SharedJuceMessageThread()
  68. {
  69. CARLA_SAFE_ASSERT(numScopedInitInstances == 0);
  70. // in case something fails
  71. juce::MessageManager::getInstance()->stopDispatchLoop();
  72. waitForThreadToExit (5000);
  73. }
  74. void incRef()
  75. {
  76. if (numScopedInitInstances++ == 0)
  77. {
  78. startThread (7);
  79. while (! initialised)
  80. juce::Thread::sleep (1);
  81. }
  82. }
  83. void decRef()
  84. {
  85. if (--numScopedInitInstances == 0)
  86. {
  87. juce::MessageManager::getInstance()->stopDispatchLoop();
  88. waitForThreadToExit (5000);
  89. }
  90. }
  91. protected:
  92. void run() override
  93. {
  94. const juce::ScopedJuceInitialiser_GUI juceInitialiser;
  95. juce::MessageManager::getInstance()->setCurrentThreadAsMessageThread();
  96. initialised = true;
  97. juce::MessageManager::getInstance()->runDispatchLoop();
  98. }
  99. private:
  100. volatile bool initialised;
  101. CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(SharedJuceMessageThread);
  102. };
  103. #endif
  104. // -----------------------------------------------------------------------
  105. class CarlaEngineNativeUI : public CarlaExternalUI
  106. {
  107. public:
  108. CarlaEngineNativeUI(CarlaEngine* const engine)
  109. : fEngine(engine)
  110. {
  111. carla_debug("CarlaEngineNativeUI::CarlaEngineNativeUI(%p)", engine);
  112. }
  113. ~CarlaEngineNativeUI() noexcept override
  114. {
  115. carla_debug("CarlaEngineNativeUI::~CarlaEngineNativeUI()");
  116. }
  117. protected:
  118. bool msgReceived(const char* const msg) noexcept override
  119. {
  120. if (CarlaExternalUI::msgReceived(msg))
  121. return true;
  122. bool ok = true;
  123. if (std::strcmp(msg, "set_engine_option") == 0)
  124. {
  125. uint32_t option;
  126. int32_t value;
  127. const char* valueStr = nullptr;
  128. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(option), true);
  129. CARLA_SAFE_ASSERT_RETURN(readNextLineAsInt(value), true);
  130. readNextLineAsString(valueStr); // can be null
  131. try {
  132. fEngine->setOption(static_cast<EngineOption>(option), value, valueStr);
  133. } CARLA_SAFE_EXCEPTION("setOption");
  134. if (valueStr != nullptr)
  135. delete[] valueStr;
  136. }
  137. else if (std::strcmp(msg, "clear_engine_xruns") == 0)
  138. {
  139. fEngine->clearXruns();
  140. }
  141. else if (std::strcmp(msg, "cancel_engine_action") == 0)
  142. {
  143. fEngine->setActionCanceled(true);
  144. }
  145. else if (std::strcmp(msg, "load_file") == 0)
  146. {
  147. const char* filename;
  148. CARLA_SAFE_ASSERT_RETURN(readNextLineAsString(filename), true);
  149. try {
  150. ok = fEngine->loadFile(filename);
  151. } CARLA_SAFE_EXCEPTION("loadFile");
  152. delete[] filename;
  153. }
  154. else if (std::strcmp(msg, "load_project") == 0)
  155. {
  156. const char* filename;
  157. CARLA_SAFE_ASSERT_RETURN(readNextLineAsString(filename), true);
  158. try {
  159. ok = fEngine->loadProject(filename, true);
  160. } CARLA_SAFE_EXCEPTION("loadProject");
  161. delete[] filename;
  162. }
  163. else if (std::strcmp(msg, "save_project") == 0)
  164. {
  165. const char* filename;
  166. CARLA_SAFE_ASSERT_RETURN(readNextLineAsString(filename), true);
  167. try {
  168. ok = fEngine->saveProject(filename, true);
  169. } CARLA_SAFE_EXCEPTION("saveProject");
  170. delete[] filename;
  171. }
  172. else if (std::strcmp(msg, "clear_project_filename") == 0)
  173. {
  174. fEngine->clearCurrentProjectFilename();
  175. }
  176. else if (std::strcmp(msg, "patchbay_connect") == 0)
  177. {
  178. bool external;
  179. uint32_t groupA, portA, groupB, portB;
  180. CARLA_SAFE_ASSERT_RETURN(readNextLineAsBool(external), true);
  181. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(groupA), true);
  182. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(portA), true);
  183. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(groupB), true);
  184. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(portB), true);
  185. try {
  186. ok = fEngine->patchbayConnect(external, groupA, portA, groupB, portB);
  187. } CARLA_SAFE_EXCEPTION("patchbayConnect");
  188. }
  189. else if (std::strcmp(msg, "patchbay_disconnect") == 0)
  190. {
  191. bool external;
  192. uint32_t connectionId;
  193. CARLA_SAFE_ASSERT_RETURN(readNextLineAsBool(external), true);
  194. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(connectionId), true);
  195. try {
  196. ok = fEngine->patchbayDisconnect(external, connectionId);
  197. } CARLA_SAFE_EXCEPTION("patchbayDisconnect");
  198. }
  199. else if (std::strcmp(msg, "patchbay_refresh") == 0)
  200. {
  201. bool external;
  202. CARLA_SAFE_ASSERT_RETURN(readNextLineAsBool(external), true);
  203. try {
  204. ok = fEngine->patchbayRefresh(true, false, external);
  205. } CARLA_SAFE_EXCEPTION("patchbayRefresh");
  206. }
  207. else if (std::strcmp(msg, "transport_play") == 0)
  208. {
  209. fEngine->transportPlay();
  210. }
  211. else if (std::strcmp(msg, "transport_pause") == 0)
  212. {
  213. fEngine->transportPause();
  214. }
  215. else if (std::strcmp(msg, "transport_bpm") == 0)
  216. {
  217. double bpm;
  218. CARLA_SAFE_ASSERT_RETURN(readNextLineAsDouble(bpm), true);
  219. fEngine->transportBPM(bpm);
  220. }
  221. else if (std::strcmp(msg, "transport_relocate") == 0)
  222. {
  223. uint64_t frame;
  224. CARLA_SAFE_ASSERT_RETURN(readNextLineAsULong(frame), true);
  225. fEngine->transportRelocate(frame);
  226. }
  227. else if (std::strcmp(msg, "add_plugin") == 0)
  228. {
  229. uint32_t btype, ptype;
  230. const char* filename = nullptr;
  231. const char* name;
  232. const char* label;
  233. int64_t uniqueId;
  234. uint options;
  235. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(btype), true);
  236. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(ptype), true);
  237. readNextLineAsString(filename); // can be null
  238. CARLA_SAFE_ASSERT_RETURN(readNextLineAsString(name), true);
  239. CARLA_SAFE_ASSERT_RETURN(readNextLineAsString(label), true);
  240. CARLA_SAFE_ASSERT_RETURN(readNextLineAsLong(uniqueId), true);
  241. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(options), true);
  242. if (filename != nullptr && std::strcmp(filename, "(null)") == 0)
  243. {
  244. delete[] filename;
  245. filename = nullptr;
  246. }
  247. if (std::strcmp(name, "(null)") == 0)
  248. {
  249. delete[] name;
  250. name = nullptr;
  251. }
  252. ok = fEngine->addPlugin(static_cast<BinaryType>(btype), static_cast<PluginType>(ptype),
  253. filename, name, label, uniqueId, nullptr, options);
  254. if (filename != nullptr)
  255. delete[] filename;
  256. if (name != nullptr)
  257. delete[] name;
  258. delete[] label;
  259. }
  260. else if (std::strcmp(msg, "remove_plugin") == 0)
  261. {
  262. uint32_t pluginId;
  263. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(pluginId), true);
  264. ok = fEngine->removePlugin(pluginId);
  265. }
  266. else if (std::strcmp(msg, "remove_all_plugins") == 0)
  267. {
  268. ok = fEngine->removeAllPlugins();
  269. }
  270. else if (std::strcmp(msg, "rename_plugin") == 0)
  271. {
  272. uint32_t pluginId;
  273. const char* newName;
  274. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(pluginId), true);
  275. CARLA_SAFE_ASSERT_RETURN(readNextLineAsString(newName), true);
  276. // TODO
  277. /*const char* name =*/ fEngine->renamePlugin(pluginId, newName);
  278. delete[] newName;
  279. }
  280. else if (std::strcmp(msg, "clone_plugin") == 0)
  281. {
  282. uint32_t pluginId;
  283. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(pluginId), true);
  284. ok = fEngine->clonePlugin(pluginId);
  285. }
  286. else if (std::strcmp(msg, "replace_plugin") == 0)
  287. {
  288. uint32_t pluginId;
  289. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(pluginId), true);
  290. ok = fEngine->replacePlugin(pluginId);
  291. }
  292. else if (std::strcmp(msg, "switch_plugins") == 0)
  293. {
  294. uint32_t pluginIdA, pluginIdB;
  295. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(pluginIdA), true);
  296. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(pluginIdB), true);
  297. ok = fEngine->switchPlugins(pluginIdA, pluginIdB);
  298. }
  299. else if (std::strcmp(msg, "load_plugin_state") == 0)
  300. {
  301. uint32_t pluginId;
  302. const char* filename;
  303. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(pluginId), true);
  304. CARLA_SAFE_ASSERT_RETURN(readNextLineAsString(filename), true);
  305. if (CarlaPlugin* const plugin = fEngine->getPlugin(pluginId))
  306. plugin->loadStateFromFile(filename);
  307. delete[] filename;
  308. }
  309. else if (std::strcmp(msg, "save_plugin_state") == 0)
  310. {
  311. uint32_t pluginId;
  312. const char* filename;
  313. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(pluginId), true);
  314. CARLA_SAFE_ASSERT_RETURN(readNextLineAsString(filename), true);
  315. if (CarlaPlugin* const plugin = fEngine->getPlugin(pluginId))
  316. plugin->saveStateToFile(filename);
  317. delete[] filename;
  318. }
  319. else if (std::strcmp(msg, "set_option") == 0)
  320. {
  321. uint32_t pluginId, option;
  322. bool yesNo;
  323. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(pluginId), true);
  324. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(option), true);
  325. CARLA_SAFE_ASSERT_RETURN(readNextLineAsBool(yesNo), true);
  326. if (CarlaPlugin* const plugin = fEngine->getPlugin(pluginId))
  327. plugin->setOption(option, yesNo, false);
  328. }
  329. else if (std::strcmp(msg, "set_active") == 0)
  330. {
  331. uint32_t pluginId;
  332. bool onOff;
  333. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(pluginId), true);
  334. CARLA_SAFE_ASSERT_RETURN(readNextLineAsBool(onOff), true);
  335. if (CarlaPlugin* const plugin = fEngine->getPlugin(pluginId))
  336. plugin->setActive(onOff, true, false);
  337. }
  338. else if (std::strcmp(msg, "set_drywet") == 0)
  339. {
  340. uint32_t pluginId;
  341. float value;
  342. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(pluginId), true);
  343. CARLA_SAFE_ASSERT_RETURN(readNextLineAsFloat(value), true);
  344. if (CarlaPlugin* const plugin = fEngine->getPlugin(pluginId))
  345. plugin->setDryWet(value, true, false);
  346. }
  347. else if (std::strcmp(msg, "set_volume") == 0)
  348. {
  349. uint32_t pluginId;
  350. float value;
  351. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(pluginId), true);
  352. CARLA_SAFE_ASSERT_RETURN(readNextLineAsFloat(value), true);
  353. if (CarlaPlugin* const plugin = fEngine->getPlugin(pluginId))
  354. plugin->setVolume(value, true, false);
  355. }
  356. else if (std::strcmp(msg, "set_balance_left") == 0)
  357. {
  358. uint32_t pluginId;
  359. float value;
  360. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(pluginId), true);
  361. CARLA_SAFE_ASSERT_RETURN(readNextLineAsFloat(value), true);
  362. if (CarlaPlugin* const plugin = fEngine->getPlugin(pluginId))
  363. plugin->setBalanceLeft(value, true, false);
  364. }
  365. else if (std::strcmp(msg, "set_balance_right") == 0)
  366. {
  367. uint32_t pluginId;
  368. float value;
  369. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(pluginId), true);
  370. CARLA_SAFE_ASSERT_RETURN(readNextLineAsFloat(value), true);
  371. if (CarlaPlugin* const plugin = fEngine->getPlugin(pluginId))
  372. plugin->setBalanceRight(value, true, false);
  373. }
  374. else if (std::strcmp(msg, "set_panning") == 0)
  375. {
  376. uint32_t pluginId;
  377. float value;
  378. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(pluginId), true);
  379. CARLA_SAFE_ASSERT_RETURN(readNextLineAsFloat(value), true);
  380. if (CarlaPlugin* const plugin = fEngine->getPlugin(pluginId))
  381. plugin->setPanning(value, true, false);
  382. }
  383. else if (std::strcmp(msg, "set_ctrl_channel") == 0)
  384. {
  385. uint32_t pluginId;
  386. int32_t channel;
  387. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(pluginId), true);
  388. CARLA_SAFE_ASSERT_RETURN(readNextLineAsInt(channel), true);
  389. CARLA_SAFE_ASSERT_RETURN(channel >= -1 && channel < MAX_MIDI_CHANNELS, true);
  390. if (CarlaPlugin* const plugin = fEngine->getPlugin(pluginId))
  391. plugin->setCtrlChannel(int8_t(channel), true, false);
  392. }
  393. else if (std::strcmp(msg, "set_parameter_value") == 0)
  394. {
  395. uint32_t pluginId, parameterId;
  396. float value;
  397. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(pluginId), true);
  398. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(parameterId), true);
  399. CARLA_SAFE_ASSERT_RETURN(readNextLineAsFloat(value), true);
  400. if (CarlaPlugin* const plugin = fEngine->getPlugin(pluginId))
  401. plugin->setParameterValue(parameterId, value, true, true, false);
  402. }
  403. else if (std::strcmp(msg, "set_parameter_midi_channel") == 0)
  404. {
  405. uint32_t pluginId, parameterId, channel;
  406. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(pluginId), true);
  407. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(parameterId), true);
  408. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(channel), true);
  409. CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS, true);
  410. if (CarlaPlugin* const plugin = fEngine->getPlugin(pluginId))
  411. plugin->setParameterMidiChannel(parameterId, static_cast<uint8_t>(channel), true, false);
  412. }
  413. else if (std::strcmp(msg, "set_parameter_midi_cc") == 0)
  414. {
  415. uint32_t pluginId, parameterId;
  416. int32_t cc;
  417. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(pluginId), true);
  418. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(parameterId), true);
  419. CARLA_SAFE_ASSERT_RETURN(readNextLineAsInt(cc), true);
  420. CARLA_SAFE_ASSERT_RETURN(cc >= -1 && cc < MAX_MIDI_CONTROL, true);
  421. if (CarlaPlugin* const plugin = fEngine->getPlugin(pluginId))
  422. plugin->setParameterMidiCC(parameterId, static_cast<int16_t>(cc), true, false);
  423. }
  424. else if (std::strcmp(msg, "set_program") == 0)
  425. {
  426. uint32_t pluginId;
  427. int32_t index;
  428. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(pluginId), true);
  429. CARLA_SAFE_ASSERT_RETURN(readNextLineAsInt(index), true);
  430. if (CarlaPlugin* const plugin = fEngine->getPlugin(pluginId))
  431. {
  432. plugin->setProgram(index, true, true, false);
  433. _updateParamValues(plugin, pluginId);
  434. }
  435. }
  436. else if (std::strcmp(msg, "set_midi_program") == 0)
  437. {
  438. uint32_t pluginId;
  439. int32_t index;
  440. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(pluginId), true);
  441. CARLA_SAFE_ASSERT_RETURN(readNextLineAsInt(index), true);
  442. if (CarlaPlugin* const plugin = fEngine->getPlugin(pluginId))
  443. {
  444. plugin->setMidiProgram(index, true, true, false);
  445. _updateParamValues(plugin, pluginId);
  446. }
  447. }
  448. else if (std::strcmp(msg, "set_custom_data") == 0)
  449. {
  450. uint32_t pluginId;
  451. const char* type;
  452. const char* key;
  453. const char* value;
  454. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(pluginId), true);
  455. CARLA_SAFE_ASSERT_RETURN(readNextLineAsString(type), true);
  456. CARLA_SAFE_ASSERT_RETURN(readNextLineAsString(key), true);
  457. CARLA_SAFE_ASSERT_RETURN(readNextLineAsString(value), true);
  458. if (CarlaPlugin* const plugin = fEngine->getPlugin(pluginId))
  459. plugin->setCustomData(type, key, value, true);
  460. delete[] type;
  461. delete[] key;
  462. delete[] value;
  463. }
  464. else if (std::strcmp(msg, "set_chunk_data") == 0)
  465. {
  466. uint32_t pluginId;
  467. const char* cdata;
  468. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(pluginId), true);
  469. CARLA_SAFE_ASSERT_RETURN(readNextLineAsString(cdata), true);
  470. if (CarlaPlugin* const plugin = fEngine->getPlugin(pluginId))
  471. {
  472. std::vector<uint8_t> chunk(carla_getChunkFromBase64String(cdata));
  473. #ifdef CARLA_PROPER_CPP11_SUPPORT
  474. plugin->setChunkData(chunk.data(), chunk.size());
  475. #else
  476. plugin->setChunkData(&chunk.front(), chunk.size());
  477. #endif
  478. }
  479. delete[] cdata;
  480. }
  481. else if (std::strcmp(msg, "prepare_for_save") == 0)
  482. {
  483. uint32_t pluginId;
  484. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(pluginId), true);
  485. if (CarlaPlugin* const plugin = fEngine->getPlugin(pluginId))
  486. plugin->prepareForSave();
  487. }
  488. else if (std::strcmp(msg, "reset_parameters") == 0)
  489. {
  490. uint32_t pluginId;
  491. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(pluginId), true);
  492. if (CarlaPlugin* const plugin = fEngine->getPlugin(pluginId))
  493. plugin->resetParameters();
  494. }
  495. else if (std::strcmp(msg, "randomize_parameters") == 0)
  496. {
  497. uint32_t pluginId;
  498. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(pluginId), true);
  499. if (CarlaPlugin* const plugin = fEngine->getPlugin(pluginId))
  500. plugin->randomizeParameters();
  501. }
  502. else if (std::strcmp(msg, "send_midi_note") == 0)
  503. {
  504. uint32_t pluginId, channel, note, velocity;
  505. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(pluginId), true);
  506. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(channel), true);
  507. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(note), true);
  508. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(velocity), true);
  509. CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS, true);
  510. CARLA_SAFE_ASSERT_RETURN(note < MAX_MIDI_VALUE, true);
  511. CARLA_SAFE_ASSERT_RETURN(velocity < MAX_MIDI_VALUE, true);
  512. if (CarlaPlugin* const plugin = fEngine->getPlugin(pluginId))
  513. plugin->sendMidiSingleNote(static_cast<uint8_t>(channel), static_cast<uint8_t>(note), static_cast<uint8_t>(velocity), true, true, false);
  514. }
  515. else if (std::strcmp(msg, "show_custom_ui") == 0)
  516. {
  517. uint32_t pluginId;
  518. bool yesNo;
  519. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(pluginId), true);
  520. CARLA_SAFE_ASSERT_RETURN(readNextLineAsBool(yesNo), true);
  521. if (CarlaPlugin* const plugin = fEngine->getPlugin(pluginId))
  522. plugin->showCustomUI(yesNo);
  523. }
  524. else
  525. {
  526. carla_stderr("CarlaEngineNativeUI::msgReceived : %s", msg);
  527. return false;
  528. }
  529. if (! ok)
  530. {
  531. const CarlaMutexLocker cml(getPipeLock());
  532. if (writeMessage("error\n", 6) && writeAndFixMessage(fEngine->getLastError()))
  533. flushMessages();
  534. }
  535. return true;
  536. }
  537. private:
  538. CarlaEngine* const fEngine;
  539. void _updateParamValues(CarlaPlugin* const plugin, const uint32_t pluginId) const noexcept
  540. {
  541. for (uint32_t i=0, count=plugin->getParameterCount(); i<count; ++i) {
  542. fEngine->callback(true, true,
  543. ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED,
  544. pluginId,
  545. static_cast<int>(i),
  546. 0, 0,
  547. plugin->getParameterValue(i),
  548. nullptr);
  549. }
  550. }
  551. CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaEngineNativeUI)
  552. };
  553. // -----------------------------------------------------------------------
  554. class CarlaEngineNative : public CarlaEngine
  555. {
  556. public:
  557. CarlaEngineNative(const NativeHostDescriptor* const host, const bool isPatchbay, const bool withMidiOut,
  558. const uint32_t inChan = 2, uint32_t outChan = 2)
  559. : CarlaEngine(),
  560. pHost(host),
  561. #ifdef USE_JUCE_MESSAGE_THREAD
  562. // if not running inside Carla, we will have to run event loop ourselves
  563. kNeedsJuceMsgThread(host->dispatcher(pHost->handle,
  564. NATIVE_HOST_OPCODE_INTERNAL_PLUGIN, 0, 0, nullptr, 0.0f) == 0),
  565. fJuceMsgThread(),
  566. #endif
  567. kIsPatchbay(isPatchbay),
  568. kHasMidiOut(withMidiOut),
  569. fIsActive(false),
  570. fIsRunning(false),
  571. fUiServer(this),
  572. fOptionsForced(false)
  573. {
  574. carla_debug("CarlaEngineNative::CarlaEngineNative()");
  575. #ifdef USE_JUCE_MESSAGE_THREAD
  576. if (kNeedsJuceMsgThread)
  577. fJuceMsgThread->incRef();
  578. #endif
  579. pData->bufferSize = pHost->get_buffer_size(pHost->handle);
  580. pData->sampleRate = pHost->get_sample_rate(pHost->handle);
  581. pData->initTime(nullptr);
  582. #ifndef BUILD_BRIDGE
  583. // Forced OSC setup when running as plugin
  584. pData->options.oscEnabled = true;
  585. pData->options.oscPortTCP = -1;
  586. pData->options.oscPortUDP = 0;
  587. #endif
  588. if (outChan == 0)
  589. outChan = inChan;
  590. // set-up engine
  591. if (kIsPatchbay)
  592. {
  593. pData->options.processMode = ENGINE_PROCESS_MODE_PATCHBAY;
  594. pData->options.transportMode = ENGINE_TRANSPORT_MODE_PLUGIN;
  595. pData->options.forceStereo = false;
  596. pData->options.preferPluginBridges = false;
  597. pData->options.preferUiBridges = false;
  598. init("Carla-Patchbay");
  599. pData->graph.create(inChan, outChan);
  600. }
  601. else
  602. {
  603. CARLA_SAFE_ASSERT(inChan == 2);
  604. CARLA_SAFE_ASSERT(outChan == 2);
  605. pData->options.processMode = ENGINE_PROCESS_MODE_CONTINUOUS_RACK;
  606. pData->options.transportMode = ENGINE_TRANSPORT_MODE_PLUGIN;
  607. pData->options.forceStereo = true;
  608. pData->options.preferPluginBridges = false;
  609. pData->options.preferUiBridges = false;
  610. init("Carla-Rack");
  611. pData->graph.create(0, 0); // FIXME?
  612. }
  613. if (pData->options.resourceDir != nullptr)
  614. delete[] pData->options.resourceDir;
  615. if (pData->options.binaryDir != nullptr)
  616. delete[] pData->options.binaryDir;
  617. pData->options.resourceDir = carla_strdup(pHost->resourceDir);
  618. pData->options.binaryDir = carla_strdup(carla_get_library_folder());
  619. setCallback(_ui_server_callback, this);
  620. setFileCallback(_ui_file_callback, this);
  621. }
  622. ~CarlaEngineNative() override
  623. {
  624. CARLA_SAFE_ASSERT(! fIsActive);
  625. carla_debug("CarlaEngineNative::~CarlaEngineNative() - START");
  626. pData->aboutToClose = true;
  627. fIsRunning = false;
  628. removeAllPlugins();
  629. //runPendingRtEvents();
  630. close();
  631. pData->graph.destroy();
  632. #ifdef USE_JUCE_MESSAGE_THREAD
  633. if (kNeedsJuceMsgThread)
  634. fJuceMsgThread->decRef();
  635. #endif
  636. carla_debug("CarlaEngineNative::~CarlaEngineNative() - END");
  637. }
  638. protected:
  639. // -------------------------------------
  640. // CarlaEngine virtual calls
  641. bool init(const char* const clientName) override
  642. {
  643. carla_debug("CarlaEngineNative::init(\"%s\")", clientName);
  644. fIsRunning = true;
  645. if (! pData->init(clientName))
  646. {
  647. close();
  648. setLastError("Failed to init internal data");
  649. return false;
  650. }
  651. pData->bufferSize = pHost->get_buffer_size(pHost->handle);
  652. pData->sampleRate = pHost->get_sample_rate(pHost->handle);
  653. return true;
  654. }
  655. bool close() override
  656. {
  657. fIsRunning = false;
  658. CarlaEngine::close();
  659. return true;
  660. }
  661. bool isRunning() const noexcept override
  662. {
  663. return fIsRunning;
  664. }
  665. bool isOffline() const noexcept override
  666. {
  667. return pHost->is_offline(pHost->handle);
  668. }
  669. bool usesConstantBufferSize() const noexcept override
  670. {
  671. // TODO LV2 hosts can report this, till then we allow this
  672. return true;
  673. }
  674. EngineType getType() const noexcept override
  675. {
  676. return kEngineTypePlugin;
  677. }
  678. const char* getCurrentDriverName() const noexcept override
  679. {
  680. return "Plugin";
  681. }
  682. void callback(const bool sendHost, const bool sendOsc,
  683. const EngineCallbackOpcode action, const uint pluginId,
  684. const int value1, const int value2, const int value3,
  685. const float valuef, const char* const valueStr) noexcept override
  686. {
  687. CarlaEngine::callback(sendHost, sendOsc, action, pluginId, value1, value2, value3, valuef, valueStr);
  688. if (action == ENGINE_CALLBACK_IDLE && ! pData->aboutToClose) {
  689. pHost->dispatcher(pHost->handle,
  690. NATIVE_HOST_OPCODE_HOST_IDLE,
  691. 0, 0, nullptr, 0.0f);
  692. }
  693. }
  694. // -------------------------------------------------------------------
  695. const char* renamePlugin(const uint id, const char* const newName) override
  696. {
  697. if (const char* const retName = CarlaEngine::renamePlugin(id, newName))
  698. {
  699. uiServerCallback(ENGINE_CALLBACK_PLUGIN_RENAMED, id, 0, 0, 0, 0.0f, retName);
  700. return retName;
  701. }
  702. return nullptr;
  703. }
  704. // -------------------------------------------------------------------
  705. void bufferSizeChanged(const uint32_t newBufferSize)
  706. {
  707. if (pData->bufferSize == newBufferSize)
  708. return;
  709. {
  710. const CarlaMutexLocker cml(fUiServer.getPipeLock());
  711. if (fUiServer.writeAndFixMessage("buffer-size"))
  712. {
  713. char tmpBuf[STR_MAX];
  714. carla_zeroChars(tmpBuf, STR_MAX);
  715. std::sprintf(tmpBuf, "%i\n", newBufferSize);
  716. if (fUiServer.writeMessage(tmpBuf))
  717. fUiServer.flushMessages();
  718. }
  719. }
  720. pData->bufferSize = newBufferSize;
  721. CarlaEngine::bufferSizeChanged(newBufferSize);
  722. }
  723. void sampleRateChanged(const double newSampleRate)
  724. {
  725. if (carla_isEqual(pData->sampleRate, newSampleRate))
  726. return;
  727. {
  728. const CarlaMutexLocker cml(fUiServer.getPipeLock());
  729. if (fUiServer.writeAndFixMessage("sample-rate"))
  730. {
  731. char tmpBuf[STR_MAX];
  732. carla_zeroChars(tmpBuf, STR_MAX);
  733. {
  734. const CarlaScopedLocale csl;
  735. std::sprintf(tmpBuf, "%f\n", newSampleRate);
  736. }
  737. if (fUiServer.writeMessage(tmpBuf))
  738. fUiServer.flushMessages();
  739. }
  740. }
  741. pData->sampleRate = newSampleRate;
  742. CarlaEngine::sampleRateChanged(newSampleRate);
  743. }
  744. // -------------------------------------------------------------------
  745. void uiServerSendPluginInfo(CarlaPlugin* const plugin)
  746. {
  747. char tmpBuf[STR_MAX];
  748. carla_zeroChars(tmpBuf, STR_MAX);
  749. const CarlaMutexLocker cml(fUiServer.getPipeLock());
  750. const uint pluginId(plugin->getId());
  751. std::sprintf(tmpBuf, "PLUGIN_INFO_%i\n", pluginId);
  752. if (! fUiServer.writeMessage(tmpBuf))
  753. return;
  754. std::sprintf(tmpBuf, "%i:%i:%i:" P_INT64 ":%i:%i\n", plugin->getType(), plugin->getCategory(), plugin->getHints(), plugin->getUniqueId(), plugin->getOptionsAvailable(), plugin->getOptionsEnabled());
  755. if (! fUiServer.writeMessage(tmpBuf))
  756. return;
  757. if (const char* const filename = plugin->getFilename())
  758. {
  759. std::sprintf(tmpBuf, "%s", filename);
  760. if (! fUiServer.writeAndFixMessage(tmpBuf))
  761. return;
  762. }
  763. else
  764. {
  765. if (! fUiServer.writeMessage("\n"))
  766. return;
  767. }
  768. if (const char* const name = plugin->getName())
  769. {
  770. std::sprintf(tmpBuf, "%s", name);
  771. if (! fUiServer.writeAndFixMessage(tmpBuf))
  772. return;
  773. }
  774. else
  775. {
  776. if (! fUiServer.writeMessage("\n"))
  777. return;
  778. }
  779. if (const char* const iconName = plugin->getIconName())
  780. {
  781. std::sprintf(tmpBuf, "%s", iconName);
  782. if (! fUiServer.writeAndFixMessage(tmpBuf))
  783. return;
  784. }
  785. else
  786. {
  787. if (! fUiServer.writeMessage("\n"))
  788. return;
  789. }
  790. plugin->getRealName(tmpBuf);
  791. if (! fUiServer.writeAndFixMessage(tmpBuf))
  792. return;
  793. plugin->getLabel(tmpBuf);
  794. if (! fUiServer.writeAndFixMessage(tmpBuf))
  795. return;
  796. plugin->getMaker(tmpBuf);
  797. if (! fUiServer.writeAndFixMessage(tmpBuf))
  798. return;
  799. plugin->getCopyright(tmpBuf);
  800. if (! fUiServer.writeAndFixMessage(tmpBuf))
  801. return;
  802. std::sprintf(tmpBuf, "AUDIO_COUNT_%i:%i:%i\n", pluginId, plugin->getAudioInCount(), plugin->getAudioOutCount());
  803. if (! fUiServer.writeMessage(tmpBuf))
  804. return;
  805. std::sprintf(tmpBuf, "MIDI_COUNT_%i:%i:%i\n", pluginId, plugin->getMidiInCount(), plugin->getMidiOutCount());
  806. if (! fUiServer.writeMessage(tmpBuf))
  807. return;
  808. fUiServer.flushMessages();
  809. }
  810. void uiServerSendPluginParameters(CarlaPlugin* const plugin)
  811. {
  812. char tmpBuf[STR_MAX];
  813. carla_zeroChars(tmpBuf, STR_MAX);
  814. const CarlaMutexLocker cml(fUiServer.getPipeLock());
  815. const CarlaScopedLocale csl;
  816. const uint pluginId(plugin->getId());
  817. for (int32_t i=PARAMETER_ACTIVE; i>PARAMETER_MAX; --i)
  818. {
  819. std::sprintf(tmpBuf, "PARAMVAL_%i:%i\n", pluginId, i);
  820. if (! fUiServer.writeMessage(tmpBuf))
  821. return;
  822. std::sprintf(tmpBuf, "%f\n", static_cast<double>(plugin->getInternalParameterValue(i)));
  823. if (! fUiServer.writeMessage(tmpBuf))
  824. return;
  825. fUiServer.flushMessages();
  826. }
  827. uint32_t ins, outs, count;
  828. plugin->getParameterCountInfo(ins, outs);
  829. count = plugin->getParameterCount();
  830. std::sprintf(tmpBuf, "PARAMETER_COUNT_%i:%i:%i:%i\n", pluginId, ins, outs, count);
  831. if (! fUiServer.writeMessage(tmpBuf))
  832. return;
  833. for (uint32_t i=0; i<count; ++i)
  834. {
  835. const ParameterData& paramData(plugin->getParameterData(i));
  836. const ParameterRanges& paramRanges(plugin->getParameterRanges(i));
  837. std::sprintf(tmpBuf, "PARAMETER_DATA_%i:%i\n", pluginId, i);
  838. if (! fUiServer.writeMessage(tmpBuf))
  839. return;
  840. std::sprintf(tmpBuf, "%i:%i:%i:%i\n", paramData.type, paramData.hints, paramData.midiChannel, paramData.midiCC);
  841. if (! fUiServer.writeMessage(tmpBuf))
  842. return;
  843. plugin->getParameterName(i, tmpBuf);
  844. if (! fUiServer.writeAndFixMessage(tmpBuf))
  845. return;
  846. plugin->getParameterUnit(i, tmpBuf);
  847. if (! fUiServer.writeAndFixMessage(tmpBuf))
  848. return;
  849. std::sprintf(tmpBuf, "PARAMETER_RANGES_%i:%i\n", pluginId, i);
  850. if (! fUiServer.writeMessage(tmpBuf))
  851. return;
  852. std::sprintf(tmpBuf, "%f:%f:%f:%f:%f:%f\n",
  853. static_cast<double>(paramRanges.def),
  854. static_cast<double>(paramRanges.min),
  855. static_cast<double>(paramRanges.max),
  856. static_cast<double>(paramRanges.step),
  857. static_cast<double>(paramRanges.stepSmall),
  858. static_cast<double>(paramRanges.stepLarge));
  859. if (! fUiServer.writeMessage(tmpBuf))
  860. return;
  861. std::sprintf(tmpBuf, "PARAMVAL_%i:%i\n", pluginId, i);
  862. if (! fUiServer.writeMessage(tmpBuf))
  863. return;
  864. std::sprintf(tmpBuf, "%f\n", static_cast<double>(plugin->getParameterValue(i)));
  865. if (! fUiServer.writeMessage(tmpBuf))
  866. return;
  867. }
  868. fUiServer.flushMessages();
  869. }
  870. void uiServerSendPluginPrograms(CarlaPlugin* const plugin)
  871. {
  872. char tmpBuf[STR_MAX];
  873. carla_zeroChars(tmpBuf, STR_MAX);
  874. const CarlaMutexLocker cml(fUiServer.getPipeLock());
  875. const uint pluginId(plugin->getId());
  876. uint32_t count = plugin->getProgramCount();
  877. std::sprintf(tmpBuf, "PROGRAM_COUNT_%i:%i:%i\n", pluginId, count, plugin->getCurrentProgram());
  878. if (! fUiServer.writeMessage(tmpBuf))
  879. return;
  880. for (uint32_t i=0; i<count; ++i)
  881. {
  882. std::sprintf(tmpBuf, "PROGRAM_NAME_%i:%i\n", pluginId, i);
  883. if (! fUiServer.writeMessage(tmpBuf))
  884. return;
  885. plugin->getProgramName(i, tmpBuf);
  886. if (! fUiServer.writeAndFixMessage(tmpBuf))
  887. return;
  888. }
  889. fUiServer.flushMessages();
  890. count = plugin->getMidiProgramCount();
  891. std::sprintf(tmpBuf, "MIDI_PROGRAM_COUNT_%i:%i:%i\n", pluginId, count, plugin->getCurrentMidiProgram());
  892. if (! fUiServer.writeMessage(tmpBuf))
  893. return;
  894. for (uint32_t i=0; i<count; ++i)
  895. {
  896. std::sprintf(tmpBuf, "MIDI_PROGRAM_DATA_%i:%i\n", pluginId, i);
  897. if (! fUiServer.writeMessage(tmpBuf))
  898. return;
  899. const MidiProgramData& mpData(plugin->getMidiProgramData(i));
  900. std::sprintf(tmpBuf, "%i:%i\n", mpData.bank, mpData.program);
  901. if (! fUiServer.writeMessage(tmpBuf))
  902. return;
  903. std::sprintf(tmpBuf, "%s", mpData.name);
  904. if (! fUiServer.writeAndFixMessage(tmpBuf))
  905. return;
  906. }
  907. fUiServer.flushMessages();
  908. }
  909. void uiServerSendPluginProperties(CarlaPlugin* const plugin)
  910. {
  911. char tmpBuf[STR_MAX];
  912. carla_zeroChars(tmpBuf, STR_MAX);
  913. const CarlaMutexLocker cml(fUiServer.getPipeLock());
  914. const uint pluginId(plugin->getId());
  915. uint32_t count = plugin->getCustomDataCount();
  916. std::sprintf(tmpBuf, "CUSTOM_DATA_COUNT_%i:%i\n", pluginId, count);
  917. if (! fUiServer.writeMessage(tmpBuf))
  918. return;
  919. for (uint32_t i=0; i<count; ++i)
  920. {
  921. const CustomData& customData(plugin->getCustomData(i));
  922. CARLA_SAFE_ASSERT_CONTINUE(customData.isValid());
  923. if (std::strcmp(customData.type, CUSTOM_DATA_TYPE_PROPERTY) != 0)
  924. continue;
  925. std::sprintf(tmpBuf, "CUSTOM_DATA_%i:%i\n", pluginId, i);
  926. if (! fUiServer.writeMessage(tmpBuf))
  927. return;
  928. if (! fUiServer.writeAndFixMessage(customData.type))
  929. return;
  930. if (! fUiServer.writeAndFixMessage(customData.key))
  931. return;
  932. if (! fUiServer.writeAndFixMessage(customData.value))
  933. return;
  934. }
  935. fUiServer.flushMessages();
  936. }
  937. void uiServerCallback(const EngineCallbackOpcode action, const uint pluginId,
  938. const int value1, const int value2, const int value3,
  939. const float valuef, const char* const valueStr)
  940. {
  941. if (! fIsRunning)
  942. return;
  943. if (! fUiServer.isPipeRunning())
  944. return;
  945. CarlaPlugin* plugin;
  946. switch (action)
  947. {
  948. case ENGINE_CALLBACK_UPDATE:
  949. plugin = getPlugin(pluginId);
  950. if (plugin != nullptr && plugin->isEnabled())
  951. {
  952. CARLA_SAFE_ASSERT_BREAK(plugin->getId() == pluginId);
  953. uiServerSendPluginProperties(plugin);
  954. }
  955. break;
  956. case ENGINE_CALLBACK_RELOAD_INFO:
  957. plugin = getPlugin(pluginId);
  958. if (plugin != nullptr && plugin->isEnabled())
  959. {
  960. CARLA_SAFE_ASSERT_BREAK(plugin->getId() == pluginId);
  961. uiServerSendPluginInfo(plugin);
  962. }
  963. break;
  964. case ENGINE_CALLBACK_RELOAD_PARAMETERS:
  965. plugin = getPlugin(pluginId);
  966. if (plugin != nullptr && plugin->isEnabled())
  967. {
  968. CARLA_SAFE_ASSERT_BREAK(plugin->getId() == pluginId);
  969. uiServerSendPluginParameters(plugin);
  970. }
  971. break;
  972. case ENGINE_CALLBACK_RELOAD_PROGRAMS:
  973. plugin = getPlugin(pluginId);
  974. if (plugin != nullptr && plugin->isEnabled())
  975. {
  976. CARLA_SAFE_ASSERT_BREAK(plugin->getId() == pluginId);
  977. uiServerSendPluginPrograms(plugin);
  978. }
  979. break;
  980. case ENGINE_CALLBACK_RELOAD_ALL:
  981. case ENGINE_CALLBACK_PLUGIN_ADDED:
  982. plugin = getPlugin(pluginId);
  983. if (plugin != nullptr && plugin->isEnabled())
  984. {
  985. CARLA_SAFE_ASSERT_BREAK(plugin->getId() == pluginId);
  986. uiServerSendPluginInfo(plugin);
  987. uiServerSendPluginParameters(plugin);
  988. uiServerSendPluginPrograms(plugin);
  989. uiServerSendPluginProperties(plugin);
  990. }
  991. break;
  992. default:
  993. break;
  994. }
  995. char tmpBuf[STR_MAX];
  996. carla_zeroChars(tmpBuf, STR_MAX);
  997. const CarlaMutexLocker cml(fUiServer.getPipeLock());
  998. std::sprintf(tmpBuf, "ENGINE_CALLBACK_%i\n", int(action));
  999. if (! fUiServer.writeMessage(tmpBuf))
  1000. return;
  1001. std::sprintf(tmpBuf, "%u\n", pluginId);
  1002. if (! fUiServer.writeMessage(tmpBuf))
  1003. return;
  1004. std::sprintf(tmpBuf, "%i\n", value1);
  1005. if (! fUiServer.writeMessage(tmpBuf))
  1006. return;
  1007. std::sprintf(tmpBuf, "%i\n", value2);
  1008. if (! fUiServer.writeMessage(tmpBuf))
  1009. return;
  1010. std::sprintf(tmpBuf, "%i\n", value3);
  1011. if (! fUiServer.writeMessage(tmpBuf))
  1012. return;
  1013. {
  1014. const CarlaScopedLocale csl;
  1015. std::sprintf(tmpBuf, "%f\n", static_cast<double>(valuef));
  1016. }
  1017. if (! fUiServer.writeMessage(tmpBuf))
  1018. return;
  1019. if (! fUiServer.writeAndFixMessage(valueStr != nullptr ? valueStr : ""))
  1020. return;
  1021. fUiServer.flushMessages();
  1022. }
  1023. const char* uiFileCallback(FileCallbackOpcode action, bool isDir, const char* title, const char* filter)
  1024. {
  1025. switch (action)
  1026. {
  1027. case FILE_CALLBACK_DEBUG:
  1028. return nullptr;
  1029. case FILE_CALLBACK_OPEN:
  1030. return pHost->ui_open_file(pHost->handle, isDir, title, filter);
  1031. case FILE_CALLBACK_SAVE:
  1032. return pHost->ui_save_file(pHost->handle, isDir, title, filter);
  1033. }
  1034. return nullptr;
  1035. }
  1036. void uiServerInfo()
  1037. {
  1038. CARLA_SAFE_ASSERT_RETURN(fIsRunning,);
  1039. CARLA_SAFE_ASSERT_RETURN(fUiServer.isPipeRunning(),);
  1040. char tmpBuf[STR_MAX];
  1041. carla_zeroChars(tmpBuf, STR_MAX);
  1042. const CarlaMutexLocker cml(fUiServer.getPipeLock());
  1043. #if defined(HAVE_LIBLO) && !defined(BUILD_BRIDGE)
  1044. if (! fUiServer.writeAndFixMessage("osc-urls"))
  1045. return;
  1046. if (! fUiServer.writeAndFixMessage(pData->osc.getServerPathTCP()))
  1047. return;
  1048. if (! fUiServer.writeAndFixMessage(pData->osc.getServerPathUDP()))
  1049. return;
  1050. #endif
  1051. if (! fUiServer.writeAndFixMessage("max-plugin-number"))
  1052. return;
  1053. std::sprintf(tmpBuf, "%i\n", pData->maxPluginNumber);
  1054. if (! fUiServer.writeMessage(tmpBuf))
  1055. return;
  1056. if (! fUiServer.writeAndFixMessage("buffer-size"))
  1057. return;
  1058. std::sprintf(tmpBuf, "%i\n", pData->bufferSize);
  1059. if (! fUiServer.writeMessage(tmpBuf))
  1060. return;
  1061. if (! fUiServer.writeAndFixMessage("sample-rate"))
  1062. return;
  1063. {
  1064. const CarlaScopedLocale csl;
  1065. std::sprintf(tmpBuf, "%f\n", pData->sampleRate);
  1066. }
  1067. if (! fUiServer.writeMessage(tmpBuf))
  1068. return;
  1069. fUiServer.flushMessages();
  1070. }
  1071. void uiServerOptions()
  1072. {
  1073. CARLA_SAFE_ASSERT_RETURN(fIsRunning,);
  1074. CARLA_SAFE_ASSERT_RETURN(fUiServer.isPipeRunning(),);
  1075. char tmpBuf[STR_MAX];
  1076. carla_zeroChars(tmpBuf, STR_MAX);
  1077. const EngineOptions& options(pData->options);
  1078. const CarlaMutexLocker cml(fUiServer.getPipeLock());
  1079. const char* const optionsForcedStr(fOptionsForced ? "true\n" : "false\n");
  1080. const std::size_t optionsForcedStrSize(fOptionsForced ? 5 : 6);
  1081. std::sprintf(tmpBuf, "ENGINE_OPTION_%i\n", ENGINE_OPTION_PROCESS_MODE);
  1082. if (! fUiServer.writeMessage(tmpBuf))
  1083. return;
  1084. if (! fUiServer.writeMessage(optionsForcedStr, optionsForcedStrSize))
  1085. return;
  1086. std::sprintf(tmpBuf, "%i\n", options.processMode);
  1087. if (! fUiServer.writeMessage(tmpBuf))
  1088. return;
  1089. fUiServer.flushMessages();
  1090. std::sprintf(tmpBuf, "ENGINE_OPTION_%i\n", ENGINE_OPTION_TRANSPORT_MODE);
  1091. if (! fUiServer.writeMessage(tmpBuf))
  1092. return;
  1093. if (! fUiServer.writeMessage(optionsForcedStr, optionsForcedStrSize))
  1094. return;
  1095. std::sprintf(tmpBuf, "%i\n", options.transportMode);
  1096. if (! fUiServer.writeMessage(tmpBuf))
  1097. return;
  1098. fUiServer.flushMessages();
  1099. std::sprintf(tmpBuf, "ENGINE_OPTION_%i\n", ENGINE_OPTION_FORCE_STEREO);
  1100. if (! fUiServer.writeMessage(tmpBuf))
  1101. return;
  1102. if (! fUiServer.writeMessage(optionsForcedStr, optionsForcedStrSize))
  1103. return;
  1104. if (! fUiServer.writeMessage(options.forceStereo ? "true\n" : "false\n"))
  1105. return;
  1106. fUiServer.flushMessages();
  1107. std::sprintf(tmpBuf, "ENGINE_OPTION_%i\n", ENGINE_OPTION_PREFER_PLUGIN_BRIDGES);
  1108. if (! fUiServer.writeMessage(tmpBuf))
  1109. return;
  1110. if (! fUiServer.writeMessage(optionsForcedStr, optionsForcedStrSize))
  1111. return;
  1112. if (! fUiServer.writeMessage(options.preferPluginBridges ? "true\n" : "false\n"))
  1113. return;
  1114. fUiServer.flushMessages();
  1115. std::sprintf(tmpBuf, "ENGINE_OPTION_%i\n", ENGINE_OPTION_PREFER_UI_BRIDGES);
  1116. if (! fUiServer.writeMessage(tmpBuf))
  1117. return;
  1118. if (! fUiServer.writeMessage(optionsForcedStr, optionsForcedStrSize))
  1119. return;
  1120. if (! fUiServer.writeMessage(options.preferUiBridges ? "true\n" : "false\n"))
  1121. return;
  1122. fUiServer.flushMessages();
  1123. std::sprintf(tmpBuf, "ENGINE_OPTION_%i\n", ENGINE_OPTION_UIS_ALWAYS_ON_TOP);
  1124. if (! fUiServer.writeMessage(tmpBuf))
  1125. return;
  1126. if (! fUiServer.writeMessage(optionsForcedStr, optionsForcedStrSize))
  1127. return;
  1128. if (! fUiServer.writeMessage(options.uisAlwaysOnTop ? "true\n" : "false\n"))
  1129. return;
  1130. fUiServer.flushMessages();
  1131. std::sprintf(tmpBuf, "ENGINE_OPTION_%i\n", ENGINE_OPTION_MAX_PARAMETERS);
  1132. if (! fUiServer.writeMessage(tmpBuf))
  1133. return;
  1134. if (! fUiServer.writeMessage(optionsForcedStr, optionsForcedStrSize))
  1135. return;
  1136. std::sprintf(tmpBuf, "%i\n", options.maxParameters);
  1137. if (! fUiServer.writeMessage(tmpBuf))
  1138. return;
  1139. fUiServer.flushMessages();
  1140. std::sprintf(tmpBuf, "ENGINE_OPTION_%i\n", ENGINE_OPTION_UI_BRIDGES_TIMEOUT);
  1141. if (! fUiServer.writeMessage(tmpBuf))
  1142. return;
  1143. if (! fUiServer.writeMessage(optionsForcedStr, optionsForcedStrSize))
  1144. return;
  1145. std::sprintf(tmpBuf, "%i\n", options.uiBridgesTimeout);
  1146. if (! fUiServer.writeMessage(tmpBuf))
  1147. return;
  1148. fUiServer.flushMessages();
  1149. std::sprintf(tmpBuf, "ENGINE_OPTION_%i\n", ENGINE_OPTION_PATH_BINARIES);
  1150. if (! fUiServer.writeMessage(tmpBuf))
  1151. return;
  1152. if (! fUiServer.writeMessage("true\n", 5))
  1153. return;
  1154. std::sprintf(tmpBuf, "%s\n", options.binaryDir);
  1155. if (! fUiServer.writeMessage(tmpBuf))
  1156. return;
  1157. fUiServer.flushMessages();
  1158. std::sprintf(tmpBuf, "ENGINE_OPTION_%i\n", ENGINE_OPTION_PATH_RESOURCES);
  1159. if (! fUiServer.writeMessage(tmpBuf))
  1160. return;
  1161. if (! fUiServer.writeMessage("true\n", 5))
  1162. return;
  1163. std::sprintf(tmpBuf, "%s\n", options.resourceDir);
  1164. if (! fUiServer.writeMessage(tmpBuf))
  1165. return;
  1166. fUiServer.flushMessages();
  1167. }
  1168. // -------------------------------------------------------------------
  1169. // Plugin parameter calls
  1170. uint32_t getParameterCount() const
  1171. {
  1172. if (CarlaPlugin* const plugin = _getFirstPlugin())
  1173. return plugin->getParameterCount();
  1174. return 0;
  1175. }
  1176. const NativeParameter* getParameterInfo(const uint32_t index) const
  1177. {
  1178. if (CarlaPlugin* const plugin = _getFirstPlugin())
  1179. {
  1180. if (index < plugin->getParameterCount())
  1181. {
  1182. static NativeParameter param;
  1183. static char strBufName[STR_MAX+1];
  1184. static char strBufUnit[STR_MAX+1];
  1185. const ParameterData& paramData(plugin->getParameterData(index));
  1186. const ParameterRanges& paramRanges(plugin->getParameterRanges(index));
  1187. plugin->getParameterName(index, strBufName);
  1188. plugin->getParameterUnit(index, strBufUnit);
  1189. uint hints = 0x0;
  1190. if (paramData.hints & PARAMETER_IS_BOOLEAN)
  1191. hints |= NATIVE_PARAMETER_IS_BOOLEAN;
  1192. if (paramData.hints & PARAMETER_IS_INTEGER)
  1193. hints |= NATIVE_PARAMETER_IS_INTEGER;
  1194. if (paramData.hints & PARAMETER_IS_LOGARITHMIC)
  1195. hints |= NATIVE_PARAMETER_IS_LOGARITHMIC;
  1196. if (paramData.hints & PARAMETER_IS_AUTOMABLE)
  1197. hints |= NATIVE_PARAMETER_IS_AUTOMABLE;
  1198. if (paramData.hints & PARAMETER_USES_SAMPLERATE)
  1199. hints |= NATIVE_PARAMETER_USES_SAMPLE_RATE;
  1200. if (paramData.hints & PARAMETER_USES_SCALEPOINTS)
  1201. hints |= NATIVE_PARAMETER_USES_SCALEPOINTS;
  1202. if (paramData.type == PARAMETER_INPUT || paramData.type == PARAMETER_OUTPUT)
  1203. {
  1204. if (paramData.hints & PARAMETER_IS_ENABLED)
  1205. hints |= NATIVE_PARAMETER_IS_ENABLED;
  1206. if (paramData.type == PARAMETER_OUTPUT)
  1207. hints |= NATIVE_PARAMETER_IS_OUTPUT;
  1208. }
  1209. param.hints = static_cast<NativeParameterHints>(hints);
  1210. param.name = strBufName;
  1211. param.unit = strBufUnit;
  1212. param.ranges.def = paramRanges.def;
  1213. param.ranges.min = paramRanges.min;
  1214. param.ranges.max = paramRanges.max;
  1215. param.ranges.step = paramRanges.step;
  1216. param.ranges.stepSmall = paramRanges.stepSmall;
  1217. param.ranges.stepLarge = paramRanges.stepLarge;
  1218. param.scalePointCount = 0; // TODO
  1219. param.scalePoints = nullptr;
  1220. return &param;
  1221. }
  1222. }
  1223. return nullptr;
  1224. }
  1225. float getParameterValue(const uint32_t index) const
  1226. {
  1227. if (CarlaPlugin* const plugin = _getFirstPlugin())
  1228. {
  1229. if (index < plugin->getParameterCount())
  1230. return plugin->getParameterValue(index);
  1231. }
  1232. return 0.0f;
  1233. }
  1234. // -------------------------------------------------------------------
  1235. // Plugin midi-program calls
  1236. uint32_t getMidiProgramCount() const
  1237. {
  1238. if (CarlaPlugin* const plugin = _getFirstPlugin())
  1239. return plugin->getMidiProgramCount();
  1240. return 0;
  1241. }
  1242. const NativeMidiProgram* getMidiProgramInfo(const uint32_t index) const
  1243. {
  1244. if (CarlaPlugin* const plugin = _getFirstPlugin())
  1245. {
  1246. if (index < plugin->getMidiProgramCount())
  1247. {
  1248. static NativeMidiProgram midiProg;
  1249. {
  1250. const MidiProgramData& midiProgData(plugin->getMidiProgramData(index));
  1251. midiProg.bank = midiProgData.bank;
  1252. midiProg.program = midiProgData.program;
  1253. midiProg.name = midiProgData.name;
  1254. }
  1255. return &midiProg;
  1256. }
  1257. }
  1258. return nullptr;
  1259. }
  1260. // -------------------------------------------------------------------
  1261. // Plugin state calls
  1262. void setParameterValue(const uint32_t index, const float value)
  1263. {
  1264. if (CarlaPlugin* const plugin = _getFirstPlugin())
  1265. {
  1266. if (index < plugin->getParameterCount())
  1267. plugin->setParameterValue(index, value, false, false, false);
  1268. }
  1269. }
  1270. void setMidiProgram(const uint8_t, const uint32_t bank, const uint32_t program)
  1271. {
  1272. if (CarlaPlugin* const plugin = _getFirstPlugin())
  1273. plugin->setMidiProgramById(bank, program, false, false, false);
  1274. }
  1275. // -------------------------------------------------------------------
  1276. // Plugin process calls
  1277. void activate()
  1278. {
  1279. #if 0
  1280. for (uint i=0; i < pData->curPluginCount; ++i)
  1281. {
  1282. CarlaPlugin* const plugin(pData->plugins[i].plugin);
  1283. if (plugin == nullptr || ! plugin->isEnabled())
  1284. continue;
  1285. plugin->setActive(true, true, false);
  1286. }
  1287. #endif
  1288. fIsActive = true;
  1289. }
  1290. void deactivate()
  1291. {
  1292. fIsActive = false;
  1293. #if 0
  1294. for (uint i=0; i < pData->curPluginCount; ++i)
  1295. {
  1296. CarlaPlugin* const plugin(pData->plugins[i].plugin);
  1297. if (plugin == nullptr || ! plugin->isEnabled())
  1298. continue;
  1299. plugin->setActive(false, true, false);
  1300. }
  1301. #endif
  1302. // just in case
  1303. //runPendingRtEvents();
  1304. }
  1305. void process(float** const inBuffer, float** const outBuffer, const uint32_t frames,
  1306. const NativeMidiEvent* const midiEvents, const uint32_t midiEventCount)
  1307. {
  1308. if (frames > pData->bufferSize)
  1309. {
  1310. carla_stderr2("Host is calling process with too high number of frames! %u vs %u",
  1311. frames, pData->bufferSize);
  1312. deactivate();
  1313. bufferSizeChanged(frames);
  1314. activate();
  1315. }
  1316. const PendingRtEventsRunner prt(this, frames, true);
  1317. // ---------------------------------------------------------------
  1318. // Time Info
  1319. const NativeTimeInfo* const timeInfo(pHost->get_time_info(pHost->handle));
  1320. pData->timeInfo.playing = timeInfo->playing;
  1321. pData->timeInfo.frame = timeInfo->frame;
  1322. pData->timeInfo.usecs = timeInfo->usecs;
  1323. pData->timeInfo.bbt.valid = timeInfo->bbt.valid;
  1324. if (timeInfo->bbt.valid)
  1325. {
  1326. pData->timeInfo.bbt.bar = timeInfo->bbt.bar;
  1327. pData->timeInfo.bbt.beat = timeInfo->bbt.beat;
  1328. pData->timeInfo.bbt.tick = timeInfo->bbt.tick;
  1329. pData->timeInfo.bbt.barStartTick = timeInfo->bbt.barStartTick;
  1330. pData->timeInfo.bbt.beatsPerBar = timeInfo->bbt.beatsPerBar;
  1331. pData->timeInfo.bbt.beatType = timeInfo->bbt.beatType;
  1332. pData->timeInfo.bbt.ticksPerBeat = timeInfo->bbt.ticksPerBeat;
  1333. pData->timeInfo.bbt.beatsPerMinute = timeInfo->bbt.beatsPerMinute;
  1334. }
  1335. // ---------------------------------------------------------------
  1336. // Do nothing if no plugins and rack mode
  1337. if (pData->curPluginCount == 0 && ! kIsPatchbay)
  1338. {
  1339. if (outBuffer[0] != inBuffer[0])
  1340. carla_copyFloats(outBuffer[0], inBuffer[0], frames);
  1341. if (outBuffer[1] != inBuffer[1])
  1342. carla_copyFloats(outBuffer[1], inBuffer[1], frames);
  1343. for (uint32_t i=0; i < midiEventCount; ++i)
  1344. {
  1345. if (! pHost->write_midi_event(pHost->handle, &midiEvents[i]))
  1346. break;
  1347. }
  1348. return;
  1349. }
  1350. // ---------------------------------------------------------------
  1351. // initialize events
  1352. carla_zeroStructs(pData->events.in, kMaxEngineEventInternalCount);
  1353. carla_zeroStructs(pData->events.out, kMaxEngineEventInternalCount);
  1354. // ---------------------------------------------------------------
  1355. // events input (before processing)
  1356. {
  1357. uint32_t engineEventIndex = 0;
  1358. for (uint32_t i=0; i < midiEventCount && engineEventIndex < kMaxEngineEventInternalCount; ++i)
  1359. {
  1360. const NativeMidiEvent& midiEvent(midiEvents[i]);
  1361. EngineEvent& engineEvent(pData->events.in[engineEventIndex++]);
  1362. engineEvent.time = midiEvent.time;
  1363. engineEvent.fillFromMidiData(midiEvent.size, midiEvent.data, 0);
  1364. if (engineEventIndex >= kMaxEngineEventInternalCount)
  1365. break;
  1366. }
  1367. }
  1368. if (kIsPatchbay)
  1369. {
  1370. // -----------------------------------------------------------
  1371. // process
  1372. pData->graph.process(pData, inBuffer, outBuffer, frames);
  1373. }
  1374. else
  1375. {
  1376. // -----------------------------------------------------------
  1377. // create audio buffers
  1378. const float* inBuf[2] = { inBuffer[0], inBuffer[1] };
  1379. /* */ float* outBuf[2] = { outBuffer[0], outBuffer[1] };
  1380. // -----------------------------------------------------------
  1381. // process
  1382. pData->graph.processRack(pData, inBuf, outBuf, frames);
  1383. }
  1384. // ---------------------------------------------------------------
  1385. // events output (after processing)
  1386. carla_zeroStructs(pData->events.in, kMaxEngineEventInternalCount);
  1387. if (kHasMidiOut)
  1388. {
  1389. NativeMidiEvent midiEvent;
  1390. for (uint32_t i=0; i < kMaxEngineEventInternalCount; ++i)
  1391. {
  1392. const EngineEvent& engineEvent(pData->events.out[i]);
  1393. if (engineEvent.type == kEngineEventTypeNull)
  1394. break;
  1395. carla_zeroStruct(midiEvent);
  1396. midiEvent.time = engineEvent.time;
  1397. /**/ if (engineEvent.type == kEngineEventTypeControl)
  1398. {
  1399. midiEvent.port = 0;
  1400. midiEvent.size = engineEvent.ctrl.convertToMidiData(engineEvent.channel, midiEvent.data);
  1401. }
  1402. else if (engineEvent.type == kEngineEventTypeMidi)
  1403. {
  1404. if (engineEvent.midi.size > 4)
  1405. continue;
  1406. midiEvent.port = engineEvent.midi.port;
  1407. midiEvent.size = engineEvent.midi.size;
  1408. midiEvent.data[0] = static_cast<uint8_t>(engineEvent.midi.data[0] | (engineEvent.channel & MIDI_CHANNEL_BIT));
  1409. for (uint8_t j=1; j < midiEvent.size; ++j)
  1410. midiEvent.data[j] = engineEvent.midi.data[j];
  1411. }
  1412. else
  1413. {
  1414. continue;
  1415. }
  1416. if (midiEvent.size > 0)
  1417. pHost->write_midi_event(pHost->handle, &midiEvent);
  1418. }
  1419. }
  1420. }
  1421. // -------------------------------------------------------------------
  1422. // Plugin UI calls
  1423. void uiShow(const bool show)
  1424. {
  1425. if (show)
  1426. {
  1427. if (fUiServer.isPipeRunning())
  1428. {
  1429. fUiServer.writeFocusMessage();
  1430. return;
  1431. }
  1432. CarlaString path(pHost->resourceDir);
  1433. if (kIsPatchbay)
  1434. path += CARLA_OS_SEP_STR "carla-plugin-patchbay";
  1435. else
  1436. path += CARLA_OS_SEP_STR "carla-plugin";
  1437. #ifdef CARLA_OS_WIN
  1438. path += ".exe";
  1439. #endif
  1440. carla_stdout("Trying to start carla-plugin using \"%s\"", path.buffer());
  1441. fUiServer.setData(path, pData->sampleRate, pHost->uiName);
  1442. if (! fUiServer.startPipeServer(false))
  1443. {
  1444. pHost->dispatcher(pHost->handle, NATIVE_HOST_OPCODE_UI_UNAVAILABLE, 0, 0, nullptr, 0.0f);
  1445. return;
  1446. }
  1447. uiServerInfo();
  1448. uiServerOptions();
  1449. uiServerCallback(ENGINE_CALLBACK_ENGINE_STARTED,
  1450. pData->curPluginCount,
  1451. pData->options.processMode,
  1452. pData->options.transportMode,
  1453. static_cast<int>(pData->bufferSize),
  1454. static_cast<float>(pData->sampleRate),
  1455. "Plugin");
  1456. fUiServer.writeShowMessage();
  1457. for (uint i=0; i < pData->curPluginCount; ++i)
  1458. {
  1459. CarlaPlugin* const plugin(pData->plugins[i].plugin);
  1460. if (plugin != nullptr && plugin->isEnabled())
  1461. {
  1462. uiServerCallback(ENGINE_CALLBACK_PLUGIN_ADDED, i, 0, 0, 0, 0.0f, plugin->getName());
  1463. }
  1464. }
  1465. if (kIsPatchbay)
  1466. patchbayRefresh(true, false, false);
  1467. }
  1468. else
  1469. {
  1470. fUiServer.stopPipeServer(2000);
  1471. // hide all custom uis
  1472. for (uint i=0; i < pData->curPluginCount; ++i)
  1473. {
  1474. CarlaPlugin* const plugin(pData->plugins[i].plugin);
  1475. if (plugin != nullptr && plugin->isEnabled())
  1476. {
  1477. if (plugin->getHints() & PLUGIN_HAS_CUSTOM_UI)
  1478. {
  1479. try {
  1480. plugin->showCustomUI(false);
  1481. } CARLA_SAFE_EXCEPTION_CONTINUE("Plugin showCustomUI (hide)");
  1482. }
  1483. }
  1484. }
  1485. }
  1486. }
  1487. void uiIdle()
  1488. {
  1489. for (uint i=0; i < pData->curPluginCount; ++i)
  1490. {
  1491. CarlaPlugin* const plugin(pData->plugins[i].plugin);
  1492. if (plugin != nullptr && plugin->isEnabled())
  1493. {
  1494. const uint hints(plugin->getHints());
  1495. if ((hints & PLUGIN_HAS_CUSTOM_UI) != 0 && (hints & PLUGIN_NEEDS_UI_MAIN_THREAD) != 0)
  1496. {
  1497. try {
  1498. plugin->uiIdle();
  1499. } CARLA_SAFE_EXCEPTION_CONTINUE("Plugin uiIdle");
  1500. }
  1501. }
  1502. }
  1503. idlePipe();
  1504. switch (fUiServer.getAndResetUiState())
  1505. {
  1506. case CarlaExternalUI::UiNone:
  1507. case CarlaExternalUI::UiShow:
  1508. break;
  1509. case CarlaExternalUI::UiCrashed:
  1510. pHost->dispatcher(pHost->handle, NATIVE_HOST_OPCODE_UI_UNAVAILABLE, 0, 0, nullptr, 0.0f);
  1511. break;
  1512. case CarlaExternalUI::UiHide:
  1513. pHost->ui_closed(pHost->handle);
  1514. fUiServer.stopPipeServer(1000);
  1515. break;
  1516. }
  1517. }
  1518. void idlePipe()
  1519. {
  1520. if (! fUiServer.isPipeRunning())
  1521. return;
  1522. fUiServer.idlePipe();
  1523. char tmpBuf[STR_MAX];
  1524. carla_zeroChars(tmpBuf, STR_MAX);
  1525. const CarlaMutexLocker cml(fUiServer.getPipeLock());
  1526. const CarlaScopedLocale csl;
  1527. const EngineTimeInfo& timeInfo(pData->timeInfo);
  1528. // ------------------------------------------------------------------------------------------------------------
  1529. // send engine info
  1530. if (! fUiServer.writeAndFixMessage("runtime-info"))
  1531. return;
  1532. std::sprintf(tmpBuf, "%f:0\n", static_cast<double>(getDSPLoad()));
  1533. if (! fUiServer.writeMessage(tmpBuf))
  1534. return;
  1535. fUiServer.flushMessages();
  1536. // ------------------------------------------------------------------------------------------------------------
  1537. // send transport
  1538. if (! fUiServer.writeAndFixMessage("transport"))
  1539. return;
  1540. if (! fUiServer.writeMessage(timeInfo.playing ? "true\n" : "false\n"))
  1541. return;
  1542. if (timeInfo.bbt.valid)
  1543. {
  1544. std::sprintf(tmpBuf, P_UINT64 ":%i:%i:%i\n",
  1545. timeInfo.frame, timeInfo.bbt.bar, timeInfo.bbt.beat, static_cast<int>(timeInfo.bbt.tick + 0.5));
  1546. if (! fUiServer.writeMessage(tmpBuf))
  1547. return;
  1548. std::sprintf(tmpBuf, "%f\n", timeInfo.bbt.beatsPerMinute);
  1549. if (! fUiServer.writeMessage(tmpBuf))
  1550. return;
  1551. }
  1552. else
  1553. {
  1554. std::sprintf(tmpBuf, P_UINT64 ":0:0:0\n", timeInfo.frame);
  1555. if (! fUiServer.writeMessage(tmpBuf))
  1556. return;
  1557. if (! fUiServer.writeMessage("0.0\n"))
  1558. return;
  1559. }
  1560. fUiServer.flushMessages();
  1561. // ------------------------------------------------------------------------------------------------------------
  1562. // send peaks and param outputs for all plugins
  1563. for (uint i=0; i < pData->curPluginCount; ++i)
  1564. {
  1565. const EnginePluginData& plugData(pData->plugins[i]);
  1566. const CarlaPlugin* const plugin(pData->plugins[i].plugin);
  1567. std::sprintf(tmpBuf, "PEAKS_%i\n", i);
  1568. if (! fUiServer.writeMessage(tmpBuf))
  1569. return;
  1570. std::sprintf(tmpBuf, "%f:%f:%f:%f\n",
  1571. static_cast<double>(plugData.peaks[0]),
  1572. static_cast<double>(plugData.peaks[1]),
  1573. static_cast<double>(plugData.peaks[2]),
  1574. static_cast<double>(plugData.peaks[3]));
  1575. if (! fUiServer.writeMessage(tmpBuf))
  1576. return;
  1577. fUiServer.flushMessages();
  1578. for (uint32_t j=0, count=plugin->getParameterCount(); j < count; ++j)
  1579. {
  1580. if (! plugin->isParameterOutput(j))
  1581. continue;
  1582. std::sprintf(tmpBuf, "PARAMVAL_%i:%i\n", i, j);
  1583. if (! fUiServer.writeMessage(tmpBuf))
  1584. return;
  1585. std::sprintf(tmpBuf, "%f\n", static_cast<double>(plugin->getParameterValue(j)));
  1586. if (! fUiServer.writeMessage(tmpBuf))
  1587. return;
  1588. fUiServer.flushMessages();
  1589. }
  1590. }
  1591. }
  1592. // -------------------------------------------------------------------
  1593. // Plugin state calls
  1594. char* getState() const
  1595. {
  1596. MemoryOutputStream out;
  1597. saveProjectInternal(out);
  1598. return strdup(out.toString().toRawUTF8());
  1599. }
  1600. void setState(const char* const data)
  1601. {
  1602. // remove all plugins from UI side
  1603. for (uint i=0, count=pData->curPluginCount; i < count; ++i)
  1604. CarlaEngine::callback(true, true, ENGINE_CALLBACK_PLUGIN_REMOVED, count-i-1, 0, 0, 0, 0.0f, nullptr);
  1605. // remove all plugins from backend, no lock
  1606. fIsRunning = false;
  1607. removeAllPlugins();
  1608. fIsRunning = true;
  1609. // stopped during removeAllPlugins()
  1610. if (! pData->thread.isThreadRunning())
  1611. pData->thread.startThread();
  1612. fOptionsForced = true;
  1613. const String state(data);
  1614. XmlDocument xml(state);
  1615. loadProjectInternal(xml);
  1616. }
  1617. // -------------------------------------------------------------------
  1618. public:
  1619. #define handlePtr ((CarlaEngineNative*)handle)
  1620. static NativePluginHandle _instantiateRack(const NativeHostDescriptor* host)
  1621. {
  1622. return new CarlaEngineNative(host, false, true);
  1623. }
  1624. static NativePluginHandle _instantiateRackNoMidiOut(const NativeHostDescriptor* host)
  1625. {
  1626. return new CarlaEngineNative(host, false, false);
  1627. }
  1628. static NativePluginHandle _instantiatePatchbay(const NativeHostDescriptor* host)
  1629. {
  1630. return new CarlaEngineNative(host, true, true);
  1631. }
  1632. static NativePluginHandle _instantiatePatchbay3s(const NativeHostDescriptor* host)
  1633. {
  1634. return new CarlaEngineNative(host, true, true, 3, 2);
  1635. }
  1636. static NativePluginHandle _instantiatePatchbay16(const NativeHostDescriptor* host)
  1637. {
  1638. return new CarlaEngineNative(host, true, true, 16, 16);
  1639. }
  1640. static NativePluginHandle _instantiatePatchbay32(const NativeHostDescriptor* host)
  1641. {
  1642. return new CarlaEngineNative(host, true, true, 32, 32);
  1643. }
  1644. static void _cleanup(NativePluginHandle handle)
  1645. {
  1646. delete handlePtr;
  1647. }
  1648. static uint32_t _get_parameter_count(NativePluginHandle handle)
  1649. {
  1650. return handlePtr->getParameterCount();
  1651. }
  1652. static const NativeParameter* _get_parameter_info(NativePluginHandle handle, uint32_t index)
  1653. {
  1654. return handlePtr->getParameterInfo(index);
  1655. }
  1656. static float _get_parameter_value(NativePluginHandle handle, uint32_t index)
  1657. {
  1658. return handlePtr->getParameterValue(index);
  1659. }
  1660. static uint32_t _get_midi_program_count(NativePluginHandle handle)
  1661. {
  1662. return handlePtr->getMidiProgramCount();
  1663. }
  1664. static const NativeMidiProgram* _get_midi_program_info(NativePluginHandle handle, uint32_t index)
  1665. {
  1666. return handlePtr->getMidiProgramInfo(index);
  1667. }
  1668. static void _set_parameter_value(NativePluginHandle handle, uint32_t index, float value)
  1669. {
  1670. handlePtr->setParameterValue(index, value);
  1671. }
  1672. static void _set_midi_program(NativePluginHandle handle, uint8_t channel, uint32_t bank, uint32_t program)
  1673. {
  1674. handlePtr->setMidiProgram(channel, bank, program);
  1675. }
  1676. static void _ui_show(NativePluginHandle handle, bool show)
  1677. {
  1678. handlePtr->uiShow(show);
  1679. }
  1680. static void _ui_idle(NativePluginHandle handle)
  1681. {
  1682. handlePtr->uiIdle();
  1683. }
  1684. static void _activate(NativePluginHandle handle)
  1685. {
  1686. handlePtr->activate();
  1687. }
  1688. static void _deactivate(NativePluginHandle handle)
  1689. {
  1690. handlePtr->deactivate();
  1691. }
  1692. static void _process(NativePluginHandle handle, float** inBuffer, float** outBuffer, const uint32_t frames, const NativeMidiEvent* midiEvents, uint32_t midiEventCount)
  1693. {
  1694. handlePtr->process(inBuffer, outBuffer, frames, midiEvents, midiEventCount);
  1695. }
  1696. static char* _get_state(NativePluginHandle handle)
  1697. {
  1698. return handlePtr->getState();
  1699. }
  1700. static void _set_state(NativePluginHandle handle, const char* data)
  1701. {
  1702. handlePtr->setState(data);
  1703. }
  1704. static intptr_t _dispatcher(NativePluginHandle handle, NativePluginDispatcherOpcode opcode, int32_t index, intptr_t value, void* ptr, float opt)
  1705. {
  1706. switch(opcode)
  1707. {
  1708. case NATIVE_PLUGIN_OPCODE_NULL:
  1709. return 0;
  1710. case NATIVE_PLUGIN_OPCODE_BUFFER_SIZE_CHANGED:
  1711. CARLA_SAFE_ASSERT_RETURN(value > 0, 0);
  1712. handlePtr->bufferSizeChanged(static_cast<uint32_t>(value));
  1713. return 0;
  1714. case NATIVE_PLUGIN_OPCODE_SAMPLE_RATE_CHANGED:
  1715. CARLA_SAFE_ASSERT_RETURN(opt > 0.0f, 0);
  1716. handlePtr->sampleRateChanged(static_cast<double>(opt));
  1717. return 0;
  1718. case NATIVE_PLUGIN_OPCODE_OFFLINE_CHANGED:
  1719. handlePtr->offlineModeChanged(value != 0);
  1720. return 0;
  1721. case NATIVE_PLUGIN_OPCODE_UI_NAME_CHANGED:
  1722. //handlePtr->uiNameChanged(static_cast<const char*>(ptr));
  1723. return 0;
  1724. case NATIVE_PLUGIN_OPCODE_GET_INTERNAL_HANDLE: {
  1725. CarlaEngineNative* const engine = handlePtr;
  1726. return (intptr_t)(CarlaEngine*)engine;
  1727. }
  1728. }
  1729. return 0;
  1730. // unused
  1731. (void)index;
  1732. (void)ptr;
  1733. }
  1734. // -------------------------------------------------------------------
  1735. static void _ui_server_callback(void* handle, EngineCallbackOpcode action, uint pluginId,
  1736. int value1, int value2, int value3,
  1737. float valuef, const char* valueStr)
  1738. {
  1739. handlePtr->uiServerCallback(action, pluginId, value1, value2, value3, valuef, valueStr);
  1740. }
  1741. static const char* _ui_file_callback(void* handle, FileCallbackOpcode action, bool isDir,
  1742. const char* title, const char* filter)
  1743. {
  1744. return handlePtr->uiFileCallback(action, isDir, title, filter);
  1745. }
  1746. // -------------------------------------------------------------------
  1747. #undef handlePtr
  1748. private:
  1749. const NativeHostDescriptor* const pHost;
  1750. #ifdef USE_JUCE_MESSAGE_THREAD
  1751. const bool kNeedsJuceMsgThread;
  1752. const juce::SharedResourcePointer<SharedJuceMessageThread> fJuceMsgThread;
  1753. #endif
  1754. const bool kIsPatchbay; // rack if false
  1755. const bool kHasMidiOut;
  1756. bool fIsActive, fIsRunning;
  1757. CarlaEngineNativeUI fUiServer;
  1758. bool fOptionsForced;
  1759. CarlaPlugin* _getFirstPlugin() const noexcept
  1760. {
  1761. if (pData->curPluginCount == 0 || pData->plugins == nullptr)
  1762. return nullptr;
  1763. CarlaPlugin* const plugin(pData->plugins[0].plugin);
  1764. if (plugin == nullptr || ! plugin->isEnabled())
  1765. return nullptr;
  1766. return pData->plugins[0].plugin;
  1767. }
  1768. CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaEngineNative)
  1769. };
  1770. // -----------------------------------------------------------------------
  1771. static const NativePluginDescriptor carlaRackDesc = {
  1772. /* category */ NATIVE_PLUGIN_CATEGORY_OTHER,
  1773. /* hints */ static_cast<NativePluginHints>(NATIVE_PLUGIN_IS_SYNTH
  1774. |NATIVE_PLUGIN_HAS_UI
  1775. |NATIVE_PLUGIN_NEEDS_UI_MAIN_THREAD
  1776. |NATIVE_PLUGIN_USES_STATE
  1777. |NATIVE_PLUGIN_USES_TIME),
  1778. /* supports */ static_cast<NativePluginSupports>(NATIVE_PLUGIN_SUPPORTS_EVERYTHING),
  1779. /* audioIns */ 2,
  1780. /* audioOuts */ 2,
  1781. /* midiIns */ 1,
  1782. /* midiOuts */ 1,
  1783. /* paramIns */ 0,
  1784. /* paramOuts */ 0,
  1785. /* name */ "Carla-Rack",
  1786. /* label */ "carlarack",
  1787. /* maker */ "falkTX",
  1788. /* copyright */ "GNU GPL v2+",
  1789. CarlaEngineNative::_instantiateRack,
  1790. CarlaEngineNative::_cleanup,
  1791. CarlaEngineNative::_get_parameter_count,
  1792. CarlaEngineNative::_get_parameter_info,
  1793. CarlaEngineNative::_get_parameter_value,
  1794. CarlaEngineNative::_get_midi_program_count,
  1795. CarlaEngineNative::_get_midi_program_info,
  1796. CarlaEngineNative::_set_parameter_value,
  1797. CarlaEngineNative::_set_midi_program,
  1798. /* _set_custom_data */ nullptr,
  1799. CarlaEngineNative::_ui_show,
  1800. CarlaEngineNative::_ui_idle,
  1801. /* _ui_set_parameter_value */ nullptr,
  1802. /* _ui_set_midi_program */ nullptr,
  1803. /* _ui_set_custom_data */ nullptr,
  1804. CarlaEngineNative::_activate,
  1805. CarlaEngineNative::_deactivate,
  1806. CarlaEngineNative::_process,
  1807. CarlaEngineNative::_get_state,
  1808. CarlaEngineNative::_set_state,
  1809. CarlaEngineNative::_dispatcher
  1810. };
  1811. static const NativePluginDescriptor carlaRackNoMidiOutDesc = {
  1812. /* category */ NATIVE_PLUGIN_CATEGORY_OTHER,
  1813. /* hints */ static_cast<NativePluginHints>(NATIVE_PLUGIN_IS_SYNTH
  1814. |NATIVE_PLUGIN_HAS_UI
  1815. |NATIVE_PLUGIN_NEEDS_UI_MAIN_THREAD
  1816. |NATIVE_PLUGIN_USES_STATE
  1817. |NATIVE_PLUGIN_USES_TIME),
  1818. /* supports */ static_cast<NativePluginSupports>(NATIVE_PLUGIN_SUPPORTS_EVERYTHING),
  1819. /* audioIns */ 2,
  1820. /* audioOuts */ 2,
  1821. /* midiIns */ 1,
  1822. /* midiOuts */ 0,
  1823. /* paramIns */ 0,
  1824. /* paramOuts */ 0,
  1825. /* name */ "Carla-Rack (no midi out)",
  1826. /* label */ "carlarack-nomidiout",
  1827. /* maker */ "falkTX",
  1828. /* copyright */ "GNU GPL v2+",
  1829. CarlaEngineNative::_instantiateRackNoMidiOut,
  1830. CarlaEngineNative::_cleanup,
  1831. CarlaEngineNative::_get_parameter_count,
  1832. CarlaEngineNative::_get_parameter_info,
  1833. CarlaEngineNative::_get_parameter_value,
  1834. CarlaEngineNative::_get_midi_program_count,
  1835. CarlaEngineNative::_get_midi_program_info,
  1836. CarlaEngineNative::_set_parameter_value,
  1837. CarlaEngineNative::_set_midi_program,
  1838. /* _set_custom_data */ nullptr,
  1839. CarlaEngineNative::_ui_show,
  1840. CarlaEngineNative::_ui_idle,
  1841. /* _ui_set_parameter_value */ nullptr,
  1842. /* _ui_set_midi_program */ nullptr,
  1843. /* _ui_set_custom_data */ nullptr,
  1844. CarlaEngineNative::_activate,
  1845. CarlaEngineNative::_deactivate,
  1846. CarlaEngineNative::_process,
  1847. CarlaEngineNative::_get_state,
  1848. CarlaEngineNative::_set_state,
  1849. CarlaEngineNative::_dispatcher
  1850. };
  1851. static const NativePluginDescriptor carlaPatchbayDesc = {
  1852. /* category */ NATIVE_PLUGIN_CATEGORY_OTHER,
  1853. /* hints */ static_cast<NativePluginHints>(NATIVE_PLUGIN_IS_SYNTH
  1854. |NATIVE_PLUGIN_HAS_UI
  1855. |NATIVE_PLUGIN_NEEDS_UI_MAIN_THREAD
  1856. |NATIVE_PLUGIN_USES_STATE
  1857. |NATIVE_PLUGIN_USES_TIME),
  1858. /* supports */ static_cast<NativePluginSupports>(NATIVE_PLUGIN_SUPPORTS_EVERYTHING),
  1859. /* audioIns */ 2,
  1860. /* audioOuts */ 2,
  1861. /* midiIns */ 1,
  1862. /* midiOuts */ 1,
  1863. /* paramIns */ 0,
  1864. /* paramOuts */ 0,
  1865. /* name */ "Carla-Patchbay",
  1866. /* label */ "carlapatchbay",
  1867. /* maker */ "falkTX",
  1868. /* copyright */ "GNU GPL v2+",
  1869. CarlaEngineNative::_instantiatePatchbay,
  1870. CarlaEngineNative::_cleanup,
  1871. CarlaEngineNative::_get_parameter_count,
  1872. CarlaEngineNative::_get_parameter_info,
  1873. CarlaEngineNative::_get_parameter_value,
  1874. CarlaEngineNative::_get_midi_program_count,
  1875. CarlaEngineNative::_get_midi_program_info,
  1876. CarlaEngineNative::_set_parameter_value,
  1877. CarlaEngineNative::_set_midi_program,
  1878. /* _set_custom_data */ nullptr,
  1879. CarlaEngineNative::_ui_show,
  1880. CarlaEngineNative::_ui_idle,
  1881. /* _ui_set_parameter_value */ nullptr,
  1882. /* _ui_set_midi_program */ nullptr,
  1883. /* _ui_set_custom_data */ nullptr,
  1884. CarlaEngineNative::_activate,
  1885. CarlaEngineNative::_deactivate,
  1886. CarlaEngineNative::_process,
  1887. CarlaEngineNative::_get_state,
  1888. CarlaEngineNative::_set_state,
  1889. CarlaEngineNative::_dispatcher
  1890. };
  1891. static const NativePluginDescriptor carlaPatchbay3sDesc = {
  1892. /* category */ NATIVE_PLUGIN_CATEGORY_OTHER,
  1893. /* hints */ static_cast<NativePluginHints>(NATIVE_PLUGIN_IS_SYNTH
  1894. |NATIVE_PLUGIN_HAS_UI
  1895. |NATIVE_PLUGIN_NEEDS_UI_MAIN_THREAD
  1896. |NATIVE_PLUGIN_USES_STATE
  1897. |NATIVE_PLUGIN_USES_TIME),
  1898. /* supports */ static_cast<NativePluginSupports>(NATIVE_PLUGIN_SUPPORTS_EVERYTHING),
  1899. /* audioIns */ 3,
  1900. /* audioOuts */ 2,
  1901. /* midiIns */ 1,
  1902. /* midiOuts */ 1,
  1903. /* paramIns */ 0,
  1904. /* paramOuts */ 0,
  1905. /* name */ "Carla-Patchbay (sidechain)",
  1906. /* label */ "carlapatchbay3s",
  1907. /* maker */ "falkTX",
  1908. /* copyright */ "GNU GPL v2+",
  1909. CarlaEngineNative::_instantiatePatchbay3s,
  1910. CarlaEngineNative::_cleanup,
  1911. CarlaEngineNative::_get_parameter_count,
  1912. CarlaEngineNative::_get_parameter_info,
  1913. CarlaEngineNative::_get_parameter_value,
  1914. CarlaEngineNative::_get_midi_program_count,
  1915. CarlaEngineNative::_get_midi_program_info,
  1916. CarlaEngineNative::_set_parameter_value,
  1917. CarlaEngineNative::_set_midi_program,
  1918. /* _set_custom_data */ nullptr,
  1919. CarlaEngineNative::_ui_show,
  1920. CarlaEngineNative::_ui_idle,
  1921. /* _ui_set_parameter_value */ nullptr,
  1922. /* _ui_set_midi_program */ nullptr,
  1923. /* _ui_set_custom_data */ nullptr,
  1924. CarlaEngineNative::_activate,
  1925. CarlaEngineNative::_deactivate,
  1926. CarlaEngineNative::_process,
  1927. CarlaEngineNative::_get_state,
  1928. CarlaEngineNative::_set_state,
  1929. CarlaEngineNative::_dispatcher
  1930. };
  1931. static const NativePluginDescriptor carlaPatchbay16Desc = {
  1932. /* category */ NATIVE_PLUGIN_CATEGORY_OTHER,
  1933. /* hints */ static_cast<NativePluginHints>(NATIVE_PLUGIN_IS_SYNTH
  1934. |NATIVE_PLUGIN_HAS_UI
  1935. |NATIVE_PLUGIN_NEEDS_UI_MAIN_THREAD
  1936. |NATIVE_PLUGIN_USES_STATE
  1937. |NATIVE_PLUGIN_USES_TIME),
  1938. /* supports */ static_cast<NativePluginSupports>(NATIVE_PLUGIN_SUPPORTS_EVERYTHING),
  1939. /* audioIns */ 16,
  1940. /* audioOuts */ 16,
  1941. /* midiIns */ 1,
  1942. /* midiOuts */ 1,
  1943. /* paramIns */ 0,
  1944. /* paramOuts */ 0,
  1945. /* name */ "Carla-Patchbay (16chan)",
  1946. /* label */ "carlapatchbay16",
  1947. /* maker */ "falkTX",
  1948. /* copyright */ "GNU GPL v2+",
  1949. CarlaEngineNative::_instantiatePatchbay16,
  1950. CarlaEngineNative::_cleanup,
  1951. CarlaEngineNative::_get_parameter_count,
  1952. CarlaEngineNative::_get_parameter_info,
  1953. CarlaEngineNative::_get_parameter_value,
  1954. CarlaEngineNative::_get_midi_program_count,
  1955. CarlaEngineNative::_get_midi_program_info,
  1956. CarlaEngineNative::_set_parameter_value,
  1957. CarlaEngineNative::_set_midi_program,
  1958. /* _set_custom_data */ nullptr,
  1959. CarlaEngineNative::_ui_show,
  1960. CarlaEngineNative::_ui_idle,
  1961. /* _ui_set_parameter_value */ nullptr,
  1962. /* _ui_set_midi_program */ nullptr,
  1963. /* _ui_set_custom_data */ nullptr,
  1964. CarlaEngineNative::_activate,
  1965. CarlaEngineNative::_deactivate,
  1966. CarlaEngineNative::_process,
  1967. CarlaEngineNative::_get_state,
  1968. CarlaEngineNative::_set_state,
  1969. CarlaEngineNative::_dispatcher
  1970. };
  1971. static const NativePluginDescriptor carlaPatchbay32Desc = {
  1972. /* category */ NATIVE_PLUGIN_CATEGORY_OTHER,
  1973. /* hints */ static_cast<NativePluginHints>(NATIVE_PLUGIN_IS_SYNTH
  1974. |NATIVE_PLUGIN_HAS_UI
  1975. |NATIVE_PLUGIN_NEEDS_UI_MAIN_THREAD
  1976. |NATIVE_PLUGIN_USES_STATE
  1977. |NATIVE_PLUGIN_USES_TIME),
  1978. /* supports */ static_cast<NativePluginSupports>(NATIVE_PLUGIN_SUPPORTS_EVERYTHING),
  1979. /* audioIns */ 32,
  1980. /* audioOuts */ 32,
  1981. /* midiIns */ 1,
  1982. /* midiOuts */ 1,
  1983. /* paramIns */ 0,
  1984. /* paramOuts */ 0,
  1985. /* name */ "Carla-Patchbay (32chan)",
  1986. /* label */ "carlapatchbay32",
  1987. /* maker */ "falkTX",
  1988. /* copyright */ "GNU GPL v2+",
  1989. CarlaEngineNative::_instantiatePatchbay32,
  1990. CarlaEngineNative::_cleanup,
  1991. CarlaEngineNative::_get_parameter_count,
  1992. CarlaEngineNative::_get_parameter_info,
  1993. CarlaEngineNative::_get_parameter_value,
  1994. CarlaEngineNative::_get_midi_program_count,
  1995. CarlaEngineNative::_get_midi_program_info,
  1996. CarlaEngineNative::_set_parameter_value,
  1997. CarlaEngineNative::_set_midi_program,
  1998. /* _set_custom_data */ nullptr,
  1999. CarlaEngineNative::_ui_show,
  2000. CarlaEngineNative::_ui_idle,
  2001. /* _ui_set_parameter_value */ nullptr,
  2002. /* _ui_set_midi_program */ nullptr,
  2003. /* _ui_set_custom_data */ nullptr,
  2004. CarlaEngineNative::_activate,
  2005. CarlaEngineNative::_deactivate,
  2006. CarlaEngineNative::_process,
  2007. CarlaEngineNative::_get_state,
  2008. CarlaEngineNative::_set_state,
  2009. CarlaEngineNative::_dispatcher
  2010. };
  2011. CARLA_BACKEND_END_NAMESPACE
  2012. // -----------------------------------------------------------------------
  2013. CARLA_EXPORT
  2014. void carla_register_native_plugin_carla();
  2015. void carla_register_native_plugin_carla()
  2016. {
  2017. CARLA_BACKEND_USE_NAMESPACE;
  2018. carla_register_native_plugin(&carlaRackDesc);
  2019. carla_register_native_plugin(&carlaRackNoMidiOutDesc);
  2020. carla_register_native_plugin(&carlaPatchbayDesc);
  2021. carla_register_native_plugin(&carlaPatchbay3sDesc);
  2022. carla_register_native_plugin(&carlaPatchbay16Desc);
  2023. carla_register_native_plugin(&carlaPatchbay32Desc);
  2024. }
  2025. // -----------------------------------------------------------------------
  2026. const NativePluginDescriptor* carla_get_native_rack_plugin()
  2027. {
  2028. CARLA_BACKEND_USE_NAMESPACE;
  2029. return &carlaRackDesc;
  2030. }
  2031. const NativePluginDescriptor* carla_get_native_patchbay_plugin()
  2032. {
  2033. CARLA_BACKEND_USE_NAMESPACE;
  2034. return &carlaPatchbayDesc;
  2035. }
  2036. const NativePluginDescriptor* carla_get_native_patchbay16_plugin()
  2037. {
  2038. CARLA_BACKEND_USE_NAMESPACE;
  2039. return &carlaPatchbay16Desc;
  2040. }
  2041. const NativePluginDescriptor* carla_get_native_patchbay32_plugin()
  2042. {
  2043. CARLA_BACKEND_USE_NAMESPACE;
  2044. return &carlaPatchbay32Desc;
  2045. }
  2046. // -----------------------------------------------------------------------
  2047. // Extra stuff for linking purposes
  2048. #ifdef CARLA_PLUGIN_EXPORT
  2049. CARLA_BACKEND_START_NAMESPACE
  2050. CarlaEngine* CarlaEngine::newJack() { return nullptr; }
  2051. # ifdef USING_JUCE
  2052. CarlaEngine* CarlaEngine::newJuce(const AudioApi) { return nullptr; }
  2053. uint CarlaEngine::getJuceApiCount() { return 0; }
  2054. const char* CarlaEngine::getJuceApiName(const uint) { return nullptr; }
  2055. const char* const* CarlaEngine::getJuceApiDeviceNames(const uint) { return nullptr; }
  2056. const EngineDriverDeviceInfo* CarlaEngine::getJuceDeviceInfo(const uint, const char* const) { return nullptr; }
  2057. # else
  2058. CarlaEngine* CarlaEngine::newRtAudio(const AudioApi) { return nullptr; }
  2059. uint CarlaEngine::getRtAudioApiCount() { return 0; }
  2060. const char* CarlaEngine::getRtAudioApiName(const uint) { return nullptr; }
  2061. const char* const* CarlaEngine::getRtAudioApiDeviceNames(const uint) { return nullptr; }
  2062. const EngineDriverDeviceInfo* CarlaEngine::getRtAudioDeviceInfo(const uint, const char* const) { return nullptr; }
  2063. # endif
  2064. CARLA_BACKEND_END_NAMESPACE
  2065. #define CARLA_PLUGIN_UI_CLASS_PREFIX EngineNative
  2066. #include "CarlaHostCommon.cpp"
  2067. #include "CarlaPluginUI.cpp"
  2068. #include "CarlaDssiUtils.cpp"
  2069. #include "CarlaMacUtils.cpp"
  2070. #include "CarlaPatchbayUtils.cpp"
  2071. #include "CarlaPipeUtils.cpp"
  2072. #include "CarlaStateUtils.cpp"
  2073. #endif
  2074. // -----------------------------------------------------------------------