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.

1688 lines
55KB

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