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.

1899 lines
63KB

  1. /*
  2. * Carla Plugin Host
  3. * Copyright (C) 2011-2017 Filipe Coelho <falktx@falktx.com>
  4. *
  5. * This program is free software; you can redistribute it and/or
  6. * modify it under the terms of the GNU General Public License as
  7. * published by the Free Software Foundation; either version 2 of
  8. * the License, or any later version.
  9. *
  10. * This program is distributed in the hope that it will be useful,
  11. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13. * GNU General Public License for more details.
  14. *
  15. * For a full copy of the GNU General Public License see the doc/GPL.txt file.
  16. */
  17. #include "CarlaDefines.h"
  18. #ifdef BUILD_BRIDGE
  19. # error This file should not be compiled if building bridge
  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 "juce_audio_basics/juce_audio_basics.h"
  32. using juce::File;
  33. using juce::FloatVectorOperations;
  34. using juce::MemoryOutputStream;
  35. using juce::ScopedPointer;
  36. using juce::SharedResourcePointer;
  37. using juce::String;
  38. using juce::XmlDocument;
  39. using juce::XmlElement;
  40. CARLA_BACKEND_START_NAMESPACE
  41. // -----------------------------------------------------------------------
  42. class CarlaEngineNativeUI : public CarlaExternalUI
  43. {
  44. public:
  45. CarlaEngineNativeUI(CarlaEngine* const engine)
  46. : fEngine(engine),
  47. fRemoteWinId(0)
  48. {
  49. carla_debug("CarlaEngineNativeUI::CarlaEngineNativeUI(%p)", engine);
  50. }
  51. ~CarlaEngineNativeUI() noexcept override
  52. {
  53. carla_debug("CarlaEngineNativeUI::~CarlaEngineNativeUI()");
  54. }
  55. bool isReady() const noexcept
  56. {
  57. return fRemoteWinId != 0;
  58. }
  59. intptr_t getRemoteWinId() const noexcept
  60. {
  61. return fRemoteWinId;
  62. }
  63. protected:
  64. bool msgReceived(const char* const msg) noexcept override
  65. {
  66. if (CarlaExternalUI::msgReceived(msg))
  67. return true;
  68. bool ok = true;
  69. if (std::strcmp(msg, "set_engine_option") == 0)
  70. {
  71. uint32_t option;
  72. int32_t value;
  73. const char* valueStr = nullptr;
  74. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(option), true);
  75. CARLA_SAFE_ASSERT_RETURN(readNextLineAsInt(value), true);
  76. readNextLineAsString(valueStr); // can be null
  77. try {
  78. fEngine->setOption(static_cast<EngineOption>(option), value, valueStr);
  79. } CARLA_SAFE_EXCEPTION("setOption");
  80. if (valueStr != nullptr)
  81. delete[] valueStr;
  82. }
  83. else if (std::strcmp(msg, "load_file") == 0)
  84. {
  85. const char* filename;
  86. CARLA_SAFE_ASSERT_RETURN(readNextLineAsString(filename), true);
  87. try {
  88. ok = fEngine->loadFile(filename);
  89. } CARLA_SAFE_EXCEPTION("loadFile");
  90. delete[] filename;
  91. }
  92. else if (std::strcmp(msg, "load_project") == 0)
  93. {
  94. const char* filename;
  95. CARLA_SAFE_ASSERT_RETURN(readNextLineAsString(filename), true);
  96. try {
  97. ok = fEngine->loadProject(filename);
  98. } CARLA_SAFE_EXCEPTION("loadProject");
  99. delete[] filename;
  100. }
  101. else if (std::strcmp(msg, "save_project") == 0)
  102. {
  103. const char* filename;
  104. CARLA_SAFE_ASSERT_RETURN(readNextLineAsString(filename), true);
  105. try {
  106. ok = fEngine->saveProject(filename);
  107. } CARLA_SAFE_EXCEPTION("saveProject");
  108. delete[] filename;
  109. }
  110. else if (std::strcmp(msg, "patchbay_connect") == 0)
  111. {
  112. uint32_t groupA, portA, groupB, portB;
  113. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(groupA), true);
  114. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(portA), true);
  115. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(groupB), true);
  116. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(portB), true);
  117. try {
  118. ok = fEngine->patchbayConnect(groupA, portA, groupB, portB);
  119. } CARLA_SAFE_EXCEPTION("patchbayConnect");
  120. }
  121. else if (std::strcmp(msg, "patchbay_disconnect") == 0)
  122. {
  123. uint32_t connectionId;
  124. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(connectionId), true);
  125. try {
  126. ok = fEngine->patchbayDisconnect(connectionId);
  127. } CARLA_SAFE_EXCEPTION("patchbayDisconnect");
  128. }
  129. else if (std::strcmp(msg, "patchbay_refresh") == 0)
  130. {
  131. try {
  132. ok = fEngine->patchbayRefresh();
  133. } CARLA_SAFE_EXCEPTION("patchbayRefresh");
  134. }
  135. else if (std::strcmp(msg, "transport_play") == 0)
  136. {
  137. fEngine->transportPlay();
  138. }
  139. else if (std::strcmp(msg, "transport_pause") == 0)
  140. {
  141. fEngine->transportPause();
  142. }
  143. else if (std::strcmp(msg, "transport_bpm") == 0)
  144. {
  145. double bpm;
  146. CARLA_SAFE_ASSERT_RETURN(readNextLineAsDouble(bpm), true);
  147. fEngine->transportBPM(bpm);
  148. }
  149. else if (std::strcmp(msg, "transport_relocate") == 0)
  150. {
  151. uint64_t frame;
  152. CARLA_SAFE_ASSERT_RETURN(readNextLineAsULong(frame), true);
  153. fEngine->transportRelocate(frame);
  154. }
  155. else if (std::strcmp(msg, "add_plugin") == 0)
  156. {
  157. uint32_t btype, ptype;
  158. const char* filename = nullptr;
  159. const char* name;
  160. const char* label;
  161. int64_t uniqueId;
  162. uint options;
  163. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(btype), true);
  164. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(ptype), true);
  165. readNextLineAsString(filename); // can be null
  166. CARLA_SAFE_ASSERT_RETURN(readNextLineAsString(name), true);
  167. CARLA_SAFE_ASSERT_RETURN(readNextLineAsString(label), true);
  168. CARLA_SAFE_ASSERT_RETURN(readNextLineAsLong(uniqueId), true);
  169. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(options), true);
  170. if (filename != nullptr && std::strcmp(filename, "(null)") == 0)
  171. {
  172. delete[] filename;
  173. filename = nullptr;
  174. }
  175. if (std::strcmp(name, "(null)") == 0)
  176. {
  177. delete[] name;
  178. name = nullptr;
  179. }
  180. ok = fEngine->addPlugin(static_cast<BinaryType>(btype), static_cast<PluginType>(ptype),
  181. filename, name, label, uniqueId, nullptr, options);
  182. if (filename != nullptr)
  183. delete[] filename;
  184. if (name != nullptr)
  185. delete[] name;
  186. delete[] label;
  187. }
  188. else if (std::strcmp(msg, "remove_plugin") == 0)
  189. {
  190. uint32_t pluginId;
  191. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(pluginId), true);
  192. ok = fEngine->removePlugin(pluginId);
  193. }
  194. else if (std::strcmp(msg, "remove_all_plugins") == 0)
  195. {
  196. ok = fEngine->removeAllPlugins();
  197. }
  198. else if (std::strcmp(msg, "rename_plugin") == 0)
  199. {
  200. uint32_t pluginId;
  201. const char* newName;
  202. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(pluginId), true);
  203. CARLA_SAFE_ASSERT_RETURN(readNextLineAsString(newName), true);
  204. // TODO
  205. /*const char* name =*/ fEngine->renamePlugin(pluginId, newName);
  206. delete[] newName;
  207. }
  208. else if (std::strcmp(msg, "clone_plugin") == 0)
  209. {
  210. uint32_t pluginId;
  211. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(pluginId), true);
  212. ok = fEngine->clonePlugin(pluginId);
  213. }
  214. else if (std::strcmp(msg, "replace_plugin") == 0)
  215. {
  216. uint32_t pluginId;
  217. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(pluginId), true);
  218. ok = fEngine->replacePlugin(pluginId);
  219. }
  220. else if (std::strcmp(msg, "switch_plugins") == 0)
  221. {
  222. uint32_t pluginIdA, pluginIdB;
  223. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(pluginIdA), true);
  224. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(pluginIdB), true);
  225. ok = fEngine->switchPlugins(pluginIdA, pluginIdB);
  226. }
  227. else if (std::strcmp(msg, "load_plugin_state") == 0)
  228. {
  229. uint32_t pluginId;
  230. const char* filename;
  231. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(pluginId), true);
  232. CARLA_SAFE_ASSERT_RETURN(readNextLineAsString(filename), true);
  233. if (CarlaPlugin* const plugin = fEngine->getPlugin(pluginId))
  234. plugin->loadStateFromFile(filename);
  235. delete[] filename;
  236. }
  237. else if (std::strcmp(msg, "save_plugin_state") == 0)
  238. {
  239. uint32_t pluginId;
  240. const char* filename;
  241. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(pluginId), true);
  242. CARLA_SAFE_ASSERT_RETURN(readNextLineAsString(filename), true);
  243. if (CarlaPlugin* const plugin = fEngine->getPlugin(pluginId))
  244. plugin->saveStateToFile(filename);
  245. delete[] filename;
  246. }
  247. else if (std::strcmp(msg, "set_option") == 0)
  248. {
  249. uint32_t pluginId, option;
  250. bool yesNo;
  251. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(pluginId), true);
  252. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(option), true);
  253. CARLA_SAFE_ASSERT_RETURN(readNextLineAsBool(yesNo), true);
  254. if (CarlaPlugin* const plugin = fEngine->getPlugin(pluginId))
  255. plugin->setOption(option, yesNo, false);
  256. }
  257. else if (std::strcmp(msg, "set_active") == 0)
  258. {
  259. uint32_t pluginId;
  260. bool onOff;
  261. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(pluginId), true);
  262. CARLA_SAFE_ASSERT_RETURN(readNextLineAsBool(onOff), true);
  263. if (CarlaPlugin* const plugin = fEngine->getPlugin(pluginId))
  264. plugin->setActive(onOff, true, false);
  265. }
  266. else if (std::strcmp(msg, "set_drywet") == 0)
  267. {
  268. uint32_t pluginId;
  269. float value;
  270. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(pluginId), true);
  271. CARLA_SAFE_ASSERT_RETURN(readNextLineAsFloat(value), true);
  272. if (CarlaPlugin* const plugin = fEngine->getPlugin(pluginId))
  273. plugin->setDryWet(value, true, false);
  274. }
  275. else if (std::strcmp(msg, "set_volume") == 0)
  276. {
  277. uint32_t pluginId;
  278. float value;
  279. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(pluginId), true);
  280. CARLA_SAFE_ASSERT_RETURN(readNextLineAsFloat(value), true);
  281. if (CarlaPlugin* const plugin = fEngine->getPlugin(pluginId))
  282. plugin->setVolume(value, true, false);
  283. }
  284. else if (std::strcmp(msg, "set_balance_left") == 0)
  285. {
  286. uint32_t pluginId;
  287. float value;
  288. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(pluginId), true);
  289. CARLA_SAFE_ASSERT_RETURN(readNextLineAsFloat(value), true);
  290. if (CarlaPlugin* const plugin = fEngine->getPlugin(pluginId))
  291. plugin->setBalanceLeft(value, true, false);
  292. }
  293. else if (std::strcmp(msg, "set_balance_right") == 0)
  294. {
  295. uint32_t pluginId;
  296. float value;
  297. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(pluginId), true);
  298. CARLA_SAFE_ASSERT_RETURN(readNextLineAsFloat(value), true);
  299. if (CarlaPlugin* const plugin = fEngine->getPlugin(pluginId))
  300. plugin->setBalanceRight(value, true, false);
  301. }
  302. else if (std::strcmp(msg, "set_panning") == 0)
  303. {
  304. uint32_t pluginId;
  305. float value;
  306. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(pluginId), true);
  307. CARLA_SAFE_ASSERT_RETURN(readNextLineAsFloat(value), true);
  308. if (CarlaPlugin* const plugin = fEngine->getPlugin(pluginId))
  309. plugin->setPanning(value, true, false);
  310. }
  311. else if (std::strcmp(msg, "set_ctrl_channel") == 0)
  312. {
  313. uint32_t pluginId;
  314. int32_t channel;
  315. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(pluginId), true);
  316. CARLA_SAFE_ASSERT_RETURN(readNextLineAsInt(channel), true);
  317. CARLA_SAFE_ASSERT_RETURN(channel >= -1 && channel < MAX_MIDI_CHANNELS, true);
  318. if (CarlaPlugin* const plugin = fEngine->getPlugin(pluginId))
  319. plugin->setCtrlChannel(int8_t(channel), true, false);
  320. }
  321. else if (std::strcmp(msg, "set_parameter_value") == 0)
  322. {
  323. uint32_t pluginId, parameterId;
  324. float value;
  325. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(pluginId), true);
  326. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(parameterId), true);
  327. CARLA_SAFE_ASSERT_RETURN(readNextLineAsFloat(value), true);
  328. if (CarlaPlugin* const plugin = fEngine->getPlugin(pluginId))
  329. plugin->setParameterValue(parameterId, value, true, true, false);
  330. }
  331. else if (std::strcmp(msg, "set_parameter_midi_channel") == 0)
  332. {
  333. uint32_t pluginId, parameterId, channel;
  334. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(pluginId), true);
  335. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(parameterId), true);
  336. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(channel), true);
  337. CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS, true);
  338. if (CarlaPlugin* const plugin = fEngine->getPlugin(pluginId))
  339. plugin->setParameterMidiChannel(parameterId, static_cast<uint8_t>(channel), true, false);
  340. }
  341. else if (std::strcmp(msg, "set_parameter_midi_cc") == 0)
  342. {
  343. uint32_t pluginId, parameterId;
  344. int32_t cc;
  345. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(pluginId), true);
  346. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(parameterId), true);
  347. CARLA_SAFE_ASSERT_RETURN(readNextLineAsInt(cc), true);
  348. CARLA_SAFE_ASSERT_RETURN(cc >= -1 && cc < MAX_MIDI_CONTROL, true);
  349. if (CarlaPlugin* const plugin = fEngine->getPlugin(pluginId))
  350. plugin->setParameterMidiCC(parameterId, static_cast<int16_t>(cc), true, false);
  351. }
  352. else if (std::strcmp(msg, "set_program") == 0)
  353. {
  354. uint32_t pluginId;
  355. int32_t index;
  356. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(pluginId), true);
  357. CARLA_SAFE_ASSERT_RETURN(readNextLineAsInt(index), true);
  358. if (CarlaPlugin* const plugin = fEngine->getPlugin(pluginId))
  359. {
  360. plugin->setProgram(index, true, true, false);
  361. _updateParamValues(plugin, pluginId);
  362. }
  363. }
  364. else if (std::strcmp(msg, "set_midi_program") == 0)
  365. {
  366. uint32_t pluginId;
  367. int32_t index;
  368. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(pluginId), true);
  369. CARLA_SAFE_ASSERT_RETURN(readNextLineAsInt(index), true);
  370. if (CarlaPlugin* const plugin = fEngine->getPlugin(pluginId))
  371. {
  372. plugin->setMidiProgram(index, true, true, false);
  373. _updateParamValues(plugin, pluginId);
  374. }
  375. }
  376. else if (std::strcmp(msg, "set_custom_data") == 0)
  377. {
  378. uint32_t pluginId;
  379. const char* type;
  380. const char* key;
  381. const char* value;
  382. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(pluginId), true);
  383. CARLA_SAFE_ASSERT_RETURN(readNextLineAsString(type), true);
  384. CARLA_SAFE_ASSERT_RETURN(readNextLineAsString(key), true);
  385. CARLA_SAFE_ASSERT_RETURN(readNextLineAsString(value), true);
  386. if (CarlaPlugin* const plugin = fEngine->getPlugin(pluginId))
  387. plugin->setCustomData(type, key, value, true);
  388. delete[] type;
  389. delete[] key;
  390. delete[] value;
  391. }
  392. else if (std::strcmp(msg, "set_chunk_data") == 0)
  393. {
  394. uint32_t pluginId;
  395. const char* cdata;
  396. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(pluginId), true);
  397. CARLA_SAFE_ASSERT_RETURN(readNextLineAsString(cdata), true);
  398. if (CarlaPlugin* const plugin = fEngine->getPlugin(pluginId))
  399. {
  400. std::vector<uint8_t> chunk(carla_getChunkFromBase64String(cdata));
  401. plugin->setChunkData(chunk.data(), chunk.size());
  402. }
  403. delete[] cdata;
  404. }
  405. else if (std::strcmp(msg, "prepare_for_save") == 0)
  406. {
  407. uint32_t pluginId;
  408. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(pluginId), true);
  409. if (CarlaPlugin* const plugin = fEngine->getPlugin(pluginId))
  410. plugin->prepareForSave();
  411. }
  412. else if (std::strcmp(msg, "reset_parameters") == 0)
  413. {
  414. uint32_t pluginId;
  415. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(pluginId), true);
  416. if (CarlaPlugin* const plugin = fEngine->getPlugin(pluginId))
  417. plugin->resetParameters();
  418. }
  419. else if (std::strcmp(msg, "randomize_parameters") == 0)
  420. {
  421. uint32_t pluginId;
  422. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(pluginId), true);
  423. if (CarlaPlugin* const plugin = fEngine->getPlugin(pluginId))
  424. plugin->randomizeParameters();
  425. }
  426. else if (std::strcmp(msg, "send_midi_note") == 0)
  427. {
  428. uint32_t pluginId, channel, note, velocity;
  429. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(pluginId), true);
  430. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(channel), true);
  431. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(note), true);
  432. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(velocity), true);
  433. CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS, true);
  434. CARLA_SAFE_ASSERT_RETURN(note < MAX_MIDI_VALUE, true);
  435. CARLA_SAFE_ASSERT_RETURN(velocity < MAX_MIDI_VALUE, true);
  436. if (CarlaPlugin* const plugin = fEngine->getPlugin(pluginId))
  437. plugin->sendMidiSingleNote(static_cast<uint8_t>(channel), static_cast<uint8_t>(note), static_cast<uint8_t>(velocity), true, true, false);
  438. }
  439. else if (std::strcmp(msg, "show_custom_ui") == 0)
  440. {
  441. uint32_t pluginId;
  442. bool yesNo;
  443. CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(pluginId), true);
  444. CARLA_SAFE_ASSERT_RETURN(readNextLineAsBool(yesNo), true);
  445. if (CarlaPlugin* const plugin = fEngine->getPlugin(pluginId))
  446. plugin->showCustomUI(yesNo);
  447. }
  448. else if (std::strcmp(msg, "ready") == 0)
  449. {
  450. uint64_t winId;
  451. CARLA_SAFE_ASSERT_RETURN(readNextLineAsULong(winId), true);
  452. fRemoteWinId = static_cast<intptr_t>(winId);
  453. }
  454. else
  455. {
  456. carla_stderr("CarlaEngineNativeUI::msgReceived : %s", msg);
  457. return false;
  458. }
  459. if (! ok)
  460. {
  461. const CarlaMutexLocker cml(getPipeLock());
  462. writeMessage("error\n", 6);
  463. writeAndFixMessage(fEngine->getLastError());
  464. flushMessages();
  465. }
  466. return true;
  467. }
  468. private:
  469. CarlaEngine* const fEngine;
  470. intptr_t fRemoteWinId;
  471. void _updateParamValues(CarlaPlugin* const plugin, const uint32_t pluginId) const noexcept
  472. {
  473. for (uint32_t i=0, count=plugin->getParameterCount(); i<count; ++i)
  474. fEngine->callback(ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED,
  475. pluginId, static_cast<int>(i), 0, plugin->getParameterValue(i), nullptr);
  476. }
  477. CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaEngineNativeUI)
  478. };
  479. // -----------------------------------------------------------------------
  480. class CarlaEngineNative : public CarlaEngine
  481. {
  482. public:
  483. CarlaEngineNative(const NativeHostDescriptor* const host, const uint32_t inChan = 2, uint32_t outChan = 0)
  484. : CarlaEngine(),
  485. pHost(host),
  486. fIsActive(false),
  487. fIsRunning(false),
  488. fUiServer(this),
  489. fOptionsForced(false),
  490. fWaitForReadyMsg(false)
  491. {
  492. carla_debug("CarlaEngineNative::CarlaEngineNative()");
  493. carla_zeroChars(fTmpBuf, STR_MAX+1);
  494. pData->bufferSize = pHost->get_buffer_size(pHost->handle);
  495. pData->sampleRate = pHost->get_sample_rate(pHost->handle);
  496. pData->initTime(nullptr);
  497. if (outChan == 0)
  498. outChan = inChan;
  499. CARLA_SAFE_ASSERT(inChan == 2);
  500. CARLA_SAFE_ASSERT(outChan == 2);
  501. pData->options.processMode = ENGINE_PROCESS_MODE_CONTINUOUS_RACK;
  502. pData->options.transportMode = ENGINE_TRANSPORT_MODE_PLUGIN;
  503. pData->options.forceStereo = true;
  504. pData->options.preferPluginBridges = false;
  505. pData->options.preferUiBridges = false;
  506. init("Carla-Rack");
  507. pData->graph.create(0, 0); // FIXME?
  508. if (pData->options.resourceDir != nullptr)
  509. delete[] pData->options.resourceDir;
  510. if (pData->options.binaryDir != nullptr)
  511. delete[] pData->options.binaryDir;
  512. pData->options.resourceDir = carla_strdup(pHost->resourceDir);
  513. pData->options.binaryDir = carla_strdup(carla_get_library_folder());
  514. setCallback(_ui_server_callback, this);
  515. }
  516. ~CarlaEngineNative() override
  517. {
  518. CARLA_SAFE_ASSERT(! fIsActive);
  519. carla_debug("CarlaEngineNative::~CarlaEngineNative() - START");
  520. pData->aboutToClose = true;
  521. fIsRunning = false;
  522. removeAllPlugins();
  523. //runPendingRtEvents();
  524. close();
  525. pData->graph.destroy();
  526. carla_debug("CarlaEngineNative::~CarlaEngineNative() - END");
  527. }
  528. protected:
  529. // -------------------------------------
  530. // CarlaEngine virtual calls
  531. bool init(const char* const clientName) override
  532. {
  533. carla_debug("CarlaEngineNative::init(\"%s\")", clientName);
  534. fIsRunning = true;
  535. if (! pData->init(clientName))
  536. {
  537. close();
  538. setLastError("Failed to init internal data");
  539. return false;
  540. }
  541. pData->bufferSize = pHost->get_buffer_size(pHost->handle);
  542. pData->sampleRate = pHost->get_sample_rate(pHost->handle);
  543. return true;
  544. }
  545. bool close() override
  546. {
  547. fIsRunning = false;
  548. CarlaEngine::close();
  549. return true;
  550. }
  551. bool isRunning() const noexcept override
  552. {
  553. return fIsRunning;
  554. }
  555. bool isOffline() const noexcept override
  556. {
  557. return pHost->is_offline(pHost->handle);
  558. }
  559. bool usesConstantBufferSize() const noexcept override
  560. {
  561. // TODO
  562. return true;
  563. }
  564. EngineType getType() const noexcept override
  565. {
  566. return kEngineTypePlugin;
  567. }
  568. const char* getCurrentDriverName() const noexcept override
  569. {
  570. return "Plugin";
  571. }
  572. void callback(const EngineCallbackOpcode action, const uint pluginId, const int value1, const int value2, const float value3, const char* const valueStr) noexcept override
  573. {
  574. CarlaEngine::callback(action, pluginId, value1, value2, value3, valueStr);
  575. if (action == ENGINE_CALLBACK_IDLE && ! pData->aboutToClose)
  576. pHost->dispatcher(pHost->handle, NATIVE_HOST_OPCODE_HOST_IDLE, 0, 0, nullptr, 0.0f);
  577. }
  578. // -------------------------------------------------------------------
  579. const char* renamePlugin(const uint id, const char* const newName) override
  580. {
  581. if (const char* const retName = CarlaEngine::renamePlugin(id, newName))
  582. {
  583. uiServerCallback(ENGINE_CALLBACK_PLUGIN_RENAMED, id, 0, 0, 0.0f, retName);
  584. return retName;
  585. }
  586. return nullptr;
  587. }
  588. // -------------------------------------------------------------------
  589. void bufferSizeChanged(const uint32_t newBufferSize)
  590. {
  591. if (pData->bufferSize == newBufferSize)
  592. return;
  593. {
  594. const CarlaMutexLocker cml(fUiServer.getPipeLock());
  595. fUiServer.writeAndFixMessage("buffer-size");
  596. std::sprintf(fTmpBuf, "%i\n", newBufferSize);
  597. fUiServer.writeMessage(fTmpBuf);
  598. fUiServer.flushMessages();
  599. }
  600. pData->bufferSize = newBufferSize;
  601. CarlaEngine::bufferSizeChanged(newBufferSize);
  602. }
  603. void sampleRateChanged(const double newSampleRate)
  604. {
  605. if (carla_isEqual(pData->sampleRate, newSampleRate))
  606. return;
  607. {
  608. const CarlaMutexLocker cml(fUiServer.getPipeLock());
  609. const ScopedLocale csl;
  610. fUiServer.writeAndFixMessage("sample-rate");
  611. std::sprintf(fTmpBuf, "%f\n", newSampleRate);
  612. fUiServer.writeMessage(fTmpBuf);
  613. fUiServer.flushMessages();
  614. }
  615. pData->sampleRate = newSampleRate;
  616. CarlaEngine::sampleRateChanged(newSampleRate);
  617. }
  618. // -------------------------------------------------------------------
  619. void uiServerSendPluginInfo(CarlaPlugin* const plugin)
  620. {
  621. const CarlaMutexLocker cml(fUiServer.getPipeLock());
  622. const uint pluginId(plugin->getId());
  623. std::sprintf(fTmpBuf, "PLUGIN_INFO_%i\n", pluginId);
  624. fUiServer.writeMessage(fTmpBuf);
  625. std::sprintf(fTmpBuf, "%i:%i:%i:" P_INT64 ":%i:%i\n", plugin->getType(), plugin->getCategory(), plugin->getHints(), plugin->getUniqueId(), plugin->getOptionsAvailable(), plugin->getOptionsEnabled());
  626. fUiServer.writeMessage(fTmpBuf);
  627. if (const char* const filename = plugin->getFilename())
  628. {
  629. std::sprintf(fTmpBuf, "%s", filename);
  630. fUiServer.writeAndFixMessage(fTmpBuf);
  631. }
  632. else
  633. fUiServer.writeMessage("\n");
  634. if (const char* const name = plugin->getName())
  635. {
  636. std::sprintf(fTmpBuf, "%s", name);
  637. fUiServer.writeAndFixMessage(fTmpBuf);
  638. }
  639. else
  640. fUiServer.writeMessage("\n");
  641. if (const char* const iconName = plugin->getIconName())
  642. {
  643. std::sprintf(fTmpBuf, "%s", iconName);
  644. fUiServer.writeAndFixMessage(fTmpBuf);
  645. }
  646. else
  647. fUiServer.writeMessage("\n");
  648. plugin->getRealName(fTmpBuf);
  649. fUiServer.writeAndFixMessage(fTmpBuf);
  650. plugin->getLabel(fTmpBuf);
  651. fUiServer.writeAndFixMessage(fTmpBuf);
  652. plugin->getMaker(fTmpBuf);
  653. fUiServer.writeAndFixMessage(fTmpBuf);
  654. plugin->getCopyright(fTmpBuf);
  655. fUiServer.writeAndFixMessage(fTmpBuf);
  656. std::sprintf(fTmpBuf, "AUDIO_COUNT_%i:%i:%i\n", pluginId, plugin->getAudioInCount(), plugin->getAudioOutCount());
  657. fUiServer.writeMessage(fTmpBuf);
  658. std::sprintf(fTmpBuf, "MIDI_COUNT_%i:%i:%i\n", pluginId, plugin->getMidiInCount(), plugin->getMidiOutCount());
  659. fUiServer.writeMessage(fTmpBuf);
  660. fUiServer.flushMessages();
  661. }
  662. void uiServerSendPluginParameters(CarlaPlugin* const plugin)
  663. {
  664. const CarlaMutexLocker cml(fUiServer.getPipeLock());
  665. const ScopedLocale csl;
  666. const uint pluginId(plugin->getId());
  667. for (int32_t i=PARAMETER_ACTIVE; i>PARAMETER_MAX; --i)
  668. {
  669. std::sprintf(fTmpBuf, "PARAMVAL_%i:%i\n", pluginId, i);
  670. fUiServer.writeMessage(fTmpBuf);
  671. std::sprintf(fTmpBuf, "%f\n", plugin->getInternalParameterValue(i));
  672. fUiServer.writeMessage(fTmpBuf);
  673. fUiServer.flushMessages();
  674. }
  675. uint32_t ins, outs, count;
  676. plugin->getParameterCountInfo(ins, outs);
  677. count = plugin->getParameterCount();
  678. std::sprintf(fTmpBuf, "PARAMETER_COUNT_%i:%i:%i:%i\n", pluginId, ins, outs, count);
  679. fUiServer.writeMessage(fTmpBuf);
  680. for (uint32_t i=0; i<count; ++i)
  681. {
  682. const ParameterData& paramData(plugin->getParameterData(i));
  683. const ParameterRanges& paramRanges(plugin->getParameterRanges(i));
  684. std::sprintf(fTmpBuf, "PARAMETER_DATA_%i:%i\n", pluginId, i);
  685. fUiServer.writeMessage(fTmpBuf);
  686. std::sprintf(fTmpBuf, "%i:%i:%i:%i\n", paramData.type, paramData.hints, paramData.midiChannel, paramData.midiCC);
  687. fUiServer.writeMessage(fTmpBuf);
  688. plugin->getParameterName(i, fTmpBuf);
  689. fUiServer.writeAndFixMessage(fTmpBuf);
  690. plugin->getParameterUnit(i, fTmpBuf);
  691. fUiServer.writeAndFixMessage(fTmpBuf);
  692. std::sprintf(fTmpBuf, "PARAMETER_RANGES_%i:%i\n", pluginId, i);
  693. fUiServer.writeMessage(fTmpBuf);
  694. std::sprintf(fTmpBuf, "%f:%f:%f:%f:%f:%f\n", paramRanges.def, paramRanges.min, paramRanges.max, paramRanges.step, paramRanges.stepSmall, paramRanges.stepLarge);
  695. fUiServer.writeMessage(fTmpBuf);
  696. std::sprintf(fTmpBuf, "PARAMVAL_%i:%i\n", pluginId, i);
  697. fUiServer.writeMessage(fTmpBuf);
  698. std::sprintf(fTmpBuf, "%f\n", plugin->getParameterValue(i));
  699. fUiServer.writeMessage(fTmpBuf);
  700. }
  701. fUiServer.flushMessages();
  702. }
  703. void uiServerSendPluginPrograms(CarlaPlugin* const plugin)
  704. {
  705. const CarlaMutexLocker cml(fUiServer.getPipeLock());
  706. const uint pluginId(plugin->getId());
  707. uint32_t count = plugin->getProgramCount();
  708. std::sprintf(fTmpBuf, "PROGRAM_COUNT_%i:%i:%i\n", pluginId, count, plugin->getCurrentProgram());
  709. fUiServer.writeMessage(fTmpBuf);
  710. for (uint32_t i=0; i<count; ++i)
  711. {
  712. std::sprintf(fTmpBuf, "PROGRAM_NAME_%i:%i\n", pluginId, i);
  713. fUiServer.writeMessage(fTmpBuf);
  714. plugin->getProgramName(i, fTmpBuf);
  715. fUiServer.writeAndFixMessage(fTmpBuf);
  716. }
  717. fUiServer.flushMessages();
  718. count = plugin->getMidiProgramCount();
  719. std::sprintf(fTmpBuf, "MIDI_PROGRAM_COUNT_%i:%i:%i\n", pluginId, count, plugin->getCurrentMidiProgram());
  720. fUiServer.writeMessage(fTmpBuf);
  721. for (uint32_t i=0; i<count; ++i)
  722. {
  723. std::sprintf(fTmpBuf, "MIDI_PROGRAM_DATA_%i:%i\n", pluginId, i);
  724. fUiServer.writeMessage(fTmpBuf);
  725. const MidiProgramData& mpData(plugin->getMidiProgramData(i));
  726. std::sprintf(fTmpBuf, "%i:%i\n", mpData.bank, mpData.program);
  727. fUiServer.writeMessage(fTmpBuf);
  728. std::sprintf(fTmpBuf, "%s", mpData.name);
  729. fUiServer.writeAndFixMessage(fTmpBuf);
  730. }
  731. fUiServer.flushMessages();
  732. }
  733. void uiServerSendPluginProperties(CarlaPlugin* const plugin)
  734. {
  735. const CarlaMutexLocker cml(fUiServer.getPipeLock());
  736. const uint pluginId(plugin->getId());
  737. uint32_t count = plugin->getCustomDataCount();
  738. std::sprintf(fTmpBuf, "CUSTOM_DATA_COUNT_%i:%i\n", pluginId, count);
  739. fUiServer.writeMessage(fTmpBuf);
  740. for (uint32_t i=0; i<count; ++i)
  741. {
  742. const CustomData& customData(plugin->getCustomData(i));
  743. CARLA_SAFE_ASSERT_CONTINUE(customData.isValid());
  744. if (std::strcmp(customData.type, CUSTOM_DATA_TYPE_PROPERTY) != 0)
  745. continue;
  746. std::sprintf(fTmpBuf, "CUSTOM_DATA_%i:%i\n", pluginId, i);
  747. fUiServer.writeMessage(fTmpBuf);
  748. fUiServer.writeAndFixMessage(customData.type);
  749. fUiServer.writeAndFixMessage(customData.key);
  750. fUiServer.writeAndFixMessage(customData.value);
  751. }
  752. fUiServer.flushMessages();
  753. }
  754. void uiServerCallback(const EngineCallbackOpcode action, const uint pluginId, const int value1, const int value2, const float value3, const char* const valueStr)
  755. {
  756. if (! fIsRunning)
  757. return;
  758. if (! fUiServer.isPipeRunning())
  759. return;
  760. CarlaPlugin* plugin;
  761. switch (action)
  762. {
  763. case ENGINE_CALLBACK_UPDATE:
  764. plugin = getPlugin(pluginId);
  765. if (plugin != nullptr && plugin->isEnabled())
  766. {
  767. CARLA_SAFE_ASSERT_BREAK(plugin->getId() == pluginId);
  768. uiServerSendPluginProperties(plugin);
  769. }
  770. break;
  771. case ENGINE_CALLBACK_RELOAD_INFO:
  772. plugin = getPlugin(pluginId);
  773. if (plugin != nullptr && plugin->isEnabled())
  774. {
  775. CARLA_SAFE_ASSERT_BREAK(plugin->getId() == pluginId);
  776. uiServerSendPluginInfo(plugin);
  777. }
  778. break;
  779. case ENGINE_CALLBACK_RELOAD_PARAMETERS:
  780. plugin = getPlugin(pluginId);
  781. if (plugin != nullptr && plugin->isEnabled())
  782. {
  783. CARLA_SAFE_ASSERT_BREAK(plugin->getId() == pluginId);
  784. uiServerSendPluginParameters(plugin);
  785. }
  786. break;
  787. case ENGINE_CALLBACK_RELOAD_PROGRAMS:
  788. plugin = getPlugin(pluginId);
  789. if (plugin != nullptr && plugin->isEnabled())
  790. {
  791. CARLA_SAFE_ASSERT_BREAK(plugin->getId() == pluginId);
  792. uiServerSendPluginPrograms(plugin);
  793. }
  794. break;
  795. case ENGINE_CALLBACK_RELOAD_ALL:
  796. case ENGINE_CALLBACK_PLUGIN_ADDED:
  797. plugin = getPlugin(pluginId);
  798. if (plugin != nullptr && plugin->isEnabled())
  799. {
  800. CARLA_SAFE_ASSERT_BREAK(plugin->getId() == pluginId);
  801. uiServerSendPluginInfo(plugin);
  802. uiServerSendPluginParameters(plugin);
  803. uiServerSendPluginPrograms(plugin);
  804. uiServerSendPluginProperties(plugin);
  805. }
  806. break;
  807. default:
  808. break;
  809. }
  810. const CarlaMutexLocker cml(fUiServer.getPipeLock());
  811. const ScopedLocale csl;
  812. std::sprintf(fTmpBuf, "ENGINE_CALLBACK_%i\n", int(action));
  813. fUiServer.writeMessage(fTmpBuf);
  814. std::sprintf(fTmpBuf, "%u\n", pluginId);
  815. fUiServer.writeMessage(fTmpBuf);
  816. std::sprintf(fTmpBuf, "%i\n", value1);
  817. fUiServer.writeMessage(fTmpBuf);
  818. std::sprintf(fTmpBuf, "%i\n", value2);
  819. fUiServer.writeMessage(fTmpBuf);
  820. std::sprintf(fTmpBuf, "%f\n", value3);
  821. fUiServer.writeMessage(fTmpBuf);
  822. fUiServer.writeAndFixMessage(valueStr != nullptr ? valueStr : "");
  823. fUiServer.flushMessages();
  824. }
  825. void uiServerInfo()
  826. {
  827. CARLA_SAFE_ASSERT_RETURN(fIsRunning,);
  828. CARLA_SAFE_ASSERT_RETURN(fUiServer.isPipeRunning(),);
  829. const CarlaMutexLocker cml(fUiServer.getPipeLock());
  830. #ifdef HAVE_LIBLO
  831. fUiServer.writeAndFixMessage("osc-urls");
  832. fUiServer.writeAndFixMessage(pData->osc.getServerPathTCP());
  833. fUiServer.writeAndFixMessage(pData->osc.getServerPathUDP());
  834. #endif
  835. fUiServer.writeAndFixMessage("max-plugin-number");
  836. std::sprintf(fTmpBuf, "%i\n", pData->maxPluginNumber);
  837. fUiServer.writeMessage(fTmpBuf);
  838. fUiServer.writeAndFixMessage("buffer-size");
  839. std::sprintf(fTmpBuf, "%i\n", pData->bufferSize);
  840. fUiServer.writeMessage(fTmpBuf);
  841. const ScopedLocale csl;
  842. fUiServer.writeAndFixMessage("sample-rate");
  843. std::sprintf(fTmpBuf, "%f\n", pData->sampleRate);
  844. fUiServer.writeMessage(fTmpBuf);
  845. fUiServer.flushMessages();
  846. }
  847. void uiServerOptions()
  848. {
  849. CARLA_SAFE_ASSERT_RETURN(fIsRunning,);
  850. CARLA_SAFE_ASSERT_RETURN(fUiServer.isPipeRunning(),);
  851. const EngineOptions& options(pData->options);
  852. const CarlaMutexLocker cml(fUiServer.getPipeLock());
  853. const char* const optionsForcedStr(fOptionsForced ? "true\n" : "false\n");
  854. const std::size_t optionsForcedStrSize(fOptionsForced ? 5 : 6);
  855. std::sprintf(fTmpBuf, "ENGINE_OPTION_%i\n", ENGINE_OPTION_PROCESS_MODE);
  856. fUiServer.writeMessage(fTmpBuf);
  857. fUiServer.writeMessage(optionsForcedStr, optionsForcedStrSize);
  858. std::sprintf(fTmpBuf, "%i\n", options.processMode);
  859. fUiServer.writeMessage(fTmpBuf);
  860. fUiServer.flushMessages();
  861. std::sprintf(fTmpBuf, "ENGINE_OPTION_%i\n", ENGINE_OPTION_TRANSPORT_MODE);
  862. fUiServer.writeMessage(fTmpBuf);
  863. fUiServer.writeMessage(optionsForcedStr, optionsForcedStrSize);
  864. std::sprintf(fTmpBuf, "%i\n", options.transportMode);
  865. fUiServer.writeMessage(fTmpBuf);
  866. fUiServer.flushMessages();
  867. std::sprintf(fTmpBuf, "ENGINE_OPTION_%i\n", ENGINE_OPTION_FORCE_STEREO);
  868. fUiServer.writeMessage(fTmpBuf);
  869. fUiServer.writeMessage(optionsForcedStr, optionsForcedStrSize);
  870. fUiServer.writeMessage(options.forceStereo ? "true\n" : "false\n");
  871. fUiServer.flushMessages();
  872. std::sprintf(fTmpBuf, "ENGINE_OPTION_%i\n", ENGINE_OPTION_PREFER_PLUGIN_BRIDGES);
  873. fUiServer.writeMessage(fTmpBuf);
  874. fUiServer.writeMessage(optionsForcedStr, optionsForcedStrSize);
  875. fUiServer.writeMessage(options.preferPluginBridges ? "true\n" : "false\n");
  876. fUiServer.flushMessages();
  877. std::sprintf(fTmpBuf, "ENGINE_OPTION_%i\n", ENGINE_OPTION_PREFER_UI_BRIDGES);
  878. fUiServer.writeMessage(fTmpBuf);
  879. fUiServer.writeMessage(optionsForcedStr, optionsForcedStrSize);
  880. fUiServer.writeMessage(options.preferUiBridges ? "true\n" : "false\n");
  881. fUiServer.flushMessages();
  882. std::sprintf(fTmpBuf, "ENGINE_OPTION_%i\n", ENGINE_OPTION_UIS_ALWAYS_ON_TOP);
  883. fUiServer.writeMessage(fTmpBuf);
  884. fUiServer.writeMessage(optionsForcedStr, optionsForcedStrSize);
  885. fUiServer.writeMessage(options.uisAlwaysOnTop ? "true\n" : "false\n");
  886. fUiServer.flushMessages();
  887. std::sprintf(fTmpBuf, "ENGINE_OPTION_%i\n", ENGINE_OPTION_MAX_PARAMETERS);
  888. fUiServer.writeMessage(fTmpBuf);
  889. fUiServer.writeMessage(optionsForcedStr, optionsForcedStrSize);
  890. std::sprintf(fTmpBuf, "%i\n", options.maxParameters);
  891. fUiServer.writeMessage(fTmpBuf);
  892. fUiServer.flushMessages();
  893. std::sprintf(fTmpBuf, "ENGINE_OPTION_%i\n", ENGINE_OPTION_UI_BRIDGES_TIMEOUT);
  894. fUiServer.writeMessage(fTmpBuf);
  895. fUiServer.writeMessage(optionsForcedStr, optionsForcedStrSize);
  896. std::sprintf(fTmpBuf, "%i\n", options.uiBridgesTimeout);
  897. fUiServer.writeMessage(fTmpBuf);
  898. fUiServer.flushMessages();
  899. std::sprintf(fTmpBuf, "ENGINE_OPTION_%i\n", ENGINE_OPTION_PATH_BINARIES);
  900. fUiServer.writeMessage(fTmpBuf);
  901. fUiServer.writeMessage("true\n", 5);
  902. std::sprintf(fTmpBuf, "%s\n", options.binaryDir);
  903. fUiServer.writeMessage(fTmpBuf);
  904. fUiServer.flushMessages();
  905. std::sprintf(fTmpBuf, "ENGINE_OPTION_%i\n", ENGINE_OPTION_PATH_RESOURCES);
  906. fUiServer.writeMessage(fTmpBuf);
  907. fUiServer.writeMessage("true\n", 5);
  908. std::sprintf(fTmpBuf, "%s\n", options.resourceDir);
  909. fUiServer.writeMessage(fTmpBuf);
  910. fUiServer.flushMessages();
  911. }
  912. // -------------------------------------------------------------------
  913. // Plugin parameter calls
  914. uint32_t getParameterCount() const
  915. {
  916. if (CarlaPlugin* const plugin = _getFirstPlugin())
  917. return plugin->getParameterCount();
  918. return 0;
  919. }
  920. const NativeParameter* getParameterInfo(const uint32_t index) const
  921. {
  922. if (CarlaPlugin* const plugin = _getFirstPlugin())
  923. {
  924. if (index < plugin->getParameterCount())
  925. {
  926. static NativeParameter param;
  927. static char strBufName[STR_MAX+1];
  928. static char strBufUnit[STR_MAX+1];
  929. const ParameterData& paramData(plugin->getParameterData(index));
  930. const ParameterRanges& paramRanges(plugin->getParameterRanges(index));
  931. plugin->getParameterName(index, strBufName);
  932. plugin->getParameterUnit(index, strBufUnit);
  933. uint hints = 0x0;
  934. if (paramData.hints & PARAMETER_IS_BOOLEAN)
  935. hints |= NATIVE_PARAMETER_IS_BOOLEAN;
  936. if (paramData.hints & PARAMETER_IS_INTEGER)
  937. hints |= NATIVE_PARAMETER_IS_INTEGER;
  938. if (paramData.hints & PARAMETER_IS_LOGARITHMIC)
  939. hints |= NATIVE_PARAMETER_IS_LOGARITHMIC;
  940. if (paramData.hints & PARAMETER_IS_AUTOMABLE)
  941. hints |= NATIVE_PARAMETER_IS_AUTOMABLE;
  942. if (paramData.hints & PARAMETER_USES_SAMPLERATE)
  943. hints |= NATIVE_PARAMETER_USES_SAMPLE_RATE;
  944. if (paramData.hints & PARAMETER_USES_SCALEPOINTS)
  945. hints |= NATIVE_PARAMETER_USES_SCALEPOINTS;
  946. if (paramData.type == PARAMETER_INPUT || paramData.type == PARAMETER_OUTPUT)
  947. {
  948. if (paramData.hints & PARAMETER_IS_ENABLED)
  949. hints |= NATIVE_PARAMETER_IS_ENABLED;
  950. if (paramData.type == PARAMETER_OUTPUT)
  951. hints |= NATIVE_PARAMETER_IS_OUTPUT;
  952. }
  953. param.hints = static_cast<NativeParameterHints>(hints);
  954. param.name = strBufName;
  955. param.unit = strBufUnit;
  956. param.ranges.def = paramRanges.def;
  957. param.ranges.min = paramRanges.min;
  958. param.ranges.max = paramRanges.max;
  959. param.ranges.step = paramRanges.step;
  960. param.ranges.stepSmall = paramRanges.stepSmall;
  961. param.ranges.stepLarge = paramRanges.stepLarge;
  962. param.scalePointCount = 0; // TODO
  963. param.scalePoints = nullptr;
  964. return &param;
  965. }
  966. }
  967. return nullptr;
  968. }
  969. float getParameterValue(const uint32_t index) const
  970. {
  971. if (CarlaPlugin* const plugin = _getFirstPlugin())
  972. {
  973. if (index < plugin->getParameterCount())
  974. return plugin->getParameterValue(index);
  975. }
  976. return 0.0f;
  977. }
  978. // -------------------------------------------------------------------
  979. // Plugin midi-program calls
  980. uint32_t getMidiProgramCount() const
  981. {
  982. if (CarlaPlugin* const plugin = _getFirstPlugin())
  983. return plugin->getMidiProgramCount();
  984. return 0;
  985. }
  986. const NativeMidiProgram* getMidiProgramInfo(const uint32_t index) const
  987. {
  988. if (CarlaPlugin* const plugin = _getFirstPlugin())
  989. {
  990. if (index < plugin->getMidiProgramCount())
  991. {
  992. static NativeMidiProgram midiProg;
  993. {
  994. const MidiProgramData& midiProgData(plugin->getMidiProgramData(index));
  995. midiProg.bank = midiProgData.bank;
  996. midiProg.program = midiProgData.program;
  997. midiProg.name = midiProgData.name;
  998. }
  999. return &midiProg;
  1000. }
  1001. }
  1002. return nullptr;
  1003. }
  1004. // -------------------------------------------------------------------
  1005. // Plugin state calls
  1006. void setParameterValue(const uint32_t index, const float value)
  1007. {
  1008. if (CarlaPlugin* const plugin = _getFirstPlugin())
  1009. {
  1010. if (index < plugin->getParameterCount())
  1011. plugin->setParameterValue(index, value, false, false, false);
  1012. }
  1013. }
  1014. void setMidiProgram(const uint8_t, const uint32_t bank, const uint32_t program)
  1015. {
  1016. if (CarlaPlugin* const plugin = _getFirstPlugin())
  1017. plugin->setMidiProgramById(bank, program, false, false, false);
  1018. }
  1019. // -------------------------------------------------------------------
  1020. // Plugin process calls
  1021. void activate()
  1022. {
  1023. #if 0
  1024. for (uint i=0; i < pData->curPluginCount; ++i)
  1025. {
  1026. CarlaPlugin* const plugin(pData->plugins[i].plugin);
  1027. if (plugin == nullptr || ! plugin->isEnabled())
  1028. continue;
  1029. plugin->setActive(true, true, false);
  1030. }
  1031. #endif
  1032. fIsActive = true;
  1033. }
  1034. void deactivate()
  1035. {
  1036. fIsActive = false;
  1037. #if 0
  1038. for (uint i=0; i < pData->curPluginCount; ++i)
  1039. {
  1040. CarlaPlugin* const plugin(pData->plugins[i].plugin);
  1041. if (plugin == nullptr || ! plugin->isEnabled())
  1042. continue;
  1043. plugin->setActive(false, true, false);
  1044. }
  1045. #endif
  1046. // just in case
  1047. //runPendingRtEvents();
  1048. }
  1049. void process(float** const inBuffer, float** const outBuffer, const uint32_t frames,
  1050. const NativeMidiEvent* const midiEvents, const uint32_t midiEventCount)
  1051. {
  1052. const PendingRtEventsRunner prt(this, frames);
  1053. // ---------------------------------------------------------------
  1054. // Time Info
  1055. const NativeTimeInfo* const timeInfo(pHost->get_time_info(pHost->handle));
  1056. pData->timeInfo.playing = timeInfo->playing;
  1057. pData->timeInfo.frame = timeInfo->frame;
  1058. pData->timeInfo.usecs = timeInfo->usecs;
  1059. pData->timeInfo.valid = 0x0;
  1060. if (timeInfo->bbt.valid)
  1061. {
  1062. pData->timeInfo.valid |= EngineTimeInfo::kValidBBT;
  1063. pData->timeInfo.bbt.bar = timeInfo->bbt.bar;
  1064. pData->timeInfo.bbt.beat = timeInfo->bbt.beat;
  1065. pData->timeInfo.bbt.tick = timeInfo->bbt.tick;
  1066. pData->timeInfo.bbt.barStartTick = timeInfo->bbt.barStartTick;
  1067. pData->timeInfo.bbt.beatsPerBar = timeInfo->bbt.beatsPerBar;
  1068. pData->timeInfo.bbt.beatType = timeInfo->bbt.beatType;
  1069. pData->timeInfo.bbt.ticksPerBeat = timeInfo->bbt.ticksPerBeat;
  1070. pData->timeInfo.bbt.beatsPerMinute = timeInfo->bbt.beatsPerMinute;
  1071. }
  1072. // ---------------------------------------------------------------
  1073. // Do nothing if no plugins and rack mode
  1074. if (pData->curPluginCount == 0)
  1075. {
  1076. if (outBuffer[0] != inBuffer[0])
  1077. FloatVectorOperations::copy(outBuffer[0], inBuffer[0], static_cast<int>(frames));
  1078. if (outBuffer[1] != inBuffer[1])
  1079. FloatVectorOperations::copy(outBuffer[1], inBuffer[1], static_cast<int>(frames));
  1080. for (uint32_t i=0; i < midiEventCount; ++i)
  1081. {
  1082. if (! pHost->write_midi_event(pHost->handle, &midiEvents[i]))
  1083. break;
  1084. }
  1085. return;
  1086. }
  1087. // ---------------------------------------------------------------
  1088. // initialize events
  1089. carla_zeroStructs(pData->events.in, kMaxEngineEventInternalCount);
  1090. carla_zeroStructs(pData->events.out, kMaxEngineEventInternalCount);
  1091. // ---------------------------------------------------------------
  1092. // events input (before processing)
  1093. {
  1094. uint32_t engineEventIndex = 0;
  1095. for (uint32_t i=0; i < midiEventCount && engineEventIndex < kMaxEngineEventInternalCount; ++i)
  1096. {
  1097. const NativeMidiEvent& midiEvent(midiEvents[i]);
  1098. EngineEvent& engineEvent(pData->events.in[engineEventIndex++]);
  1099. engineEvent.time = midiEvent.time;
  1100. engineEvent.fillFromMidiData(midiEvent.size, midiEvent.data, 0);
  1101. if (engineEventIndex >= kMaxEngineEventInternalCount)
  1102. break;
  1103. }
  1104. }
  1105. {
  1106. // -----------------------------------------------------------
  1107. // create audio buffers
  1108. const float* inBuf[2] = { inBuffer[0], inBuffer[1] };
  1109. /* */ float* outBuf[2] = { outBuffer[0], outBuffer[1] };
  1110. // -----------------------------------------------------------
  1111. // process
  1112. pData->graph.processRack(pData, inBuf, outBuf, frames);
  1113. }
  1114. // ---------------------------------------------------------------
  1115. // events output (after processing)
  1116. carla_zeroStructs(pData->events.in, kMaxEngineEventInternalCount);
  1117. {
  1118. NativeMidiEvent midiEvent;
  1119. for (uint32_t i=0; i < kMaxEngineEventInternalCount; ++i)
  1120. {
  1121. const EngineEvent& engineEvent(pData->events.out[i]);
  1122. if (engineEvent.type == kEngineEventTypeNull)
  1123. break;
  1124. midiEvent.time = engineEvent.time;
  1125. if (engineEvent.type == CarlaBackend::kEngineEventTypeControl)
  1126. {
  1127. midiEvent.port = 0;
  1128. engineEvent.ctrl.convertToMidiData(engineEvent.channel, midiEvent.size, midiEvent.data);
  1129. }
  1130. else if (engineEvent.type == kEngineEventTypeMidi)
  1131. {
  1132. if (engineEvent.midi.size > 4 || engineEvent.midi.dataExt != nullptr)
  1133. continue;
  1134. midiEvent.port = engineEvent.midi.port;
  1135. midiEvent.size = engineEvent.midi.size;
  1136. midiEvent.data[0] = static_cast<uint8_t>(engineEvent.midi.data[0] + engineEvent.channel);
  1137. for (uint8_t j=1; j < midiEvent.size; ++j)
  1138. midiEvent.data[j] = engineEvent.midi.data[j];
  1139. }
  1140. else
  1141. {
  1142. carla_stderr("Unknown event type...");
  1143. continue;
  1144. }
  1145. pHost->write_midi_event(pHost->handle, &midiEvent);
  1146. }
  1147. }
  1148. }
  1149. // -------------------------------------------------------------------
  1150. // Plugin UI calls
  1151. void uiShow(const bool show)
  1152. {
  1153. if (show)
  1154. {
  1155. if (fUiServer.isPipeRunning())
  1156. {
  1157. fUiServer.writeFocusMessage();
  1158. return;
  1159. }
  1160. CarlaString path(pHost->resourceDir);
  1161. path += CARLA_OS_SEP_STR "carla-plugin";
  1162. #ifdef CARLA_OS_WIN
  1163. path += ".exe";
  1164. #endif
  1165. carla_stdout("Trying to start carla-plugin using \"%s\"", path.buffer());
  1166. fUiServer.setData(path, pData->sampleRate, pHost->uiName);
  1167. if (! fUiServer.startPipeServer(false))
  1168. {
  1169. pHost->dispatcher(pHost->handle, NATIVE_HOST_OPCODE_UI_UNAVAILABLE, 0, 0, nullptr, 0.0f);
  1170. return;
  1171. }
  1172. uiServerInfo();
  1173. uiServerOptions();
  1174. uiServerCallback(ENGINE_CALLBACK_ENGINE_STARTED, 0, pData->options.processMode, pData->options.transportMode, 0.0f, "Plugin");
  1175. fUiServer.writeShowMessage();
  1176. for (uint i=0; i < pData->curPluginCount; ++i)
  1177. {
  1178. CarlaPlugin* const plugin(pData->plugins[i].plugin);
  1179. if (plugin != nullptr && plugin->isEnabled())
  1180. {
  1181. uiServerCallback(ENGINE_CALLBACK_PLUGIN_ADDED, i, 0, 0, 0.0f, plugin->getName());
  1182. }
  1183. }
  1184. if (fWaitForReadyMsg)
  1185. {
  1186. carla_stdout("Using Carla plugin embedded, waiting for it to be ready...");
  1187. for (; fUiServer.isPipeRunning() && ! fUiServer.isReady();)
  1188. {
  1189. carla_msleep(25);
  1190. fUiServer.idlePipe();
  1191. }
  1192. carla_stdout("Done!");
  1193. }
  1194. }
  1195. else
  1196. {
  1197. fUiServer.stopPipeServer(2000);
  1198. // hide all custom uis
  1199. for (uint i=0; i < pData->curPluginCount; ++i)
  1200. {
  1201. CarlaPlugin* const plugin(pData->plugins[i].plugin);
  1202. if (plugin != nullptr && plugin->isEnabled())
  1203. {
  1204. if (plugin->getHints() & PLUGIN_HAS_CUSTOM_UI)
  1205. {
  1206. try {
  1207. plugin->showCustomUI(false);
  1208. } CARLA_SAFE_EXCEPTION_CONTINUE("Plugin showCustomUI (hide)");
  1209. }
  1210. }
  1211. }
  1212. }
  1213. }
  1214. void uiIdle()
  1215. {
  1216. for (uint i=0; i < pData->curPluginCount; ++i)
  1217. {
  1218. CarlaPlugin* const plugin(pData->plugins[i].plugin);
  1219. if (plugin != nullptr && plugin->isEnabled())
  1220. {
  1221. const uint hints(plugin->getHints());
  1222. if ((hints & PLUGIN_HAS_CUSTOM_UI) != 0 && (hints & PLUGIN_NEEDS_UI_MAIN_THREAD) != 0)
  1223. {
  1224. try {
  1225. plugin->uiIdle();
  1226. } CARLA_SAFE_EXCEPTION_CONTINUE("Plugin uiIdle");
  1227. }
  1228. }
  1229. }
  1230. if (fUiServer.isPipeRunning())
  1231. {
  1232. fUiServer.idlePipe();
  1233. const CarlaMutexLocker cml(fUiServer.getPipeLock());
  1234. #ifndef CARLA_OS_WIN
  1235. const EngineTimeInfo& timeInfo(pData->timeInfo);
  1236. const ScopedLocale csl;
  1237. // send transport
  1238. fUiServer.writeAndFixMessage("transport");
  1239. fUiServer.writeMessage(timeInfo.playing ? "true\n" : "false\n");
  1240. if (timeInfo.valid & EngineTimeInfo::kValidBBT)
  1241. {
  1242. std::sprintf(fTmpBuf, P_UINT64 ":%i:%i:%i\n", timeInfo.frame, timeInfo.bbt.bar, timeInfo.bbt.beat, timeInfo.bbt.tick);
  1243. fUiServer.writeMessage(fTmpBuf);
  1244. std::sprintf(fTmpBuf, "%f\n", timeInfo.bbt.beatsPerMinute);
  1245. fUiServer.writeMessage(fTmpBuf);
  1246. }
  1247. else
  1248. {
  1249. std::sprintf(fTmpBuf, P_UINT64 ":0:0:0\n", timeInfo.frame);
  1250. fUiServer.writeMessage(fTmpBuf);
  1251. fUiServer.writeMessage("0.0\n");
  1252. }
  1253. fUiServer.flushMessages();
  1254. #endif
  1255. // send peaks and param outputs for all plugins
  1256. for (uint i=0; i < pData->curPluginCount; ++i)
  1257. {
  1258. const EnginePluginData& plugData(pData->plugins[i]);
  1259. const CarlaPlugin* const plugin(pData->plugins[i].plugin);
  1260. std::sprintf(fTmpBuf, "PEAKS_%i\n", i);
  1261. fUiServer.writeMessage(fTmpBuf);
  1262. std::sprintf(fTmpBuf, "%f:%f:%f:%f\n", plugData.insPeak[0], plugData.insPeak[1], plugData.outsPeak[0], plugData.outsPeak[1]);
  1263. fUiServer.writeMessage(fTmpBuf);
  1264. fUiServer.flushMessages();
  1265. for (uint32_t j=0, count=plugin->getParameterCount(); j < count; ++j)
  1266. {
  1267. if (! plugin->isParameterOutput(j))
  1268. continue;
  1269. std::sprintf(fTmpBuf, "PARAMVAL_%i:%i\n", i, j);
  1270. fUiServer.writeMessage(fTmpBuf);
  1271. std::sprintf(fTmpBuf, "%f\n", plugin->getParameterValue(j));
  1272. fUiServer.writeMessage(fTmpBuf);
  1273. fUiServer.flushMessages();
  1274. }
  1275. }
  1276. }
  1277. switch (fUiServer.getAndResetUiState())
  1278. {
  1279. case CarlaExternalUI::UiNone:
  1280. case CarlaExternalUI::UiShow:
  1281. break;
  1282. case CarlaExternalUI::UiCrashed:
  1283. pHost->dispatcher(pHost->handle, NATIVE_HOST_OPCODE_UI_UNAVAILABLE, 0, 0, nullptr, 0.0f);
  1284. break;
  1285. case CarlaExternalUI::UiHide:
  1286. pHost->ui_closed(pHost->handle);
  1287. fUiServer.stopPipeServer(1000);
  1288. break;
  1289. }
  1290. }
  1291. // -------------------------------------------------------------------
  1292. // Plugin state calls
  1293. char* getState() const
  1294. {
  1295. MemoryOutputStream out;
  1296. saveProjectInternal(out);
  1297. return strdup(out.toString().toRawUTF8());
  1298. }
  1299. void setState(const char* const data)
  1300. {
  1301. // remove all plugins from UI side
  1302. for (uint i=0, count=pData->curPluginCount; i < count; ++i)
  1303. CarlaEngine::callback(ENGINE_CALLBACK_PLUGIN_REMOVED, count-i-1, 0, 0, 0.0f, nullptr);
  1304. // remove all plugins from backend, no lock
  1305. fIsRunning = false;
  1306. removeAllPlugins();
  1307. fIsRunning = true;
  1308. // stopped during removeAllPlugins()
  1309. if (! pData->thread.isThreadRunning())
  1310. pData->thread.startThread();
  1311. fOptionsForced = true;
  1312. const String state(data);
  1313. XmlDocument xml(state);
  1314. loadProjectInternal(xml);
  1315. }
  1316. // -------------------------------------------------------------------
  1317. public:
  1318. #define handlePtr ((CarlaEngineNative*)handle)
  1319. static NativePluginHandle _instantiateRack(const NativeHostDescriptor* host)
  1320. {
  1321. return new CarlaEngineNative(host, false);
  1322. }
  1323. static void _cleanup(NativePluginHandle handle)
  1324. {
  1325. delete handlePtr;
  1326. }
  1327. static uint32_t _get_parameter_count(NativePluginHandle handle)
  1328. {
  1329. return handlePtr->getParameterCount();
  1330. }
  1331. static const NativeParameter* _get_parameter_info(NativePluginHandle handle, uint32_t index)
  1332. {
  1333. return handlePtr->getParameterInfo(index);
  1334. }
  1335. static float _get_parameter_value(NativePluginHandle handle, uint32_t index)
  1336. {
  1337. return handlePtr->getParameterValue(index);
  1338. }
  1339. static uint32_t _get_midi_program_count(NativePluginHandle handle)
  1340. {
  1341. return handlePtr->getMidiProgramCount();
  1342. }
  1343. static const NativeMidiProgram* _get_midi_program_info(NativePluginHandle handle, uint32_t index)
  1344. {
  1345. return handlePtr->getMidiProgramInfo(index);
  1346. }
  1347. static void _set_parameter_value(NativePluginHandle handle, uint32_t index, float value)
  1348. {
  1349. handlePtr->setParameterValue(index, value);
  1350. }
  1351. static void _set_midi_program(NativePluginHandle handle, uint8_t channel, uint32_t bank, uint32_t program)
  1352. {
  1353. handlePtr->setMidiProgram(channel, bank, program);
  1354. }
  1355. static void _ui_show(NativePluginHandle handle, bool show)
  1356. {
  1357. handlePtr->uiShow(show);
  1358. }
  1359. static void _ui_idle(NativePluginHandle handle)
  1360. {
  1361. handlePtr->uiIdle();
  1362. }
  1363. static void _activate(NativePluginHandle handle)
  1364. {
  1365. handlePtr->activate();
  1366. }
  1367. static void _deactivate(NativePluginHandle handle)
  1368. {
  1369. handlePtr->deactivate();
  1370. }
  1371. static void _process(NativePluginHandle handle, float** inBuffer, float** outBuffer, const uint32_t frames, const NativeMidiEvent* midiEvents, uint32_t midiEventCount)
  1372. {
  1373. handlePtr->process(inBuffer, outBuffer, frames, midiEvents, midiEventCount);
  1374. }
  1375. static char* _get_state(NativePluginHandle handle)
  1376. {
  1377. return handlePtr->getState();
  1378. }
  1379. static void _set_state(NativePluginHandle handle, const char* data)
  1380. {
  1381. handlePtr->setState(data);
  1382. }
  1383. static intptr_t _dispatcher(NativePluginHandle handle, NativePluginDispatcherOpcode opcode, int32_t index, intptr_t value, void* ptr, float opt)
  1384. {
  1385. switch(opcode)
  1386. {
  1387. case NATIVE_PLUGIN_OPCODE_NULL:
  1388. if (static_cast<uint32_t>(index) == 0xDEADF00D && static_cast<uintptr_t>(value) == 0xC0C0B00B)
  1389. {
  1390. handlePtr->fWaitForReadyMsg = true;
  1391. return handlePtr->fUiServer.getRemoteWinId();
  1392. }
  1393. return 0;
  1394. case NATIVE_PLUGIN_OPCODE_BUFFER_SIZE_CHANGED:
  1395. CARLA_SAFE_ASSERT_RETURN(value > 0, 0);
  1396. handlePtr->bufferSizeChanged(static_cast<uint32_t>(value));
  1397. return 0;
  1398. case NATIVE_PLUGIN_OPCODE_SAMPLE_RATE_CHANGED:
  1399. CARLA_SAFE_ASSERT_RETURN(opt > 0.0, 0);
  1400. handlePtr->sampleRateChanged(static_cast<double>(opt));
  1401. return 0;
  1402. case NATIVE_PLUGIN_OPCODE_OFFLINE_CHANGED:
  1403. handlePtr->offlineModeChanged(value != 0);
  1404. return 0;
  1405. case NATIVE_PLUGIN_OPCODE_UI_NAME_CHANGED:
  1406. //handlePtr->uiNameChanged(static_cast<const char*>(ptr));
  1407. return 0;
  1408. }
  1409. return 0;
  1410. // unused
  1411. (void)index;
  1412. (void)ptr;
  1413. }
  1414. // -------------------------------------------------------------------
  1415. static void _ui_server_callback(void* handle, EngineCallbackOpcode action, uint pluginId, int value1, int value2, float value3, const char* valueStr)
  1416. {
  1417. handlePtr->uiServerCallback(action, pluginId, value1, value2, value3, valueStr);
  1418. }
  1419. // -------------------------------------------------------------------
  1420. #undef handlePtr
  1421. private:
  1422. const NativeHostDescriptor* const pHost;
  1423. bool fIsActive, fIsRunning;
  1424. CarlaEngineNativeUI fUiServer;
  1425. bool fOptionsForced;
  1426. bool fWaitForReadyMsg;
  1427. char fTmpBuf[STR_MAX+1];
  1428. CarlaPlugin* _getFirstPlugin() const noexcept
  1429. {
  1430. if (pData->curPluginCount == 0 || pData->plugins == nullptr)
  1431. return nullptr;
  1432. CarlaPlugin* const plugin(pData->plugins[0].plugin);
  1433. if (plugin == nullptr || ! plugin->isEnabled())
  1434. return nullptr;
  1435. return pData->plugins[0].plugin;
  1436. }
  1437. CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaEngineNative)
  1438. };
  1439. // -----------------------------------------------------------------------
  1440. static const NativePluginDescriptor carlaRackDesc = {
  1441. /* category */ NATIVE_PLUGIN_CATEGORY_OTHER,
  1442. /* hints */ static_cast<NativePluginHints>(NATIVE_PLUGIN_IS_SYNTH
  1443. |NATIVE_PLUGIN_HAS_UI
  1444. //|NATIVE_PLUGIN_NEEDS_FIXED_BUFFERS
  1445. |NATIVE_PLUGIN_NEEDS_UI_MAIN_THREAD
  1446. |NATIVE_PLUGIN_USES_STATE
  1447. |NATIVE_PLUGIN_USES_TIME),
  1448. /* supports */ static_cast<NativePluginSupports>(NATIVE_PLUGIN_SUPPORTS_EVERYTHING),
  1449. /* audioIns */ 2,
  1450. /* audioOuts */ 2,
  1451. /* midiIns */ 1,
  1452. /* midiOuts */ 1,
  1453. /* paramIns */ 0,
  1454. /* paramOuts */ 0,
  1455. /* name */ "Carla-Rack",
  1456. /* label */ "carlarack",
  1457. /* maker */ "falkTX",
  1458. /* copyright */ "GNU GPL v2+",
  1459. CarlaEngineNative::_instantiateRack,
  1460. CarlaEngineNative::_cleanup,
  1461. CarlaEngineNative::_get_parameter_count,
  1462. CarlaEngineNative::_get_parameter_info,
  1463. CarlaEngineNative::_get_parameter_value,
  1464. CarlaEngineNative::_get_midi_program_count,
  1465. CarlaEngineNative::_get_midi_program_info,
  1466. CarlaEngineNative::_set_parameter_value,
  1467. CarlaEngineNative::_set_midi_program,
  1468. /* _set_custom_data */ nullptr,
  1469. CarlaEngineNative::_ui_show,
  1470. CarlaEngineNative::_ui_idle,
  1471. /* _ui_set_parameter_value */ nullptr,
  1472. /* _ui_set_midi_program */ nullptr,
  1473. /* _ui_set_custom_data */ nullptr,
  1474. CarlaEngineNative::_activate,
  1475. CarlaEngineNative::_deactivate,
  1476. CarlaEngineNative::_process,
  1477. CarlaEngineNative::_get_state,
  1478. CarlaEngineNative::_set_state,
  1479. CarlaEngineNative::_dispatcher
  1480. };
  1481. CARLA_BACKEND_END_NAMESPACE
  1482. // -----------------------------------------------------------------------
  1483. CARLA_EXPORT
  1484. void carla_register_native_plugin_carla();
  1485. void carla_register_native_plugin_carla()
  1486. {
  1487. CARLA_BACKEND_USE_NAMESPACE;
  1488. carla_register_native_plugin(&carlaRackDesc);
  1489. }
  1490. // -----------------------------------------------------------------------
  1491. CARLA_EXPORT
  1492. const NativePluginDescriptor* carla_get_native_rack_plugin();
  1493. const NativePluginDescriptor* carla_get_native_rack_plugin()
  1494. {
  1495. CARLA_BACKEND_USE_NAMESPACE;
  1496. return &carlaRackDesc;
  1497. }
  1498. // -----------------------------------------------------------------------
  1499. // Extra stuff for linking purposes
  1500. #ifdef CARLA_PLUGIN_EXPORT
  1501. CARLA_BACKEND_START_NAMESPACE
  1502. CarlaEngine* CarlaEngine::newJack() { return nullptr; }
  1503. CarlaEngine* CarlaEngine::newRtAudio(const AudioApi) { return nullptr; }
  1504. uint CarlaEngine::getRtAudioApiCount() { return 0; }
  1505. const char* CarlaEngine::getRtAudioApiName(const uint) { return nullptr; }
  1506. const char* const* CarlaEngine::getRtAudioApiDeviceNames(const uint) { return nullptr; }
  1507. const EngineDriverDeviceInfo* CarlaEngine::getRtAudioDeviceInfo(const uint, const char* const) { return nullptr; }
  1508. CARLA_BACKEND_END_NAMESPACE
  1509. #include "CarlaHostCommon.cpp"
  1510. #include "CarlaPluginUI.cpp"
  1511. #include "CarlaDssiUtils.cpp"
  1512. #include "CarlaPatchbayUtils.cpp"
  1513. #include "CarlaPipeUtils.cpp"
  1514. #include "CarlaStateUtils.cpp"
  1515. #endif
  1516. // -----------------------------------------------------------------------