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.

2522 lines
89KB

  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 "CarlaEngineInternal.hpp"
  18. #include "CarlaPlugin.hpp"
  19. #include "CarlaBackendUtils.hpp"
  20. #include "CarlaEngineUtils.hpp"
  21. #include "CarlaMathUtils.hpp"
  22. #include "CarlaMIDI.h"
  23. #include "CarlaPatchbayUtils.hpp"
  24. #include "CarlaStringList.hpp"
  25. #include "jackey.h"
  26. #include "juce_audio_basics/juce_audio_basics.h"
  27. #ifdef __SSE2_MATH__
  28. # include <xmmintrin.h>
  29. #endif
  30. // must be last
  31. #include "jackbridge/JackBridge.hpp"
  32. #define URI_CANVAS_ICON "http://kxstudio.sf.net/ns/canvas/icon"
  33. using juce::FloatVectorOperations;
  34. using juce::String;
  35. using juce::StringArray;
  36. CARLA_BACKEND_START_NAMESPACE
  37. class CarlaEngineJack;
  38. class CarlaEngineJackClient;
  39. // -----------------------------------------------------------------------
  40. // Fallback data
  41. static const EngineEvent kFallbackJackEngineEvent = { kEngineEventTypeNull, 0, 0, {{ kEngineControlEventTypeNull, 0, 0.0f }} };
  42. // -----------------------------------------------------------------------
  43. // Carla Engine Port removal helper
  44. class CarlaEngineJackAudioPort;
  45. class CarlaEngineJackCVPort;
  46. class CarlaEngineJackEventPort;
  47. struct JackPortDeletionCallback {
  48. virtual ~JackPortDeletionCallback() noexcept {}
  49. virtual void jackAudioPortDeleted(CarlaEngineJackAudioPort* const) noexcept = 0;
  50. virtual void jackCVPortDeleted(CarlaEngineJackCVPort* const) noexcept = 0;
  51. virtual void jackEventPortDeleted(CarlaEngineJackEventPort* const) noexcept = 0;
  52. };
  53. // -----------------------------------------------------------------------
  54. // Carla Engine JACK-Audio port
  55. class CarlaEngineJackAudioPort : public CarlaEngineAudioPort
  56. {
  57. public:
  58. CarlaEngineJackAudioPort(const CarlaEngineClient& client, const bool isInputPort, const uint32_t indexOffset, jack_client_t* const jackClient, jack_port_t* const jackPort, JackPortDeletionCallback* const delCallback) noexcept
  59. : CarlaEngineAudioPort(client, isInputPort, indexOffset),
  60. fJackClient(jackClient),
  61. fJackPort(jackPort),
  62. kDeletionCallback(delCallback)
  63. {
  64. carla_debug("CarlaEngineJackAudioPort::CarlaEngineJackAudioPort(%s, %p, %p)", bool2str(isInputPort), jackClient, jackPort);
  65. switch (kClient.getEngine().getProccessMode())
  66. {
  67. case ENGINE_PROCESS_MODE_SINGLE_CLIENT:
  68. case ENGINE_PROCESS_MODE_MULTIPLE_CLIENTS:
  69. CARLA_SAFE_ASSERT_RETURN(jackClient != nullptr && jackPort != nullptr,);
  70. #ifndef BUILD_BRIDGE
  71. if (const jack_uuid_t uuid = jackbridge_port_uuid(jackPort))
  72. jackbridge_set_property(jackClient, uuid, JACKEY_SIGNAL_TYPE, "AUDIO", "text/plain");
  73. #endif
  74. break;
  75. default:
  76. CARLA_SAFE_ASSERT(jackClient == nullptr && jackPort == nullptr);
  77. break;
  78. }
  79. }
  80. ~CarlaEngineJackAudioPort() noexcept override
  81. {
  82. carla_debug("CarlaEngineJackAudioPort::~CarlaEngineJackAudioPort()");
  83. if (fJackClient != nullptr && fJackPort != nullptr)
  84. {
  85. #ifndef BUILD_BRIDGE
  86. try {
  87. if (const jack_uuid_t uuid = jackbridge_port_uuid(fJackPort))
  88. jackbridge_remove_property(fJackClient, uuid, JACKEY_SIGNAL_TYPE);
  89. } CARLA_SAFE_EXCEPTION("Audio port remove meta type");
  90. #endif
  91. try {
  92. jackbridge_port_unregister(fJackClient, fJackPort);
  93. } CARLA_SAFE_EXCEPTION("Audio port unregister");
  94. fJackClient = nullptr;
  95. fJackPort = nullptr;
  96. }
  97. if (kDeletionCallback != nullptr)
  98. kDeletionCallback->jackAudioPortDeleted(this);
  99. }
  100. void initBuffer() noexcept override
  101. {
  102. if (fJackPort == nullptr)
  103. return CarlaEngineAudioPort::initBuffer();
  104. const uint32_t bufferSize(kClient.getEngine().getBufferSize());
  105. try {
  106. fBuffer = (float*)jackbridge_port_get_buffer(fJackPort, bufferSize);
  107. }
  108. catch(...) {
  109. fBuffer = nullptr;
  110. return;
  111. }
  112. if (! kIsInput)
  113. FloatVectorOperations::clear(fBuffer, static_cast<int>(bufferSize));
  114. }
  115. void invalidate() noexcept
  116. {
  117. fJackClient = nullptr;
  118. fJackPort = nullptr;
  119. }
  120. private:
  121. jack_client_t* fJackClient;
  122. jack_port_t* fJackPort;
  123. JackPortDeletionCallback* const kDeletionCallback;
  124. friend class CarlaEngineJackClient;
  125. CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaEngineJackAudioPort)
  126. };
  127. // -----------------------------------------------------------------------
  128. // Carla Engine JACK-CV port
  129. class CarlaEngineJackCVPort : public CarlaEngineCVPort
  130. {
  131. public:
  132. CarlaEngineJackCVPort(const CarlaEngineClient& client, const bool isInputPort, const uint32_t indexOffset, jack_client_t* const jackClient, jack_port_t* const jackPort, JackPortDeletionCallback* const delCallback) noexcept
  133. : CarlaEngineCVPort(client, isInputPort, indexOffset),
  134. fJackClient(jackClient),
  135. fJackPort(jackPort),
  136. kDeletionCallback(delCallback)
  137. {
  138. carla_debug("CarlaEngineJackCVPort::CarlaEngineJackCVPort(%s, %p, %p)", bool2str(isInputPort), jackClient, jackPort);
  139. switch (kClient.getEngine().getProccessMode())
  140. {
  141. case ENGINE_PROCESS_MODE_SINGLE_CLIENT:
  142. case ENGINE_PROCESS_MODE_MULTIPLE_CLIENTS:
  143. CARLA_SAFE_ASSERT_RETURN(jackClient != nullptr && jackPort != nullptr,);
  144. #ifndef BUILD_BRIDGE
  145. if (const jack_uuid_t uuid = jackbridge_port_uuid(jackPort))
  146. jackbridge_set_property(jackClient, uuid, JACKEY_SIGNAL_TYPE, "CV", "text/plain");
  147. #endif
  148. break;
  149. default:
  150. CARLA_SAFE_ASSERT(jackClient == nullptr && jackPort == nullptr);
  151. break;
  152. }
  153. }
  154. ~CarlaEngineJackCVPort() noexcept override
  155. {
  156. carla_debug("CarlaEngineJackCVPort::~CarlaEngineJackCVPort()");
  157. if (fJackClient != nullptr && fJackPort != nullptr)
  158. {
  159. #ifndef BUILD_BRIDGE
  160. try {
  161. if (const jack_uuid_t uuid = jackbridge_port_uuid(fJackPort))
  162. jackbridge_remove_property(fJackClient, uuid, JACKEY_SIGNAL_TYPE);
  163. } CARLA_SAFE_EXCEPTION("CV port remove meta type");
  164. #endif
  165. try {
  166. jackbridge_port_unregister(fJackClient, fJackPort);
  167. } CARLA_SAFE_EXCEPTION("CV port unregister");
  168. fJackClient = nullptr;
  169. fJackPort = nullptr;
  170. }
  171. if (kDeletionCallback != nullptr)
  172. kDeletionCallback->jackCVPortDeleted(this);
  173. }
  174. void initBuffer() noexcept override
  175. {
  176. if (fJackPort == nullptr)
  177. return CarlaEngineCVPort::initBuffer();
  178. const uint32_t bufferSize(kClient.getEngine().getBufferSize());
  179. try {
  180. fBuffer = (float*)jackbridge_port_get_buffer(fJackPort, bufferSize);
  181. }
  182. catch(...) {
  183. fBuffer = nullptr;
  184. return;
  185. }
  186. if (! kIsInput)
  187. FloatVectorOperations::clear(fBuffer, static_cast<int>(bufferSize));
  188. }
  189. void invalidate() noexcept
  190. {
  191. fJackClient = nullptr;
  192. fJackPort = nullptr;
  193. }
  194. private:
  195. jack_client_t* fJackClient;
  196. jack_port_t* fJackPort;
  197. JackPortDeletionCallback* const kDeletionCallback;
  198. friend class CarlaEngineJackClient;
  199. CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaEngineJackCVPort)
  200. };
  201. // -----------------------------------------------------------------------
  202. // Carla Engine JACK-Event port
  203. class CarlaEngineJackEventPort : public CarlaEngineEventPort
  204. {
  205. public:
  206. CarlaEngineJackEventPort(const CarlaEngineClient& client, const bool isInputPort, const uint32_t indexOffset, jack_client_t* const jackClient, jack_port_t* const jackPort, JackPortDeletionCallback* const delCallback) noexcept
  207. : CarlaEngineEventPort(client, isInputPort, indexOffset),
  208. fJackClient(jackClient),
  209. fJackPort(jackPort),
  210. fJackBuffer(nullptr),
  211. fRetEvent(kFallbackJackEngineEvent),
  212. kDeletionCallback(delCallback)
  213. {
  214. carla_debug("CarlaEngineJackEventPort::CarlaEngineJackEventPort(%s, %p, %p)", bool2str(isInputPort), jackClient, jackPort);
  215. switch (kClient.getEngine().getProccessMode())
  216. {
  217. case ENGINE_PROCESS_MODE_SINGLE_CLIENT:
  218. case ENGINE_PROCESS_MODE_MULTIPLE_CLIENTS:
  219. CARLA_SAFE_ASSERT_RETURN(jackClient != nullptr && jackPort != nullptr,);
  220. break;
  221. default:
  222. CARLA_SAFE_ASSERT(jackClient == nullptr && jackPort == nullptr);
  223. break;
  224. }
  225. }
  226. ~CarlaEngineJackEventPort() noexcept override
  227. {
  228. carla_debug("CarlaEngineJackEventPort::~CarlaEngineJackEventPort()");
  229. if (fJackClient != nullptr && fJackPort != nullptr)
  230. {
  231. try {
  232. jackbridge_port_unregister(fJackClient, fJackPort);
  233. } CARLA_SAFE_EXCEPTION("Event port unregister");
  234. fJackClient = nullptr;
  235. fJackPort = nullptr;
  236. }
  237. if (kDeletionCallback != nullptr)
  238. kDeletionCallback->jackEventPortDeleted(this);
  239. }
  240. void initBuffer() noexcept override
  241. {
  242. if (fJackPort == nullptr)
  243. return CarlaEngineEventPort::initBuffer();
  244. try {
  245. fJackBuffer = jackbridge_port_get_buffer(fJackPort, kClient.getEngine().getBufferSize());
  246. }
  247. catch(...) {
  248. fJackBuffer = nullptr;
  249. return;
  250. }
  251. if (! kIsInput)
  252. jackbridge_midi_clear_buffer(fJackBuffer);
  253. }
  254. uint32_t getEventCount() const noexcept override
  255. {
  256. if (fJackPort == nullptr)
  257. return CarlaEngineEventPort::getEventCount();
  258. CARLA_SAFE_ASSERT_RETURN(kIsInput, 0);
  259. CARLA_SAFE_ASSERT_RETURN(fJackBuffer != nullptr, 0);
  260. try {
  261. return jackbridge_midi_get_event_count(fJackBuffer);
  262. } CARLA_SAFE_EXCEPTION_RETURN("jack_midi_get_event_count", 0);
  263. }
  264. const EngineEvent& getEvent(const uint32_t index) const noexcept override
  265. {
  266. if (fJackPort == nullptr)
  267. return CarlaEngineEventPort::getEvent(index);
  268. CARLA_SAFE_ASSERT_RETURN(kIsInput, kFallbackJackEngineEvent);
  269. CARLA_SAFE_ASSERT_RETURN(fJackBuffer != nullptr, kFallbackJackEngineEvent);
  270. return getEventUnchecked(index);
  271. }
  272. const EngineEvent& getEventUnchecked(const uint32_t index) const noexcept override
  273. {
  274. jack_midi_event_t jackEvent;
  275. bool test = false;
  276. try {
  277. test = jackbridge_midi_event_get(&jackEvent, fJackBuffer, index);
  278. } CARLA_SAFE_EXCEPTION_RETURN("jack_midi_event_get", kFallbackJackEngineEvent);
  279. if (! test)
  280. return kFallbackJackEngineEvent;
  281. CARLA_SAFE_ASSERT_RETURN(jackEvent.size < 0xFF /* uint8_t max */, kFallbackJackEngineEvent);
  282. uint8_t port;
  283. if (kIndexOffset < 0xFF /* uint8_t max */)
  284. {
  285. port = static_cast<uint8_t>(kIndexOffset);
  286. }
  287. else
  288. {
  289. port = 0;
  290. carla_safe_assert_uint("kIndexOffset < 0xFF", __FILE__, __LINE__, kIndexOffset);
  291. }
  292. fRetEvent.time = jackEvent.time;
  293. fRetEvent.fillFromMidiData(static_cast<uint8_t>(jackEvent.size), jackEvent.buffer, port);
  294. return fRetEvent;
  295. }
  296. bool writeControlEvent(const uint32_t time, const uint8_t channel, const EngineControlEventType type, const uint16_t param, const float value) noexcept override
  297. {
  298. if (fJackPort == nullptr)
  299. return CarlaEngineEventPort::writeControlEvent(time, channel, type, param, value);
  300. CARLA_SAFE_ASSERT_RETURN(! kIsInput, false);
  301. CARLA_SAFE_ASSERT_RETURN(fJackBuffer != nullptr, false);
  302. CARLA_SAFE_ASSERT_RETURN(type != kEngineControlEventTypeNull, false);
  303. CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS, false);
  304. CARLA_SAFE_ASSERT_RETURN(param < MAX_MIDI_CONTROL, false);
  305. CARLA_SAFE_ASSERT(value >= 0.0f && value <= 1.0f);
  306. if (type == kEngineControlEventTypeParameter) {
  307. CARLA_SAFE_ASSERT(! MIDI_IS_CONTROL_BANK_SELECT(param));
  308. }
  309. uint8_t size = 0;
  310. uint8_t data[3] = { 0, 0, 0 };
  311. EngineControlEvent ctrlEvent = { type, param, value };
  312. ctrlEvent.convertToMidiData(channel, size, data);
  313. if (size == 0)
  314. return false;
  315. try {
  316. return jackbridge_midi_event_write(fJackBuffer, time, data, size);
  317. } CARLA_SAFE_EXCEPTION_RETURN("jack_midi_event_write", false);
  318. }
  319. bool writeMidiEvent(const uint32_t time, const uint8_t channel, const uint8_t size, const uint8_t* const data) noexcept override
  320. {
  321. if (fJackPort == nullptr)
  322. return CarlaEngineEventPort::writeMidiEvent(time, channel, size, data);
  323. CARLA_SAFE_ASSERT_RETURN(! kIsInput, false);
  324. CARLA_SAFE_ASSERT_RETURN(fJackBuffer != nullptr, false);
  325. CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS, false);
  326. CARLA_SAFE_ASSERT_RETURN(size > 0, false);
  327. CARLA_SAFE_ASSERT_RETURN(data != nullptr, false);
  328. jack_midi_data_t jdata[size];
  329. jdata[0] = static_cast<jack_midi_data_t>(MIDI_GET_STATUS_FROM_DATA(data) + channel);
  330. for (uint8_t i=1; i < size; ++i)
  331. jdata[i] = data[i];
  332. try {
  333. return jackbridge_midi_event_write(fJackBuffer, time, jdata, size);
  334. } CARLA_SAFE_EXCEPTION_RETURN("jack_midi_event_write", false);
  335. }
  336. void invalidate() noexcept
  337. {
  338. fJackClient = nullptr;
  339. fJackPort = nullptr;
  340. }
  341. private:
  342. jack_client_t* fJackClient;
  343. jack_port_t* fJackPort;
  344. void* fJackBuffer;
  345. mutable EngineEvent fRetEvent;
  346. JackPortDeletionCallback* const kDeletionCallback;
  347. friend class CarlaEngineJackClient;
  348. CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaEngineJackEventPort)
  349. };
  350. // -----------------------------------------------------------------------
  351. // Jack Engine client
  352. class CarlaEngineJackClient : public CarlaEngineClient,
  353. private JackPortDeletionCallback
  354. {
  355. public:
  356. CarlaEngineJackClient(const CarlaEngine& engine, jack_client_t* const jackClient)
  357. : CarlaEngineClient(engine),
  358. fJackClient(jackClient),
  359. fUseClient(engine.getProccessMode() == ENGINE_PROCESS_MODE_SINGLE_CLIENT || engine.getProccessMode() == ENGINE_PROCESS_MODE_MULTIPLE_CLIENTS),
  360. fAudioPorts(),
  361. fCVPorts(),
  362. fEventPorts(),
  363. fPreRenameMutex(),
  364. fPreRenameConnections()
  365. {
  366. carla_debug("CarlaEngineJackClient::CarlaEngineJackClient(%p)", jackClient);
  367. if (fUseClient)
  368. {
  369. CARLA_SAFE_ASSERT(jackClient != nullptr);
  370. }
  371. else
  372. {
  373. CARLA_SAFE_ASSERT(jackClient == nullptr);
  374. }
  375. }
  376. ~CarlaEngineJackClient() noexcept override
  377. {
  378. carla_debug("CarlaEngineJackClient::~CarlaEngineJackClient()");
  379. if (getProcessMode() == ENGINE_PROCESS_MODE_MULTIPLE_CLIENTS && fJackClient != nullptr) // FIXME
  380. jackbridge_client_close(fJackClient);
  381. // ports must have been deleted by now!
  382. //fAudioPorts.clear();
  383. //fCVPorts.clear();
  384. //fEventPorts.clear();
  385. }
  386. void activate() noexcept override
  387. {
  388. carla_debug("CarlaEngineJackClient::activate()");
  389. if (getProcessMode() == ENGINE_PROCESS_MODE_MULTIPLE_CLIENTS)
  390. {
  391. CARLA_SAFE_ASSERT_RETURN(fJackClient != nullptr && ! isActive(),);
  392. try {
  393. jackbridge_activate(fJackClient);
  394. } catch(...) {}
  395. }
  396. CarlaEngineClient::activate();
  397. const CarlaMutexLocker cml(fPreRenameMutex);
  398. if (fJackClient != nullptr)
  399. {
  400. // restore pre-rename connections
  401. const char* portNameA = nullptr;
  402. const char* portNameB = nullptr;
  403. bool doConnection = false;
  404. for (CarlaStringList::Itenerator it = fPreRenameConnections.begin2(); it.valid(); it.next())
  405. {
  406. const bool connectNow = doConnection;
  407. doConnection = !doConnection;
  408. if (connectNow)
  409. portNameB = it.getValue(nullptr);
  410. else
  411. portNameA = it.getValue(nullptr);
  412. if (! connectNow)
  413. continue;
  414. CARLA_SAFE_ASSERT_CONTINUE(portNameA != nullptr && portNameA[0] != '\0');
  415. CARLA_SAFE_ASSERT_CONTINUE(portNameB != nullptr && portNameB[0] != '\0');
  416. jackbridge_connect(fJackClient, portNameA, portNameB);
  417. }
  418. }
  419. fPreRenameConnections.clear();
  420. }
  421. void deactivate() noexcept override
  422. {
  423. carla_debug("CarlaEngineJackClient::deactivate()");
  424. if (getProcessMode() == ENGINE_PROCESS_MODE_MULTIPLE_CLIENTS)
  425. {
  426. CARLA_SAFE_ASSERT_RETURN(fJackClient != nullptr && isActive(),);
  427. try {
  428. jackbridge_deactivate(fJackClient);
  429. } catch(...) {}
  430. }
  431. CarlaEngineClient::deactivate();
  432. }
  433. bool isOk() const noexcept override
  434. {
  435. if (fUseClient)
  436. return (fJackClient != nullptr);
  437. return CarlaEngineClient::isOk();
  438. }
  439. CarlaEnginePort* addPort(const EnginePortType portType, const char* const name, const bool isInput, const uint32_t indexOffset) override
  440. {
  441. carla_debug("CarlaEngineJackClient::addPort(%i:%s, \"%s\", %s)", portType, EnginePortType2Str(portType), name, bool2str(isInput));
  442. jack_port_t* jackPort = nullptr;
  443. const char* realName = name;
  444. // Create JACK port first, if needed
  445. if (fUseClient)
  446. {
  447. CARLA_SAFE_ASSERT_RETURN(fJackClient != nullptr, nullptr);
  448. realName = _getUniquePortName(name);
  449. switch (portType)
  450. {
  451. case kEnginePortTypeNull:
  452. break;
  453. case kEnginePortTypeAudio:
  454. jackPort = jackbridge_port_register(fJackClient, realName, JACK_DEFAULT_AUDIO_TYPE, isInput ? JackPortIsInput : JackPortIsOutput, 0);
  455. break;
  456. case kEnginePortTypeCV:
  457. jackPort = jackbridge_port_register(fJackClient, realName, JACK_DEFAULT_AUDIO_TYPE, isInput ? JackPortIsInput : JackPortIsOutput, 0);
  458. break;
  459. case kEnginePortTypeEvent:
  460. jackPort = jackbridge_port_register(fJackClient, realName, JACK_DEFAULT_MIDI_TYPE, isInput ? JackPortIsInput : JackPortIsOutput, 0);
  461. break;
  462. }
  463. CARLA_SAFE_ASSERT_RETURN(jackPort != nullptr, nullptr);
  464. }
  465. // Create Engine port
  466. switch (portType)
  467. {
  468. case kEnginePortTypeNull:
  469. break;
  470. case kEnginePortTypeAudio: {
  471. _addAudioPortName(isInput, realName);
  472. if (realName != name) delete[] realName;
  473. CarlaEngineJackAudioPort* const enginePort(new CarlaEngineJackAudioPort(*this, isInput, indexOffset, fJackClient, jackPort, this));
  474. fAudioPorts.append(enginePort);
  475. return enginePort;
  476. }
  477. case kEnginePortTypeCV: {
  478. _addCVPortName(isInput, realName);
  479. if (realName != name) delete[] realName;
  480. CarlaEngineJackCVPort* const enginePort(new CarlaEngineJackCVPort(*this, isInput, indexOffset, fJackClient, jackPort, this));
  481. fCVPorts.append(enginePort);
  482. return enginePort;
  483. }
  484. case kEnginePortTypeEvent: {
  485. _addEventPortName(isInput, realName);
  486. if (realName != name) delete[] realName;
  487. CarlaEngineJackEventPort* const enginePort(new CarlaEngineJackEventPort(*this, isInput, indexOffset, fJackClient, jackPort, this));
  488. fEventPorts.append(enginePort);
  489. return enginePort;
  490. }
  491. }
  492. carla_stderr("CarlaEngineJackClient::addPort(%i, \"%s\", %s) - invalid type", portType, name, bool2str(isInput));
  493. return nullptr;
  494. }
  495. void invalidate() noexcept
  496. {
  497. for (LinkedList<CarlaEngineJackAudioPort*>::Itenerator it = fAudioPorts.begin2(); it.valid(); it.next())
  498. {
  499. CarlaEngineJackAudioPort* const port(it.getValue(nullptr));
  500. CARLA_SAFE_ASSERT_CONTINUE(port != nullptr);
  501. port->invalidate();
  502. }
  503. for (LinkedList<CarlaEngineJackCVPort*>::Itenerator it = fCVPorts.begin2(); it.valid(); it.next())
  504. {
  505. CarlaEngineJackCVPort* const port(it.getValue(nullptr));
  506. CARLA_SAFE_ASSERT_CONTINUE(port != nullptr);
  507. port->invalidate();
  508. }
  509. for (LinkedList<CarlaEngineJackEventPort*>::Itenerator it = fEventPorts.begin2(); it.valid(); it.next())
  510. {
  511. CarlaEngineJackEventPort* const port(it.getValue(nullptr));
  512. CARLA_SAFE_ASSERT_CONTINUE(port != nullptr);
  513. port->invalidate();
  514. }
  515. fJackClient = nullptr;
  516. CarlaEngineClient::deactivate();
  517. }
  518. const char* getJackClientName() const noexcept
  519. {
  520. CARLA_SAFE_ASSERT_RETURN(fJackClient != nullptr, nullptr);
  521. try {
  522. return jackbridge_get_client_name(fJackClient);
  523. } CARLA_SAFE_EXCEPTION_RETURN("jack_get_client_name", nullptr);
  524. }
  525. void jackAudioPortDeleted(CarlaEngineJackAudioPort* const port) noexcept override
  526. {
  527. fAudioPorts.removeAll(port);
  528. }
  529. void jackCVPortDeleted(CarlaEngineJackCVPort* const port) noexcept override
  530. {
  531. fCVPorts.removeAll(port);
  532. }
  533. void jackEventPortDeleted(CarlaEngineJackEventPort* const port) noexcept override
  534. {
  535. fEventPorts.removeAll(port);
  536. }
  537. bool renameInSingleClient(const CarlaString& newClientName)
  538. {
  539. const CarlaString clientNamePrefix(newClientName + ":");
  540. return _renamePorts(fAudioPorts, clientNamePrefix) &&
  541. _renamePorts(fCVPorts, clientNamePrefix) &&
  542. _renamePorts(fEventPorts, clientNamePrefix);
  543. }
  544. void closeForRename(jack_client_t* const newClient, const CarlaString& newClientName) noexcept
  545. {
  546. if (fJackClient != nullptr)
  547. {
  548. if (isActive())
  549. {
  550. {
  551. const CarlaString clientNamePrefix(newClientName + ":");
  552. // store current client connections
  553. const CarlaMutexLocker cml(fPreRenameMutex);
  554. fPreRenameConnections.clear();
  555. _savePortsConnections(fAudioPorts, clientNamePrefix);
  556. _savePortsConnections(fCVPorts, clientNamePrefix);
  557. _savePortsConnections(fEventPorts, clientNamePrefix);
  558. }
  559. try {
  560. jackbridge_deactivate(fJackClient);
  561. } catch(...) {}
  562. }
  563. try {
  564. jackbridge_client_close(fJackClient);
  565. } catch(...) {}
  566. invalidate();
  567. }
  568. fAudioPorts.clear();
  569. fCVPorts.clear();
  570. fEventPorts.clear();
  571. _clearPorts();
  572. fJackClient = newClient;
  573. }
  574. private:
  575. jack_client_t* fJackClient;
  576. const bool fUseClient;
  577. LinkedList<CarlaEngineJackAudioPort*> fAudioPorts;
  578. LinkedList<CarlaEngineJackCVPort*> fCVPorts;
  579. LinkedList<CarlaEngineJackEventPort*> fEventPorts;
  580. CarlaMutex fPreRenameMutex;
  581. CarlaStringList fPreRenameConnections;
  582. template<typename T>
  583. bool _renamePorts(const LinkedList<T*>& t, const CarlaString& clientNamePrefix)
  584. {
  585. for (typename LinkedList<T*>::Itenerator it = t.begin2(); it.valid(); it.next())
  586. {
  587. T* const port(it.getValue(nullptr));
  588. CARLA_SAFE_ASSERT_CONTINUE(port != nullptr);
  589. CARLA_SAFE_ASSERT_CONTINUE(port->fJackPort != nullptr);
  590. const char* shortPortName(jackbridge_port_short_name(port->fJackPort));
  591. CARLA_SAFE_ASSERT_CONTINUE(shortPortName != nullptr && shortPortName[0] != '\0');
  592. const char* const oldClientNameSep(std::strstr(shortPortName, ":"));
  593. CARLA_SAFE_ASSERT_CONTINUE(oldClientNameSep != nullptr && oldClientNameSep[0] != '\0' && oldClientNameSep[1] != '\0');
  594. shortPortName += oldClientNameSep-shortPortName + 1;
  595. const CarlaString newPortName(clientNamePrefix + shortPortName);
  596. if (! jackbridge_port_rename(fJackClient, port->fJackPort, newPortName))
  597. return false;
  598. }
  599. return true;
  600. }
  601. template<typename T>
  602. void _savePortsConnections(const LinkedList<T*>& t, const CarlaString& clientNamePrefix)
  603. {
  604. for (typename LinkedList<T*>::Itenerator it = t.begin2(); it.valid(); it.next())
  605. {
  606. T* const port(it.getValue(nullptr));
  607. CARLA_SAFE_ASSERT_CONTINUE(port != nullptr);
  608. CARLA_SAFE_ASSERT_CONTINUE(port->fJackPort != nullptr);
  609. const char* const shortPortName(jackbridge_port_short_name(port->fJackPort));
  610. CARLA_SAFE_ASSERT_CONTINUE(shortPortName != nullptr && shortPortName[0] != '\0');
  611. const CarlaString portName(clientNamePrefix + shortPortName);
  612. if (const char** const connections = jackbridge_port_get_all_connections(fJackClient, port->fJackPort))
  613. {
  614. for (int i=0; connections[i] != nullptr; ++i)
  615. {
  616. if (port->kIsInput)
  617. {
  618. fPreRenameConnections.append(connections[i]);
  619. fPreRenameConnections.append(portName);
  620. }
  621. else
  622. {
  623. fPreRenameConnections.append(portName);
  624. fPreRenameConnections.append(connections[i]);
  625. }
  626. }
  627. jackbridge_free(connections);
  628. }
  629. }
  630. }
  631. CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaEngineJackClient)
  632. };
  633. // -----------------------------------------------------------------------
  634. // Jack Engine
  635. class CarlaEngineJack : public CarlaEngine
  636. #ifndef BUILD_BRIDGE
  637. , private CarlaThread
  638. #endif
  639. {
  640. public:
  641. CarlaEngineJack()
  642. : CarlaEngine(),
  643. #ifndef BUILD_BRIDGE
  644. CarlaThread("CarlaEngineJackCallbacks"),
  645. #endif
  646. fClient(nullptr),
  647. fFreewheel(false),
  648. #ifdef BUILD_BRIDGE
  649. fIsRunning(false)
  650. #else
  651. fTimebaseMaster(false),
  652. fUsedGroups(),
  653. fUsedPorts(),
  654. fUsedConnections(),
  655. fNewGroups(),
  656. fRetConns(),
  657. fPostPonedEvents(),
  658. fPostPonedEventsMutex()
  659. #endif
  660. {
  661. carla_debug("CarlaEngineJack::CarlaEngineJack()");
  662. #ifdef BUILD_BRIDGE
  663. pData->options.processMode = ENGINE_PROCESS_MODE_MULTIPLE_CLIENTS;
  664. #else
  665. carla_zeroPointers(fRackPorts, kRackPortCount);
  666. #endif
  667. }
  668. ~CarlaEngineJack() noexcept override
  669. {
  670. carla_debug("CarlaEngineJack::~CarlaEngineJack()");
  671. CARLA_SAFE_ASSERT(fClient == nullptr);
  672. #ifndef BUILD_BRIDGE
  673. fUsedGroups.clear();
  674. fUsedPorts.clear();
  675. fUsedConnections.clear();
  676. fNewGroups.clear();
  677. CARLA_SAFE_ASSERT(fPostPonedEvents.count() == 0);
  678. #endif
  679. }
  680. // -------------------------------------------------------------------
  681. // Maximum values
  682. uint getMaxClientNameSize() const noexcept override
  683. {
  684. #ifndef BUILD_BRIDGE
  685. if (pData->options.processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT || pData->options.processMode == ENGINE_PROCESS_MODE_MULTIPLE_CLIENTS)
  686. #endif
  687. {
  688. try {
  689. return static_cast<uint>(jackbridge_client_name_size()-1);
  690. } CARLA_SAFE_EXCEPTION_RETURN("jack_client_name_size", 32);
  691. }
  692. return CarlaEngine::getMaxClientNameSize();
  693. }
  694. uint getMaxPortNameSize() const noexcept override
  695. {
  696. if (pData->options.processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT || pData->options.processMode == ENGINE_PROCESS_MODE_MULTIPLE_CLIENTS)
  697. {
  698. try {
  699. return static_cast<uint>(jackbridge_port_name_size()-1);
  700. } CARLA_SAFE_EXCEPTION_RETURN("jack_port_name_size", 255);
  701. }
  702. return CarlaEngine::getMaxPortNameSize();
  703. }
  704. // -------------------------------------------------------------------
  705. // Virtual, per-engine type calls
  706. bool init(const char* const clientName) override
  707. {
  708. CARLA_SAFE_ASSERT_RETURN(fClient == nullptr, false);
  709. CARLA_SAFE_ASSERT_RETURN(clientName != nullptr && clientName[0] != '\0', false);
  710. CARLA_SAFE_ASSERT_RETURN(jackbridge_is_ok(), false);
  711. carla_debug("CarlaEngineJack::init(\"%s\")", clientName);
  712. fFreewheel = false;
  713. CarlaString truncatedClientName(clientName);
  714. truncatedClientName.truncate(getMaxClientNameSize());
  715. #ifdef BUILD_BRIDGE
  716. fIsRunning = true;
  717. if (! pData->init(truncatedClientName))
  718. {
  719. close();
  720. setLastError("Failed to init internal data");
  721. return false;
  722. }
  723. if (pData->bufferSize == 0 || carla_isEqual(pData->sampleRate, 0.0))
  724. {
  725. // open temp client to get initial buffer-size and sample-rate values
  726. if (jack_client_t* const tmpClient = jackbridge_client_open(truncatedClientName, JackNoStartServer, nullptr))
  727. {
  728. pData->bufferSize = jackbridge_get_buffer_size(tmpClient);
  729. pData->sampleRate = jackbridge_get_sample_rate(tmpClient);
  730. jackbridge_client_close(tmpClient);
  731. }
  732. else
  733. {
  734. close();
  735. setLastError("Failed to init temporary jack client");
  736. return false;
  737. }
  738. }
  739. return true;
  740. #else
  741. fClient = jackbridge_client_open(truncatedClientName, JackNullOption, nullptr);
  742. if (fClient == nullptr)
  743. {
  744. setLastError("Failed to create new JACK client");
  745. return false;
  746. }
  747. const char* const jackClientName(jackbridge_get_client_name(fClient));
  748. if (! pData->init(jackClientName))
  749. {
  750. jackbridge_client_close(fClient);
  751. fClient = nullptr;
  752. setLastError("Failed to init internal data");
  753. return false;
  754. }
  755. pData->bufferSize = jackbridge_get_buffer_size(fClient);
  756. pData->sampleRate = jackbridge_get_sample_rate(fClient);
  757. pData->initTime(pData->options.transportExtra);
  758. jackbridge_set_thread_init_callback(fClient, carla_jack_thread_init_callback, nullptr);
  759. jackbridge_set_buffer_size_callback(fClient, carla_jack_bufsize_callback, this);
  760. jackbridge_set_sample_rate_callback(fClient, carla_jack_srate_callback, this);
  761. jackbridge_set_freewheel_callback(fClient, carla_jack_freewheel_callback, this);
  762. jackbridge_set_latency_callback(fClient, carla_jack_latency_callback, this);
  763. jackbridge_set_process_callback(fClient, carla_jack_process_callback, this);
  764. jackbridge_on_shutdown(fClient, carla_jack_shutdown_callback, this);
  765. fTimebaseMaster = jackbridge_set_timebase_callback(fClient, true, carla_jack_timebase_callback, this);
  766. initJackPatchbay(jackClientName);
  767. jackbridge_set_client_registration_callback(fClient, carla_jack_client_registration_callback, this);
  768. jackbridge_set_port_registration_callback(fClient, carla_jack_port_registration_callback, this);
  769. jackbridge_set_port_connect_callback(fClient, carla_jack_port_connect_callback, this);
  770. jackbridge_set_port_rename_callback(fClient, carla_jack_port_rename_callback, this);
  771. if (pData->options.processMode == ENGINE_PROCESS_MODE_CONTINUOUS_RACK)
  772. {
  773. fRackPorts[kRackPortAudioIn1] = jackbridge_port_register(fClient, "audio-in1", JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0);
  774. fRackPorts[kRackPortAudioIn2] = jackbridge_port_register(fClient, "audio-in2", JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0);
  775. fRackPorts[kRackPortAudioOut1] = jackbridge_port_register(fClient, "audio-out1", JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0);
  776. fRackPorts[kRackPortAudioOut2] = jackbridge_port_register(fClient, "audio-out2", JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0);
  777. fRackPorts[kRackPortEventIn] = jackbridge_port_register(fClient, "events-in", JACK_DEFAULT_MIDI_TYPE, JackPortIsInput, 0);
  778. fRackPorts[kRackPortEventOut] = jackbridge_port_register(fClient, "events-out", JACK_DEFAULT_MIDI_TYPE, JackPortIsOutput, 0);
  779. // FIXME
  780. pData->graph.create(0, 0);
  781. }
  782. if (jackbridge_activate(fClient))
  783. {
  784. startThread();
  785. callback(ENGINE_CALLBACK_ENGINE_STARTED, 0, pData->options.processMode, pData->options.transportMode, 0.0f, getCurrentDriverName());
  786. return true;
  787. }
  788. if (pData->options.processMode == ENGINE_PROCESS_MODE_CONTINUOUS_RACK)
  789. pData->graph.destroy();
  790. pData->close();
  791. jackbridge_client_close(fClient);
  792. fClient = nullptr;
  793. setLastError("Failed to activate the JACK client");
  794. return false;
  795. #endif
  796. }
  797. bool close() override
  798. {
  799. carla_debug("CarlaEngineJack::close()");
  800. #ifdef BUILD_BRIDGE
  801. fClient = nullptr;
  802. fIsRunning = false;
  803. CarlaEngine::close();
  804. return true;
  805. #else
  806. stopThread(-1);
  807. fPostPonedEvents.clear();
  808. CARLA_SAFE_ASSERT_RETURN_ERR(fClient != nullptr, "JACK Client is null");
  809. // deactivate first
  810. const bool deactivated(jackbridge_deactivate(fClient));
  811. // clear engine data
  812. CarlaEngine::close();
  813. fUsedGroups.clear();
  814. fUsedPorts.clear();
  815. fUsedConnections.clear();
  816. fNewGroups.clear();
  817. fPostPonedEvents.clear();
  818. // clear rack/patchbay stuff
  819. if (pData->options.processMode == ENGINE_PROCESS_MODE_CONTINUOUS_RACK)
  820. {
  821. if (deactivated)
  822. {
  823. jackbridge_port_unregister(fClient, fRackPorts[kRackPortAudioIn1]);
  824. jackbridge_port_unregister(fClient, fRackPorts[kRackPortAudioIn2]);
  825. jackbridge_port_unregister(fClient, fRackPorts[kRackPortAudioOut1]);
  826. jackbridge_port_unregister(fClient, fRackPorts[kRackPortAudioOut2]);
  827. jackbridge_port_unregister(fClient, fRackPorts[kRackPortEventIn]);
  828. jackbridge_port_unregister(fClient, fRackPorts[kRackPortEventOut]);
  829. }
  830. carla_zeroPointers(fRackPorts, kRackPortCount);
  831. pData->graph.destroy();
  832. }
  833. // close client
  834. if (deactivated)
  835. jackbridge_client_close(fClient);
  836. fClient = nullptr;
  837. return true;
  838. #endif
  839. }
  840. bool isRunning() const noexcept override
  841. {
  842. #ifdef BUILD_BRIDGE
  843. return (fClient != nullptr || fIsRunning);
  844. #else
  845. return (fClient != nullptr);
  846. #endif
  847. }
  848. bool isOffline() const noexcept override
  849. {
  850. return fFreewheel;
  851. }
  852. EngineType getType() const noexcept override
  853. {
  854. return kEngineTypeJack;
  855. }
  856. const char* getCurrentDriverName() const noexcept override
  857. {
  858. return "JACK";
  859. }
  860. CarlaEngineClient* addClient(CarlaPlugin* const plugin) override
  861. {
  862. jack_client_t* client = nullptr;
  863. #ifndef BUILD_BRIDGE
  864. if (pData->options.processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)
  865. {
  866. client = fClient;
  867. }
  868. else if (pData->options.processMode == ENGINE_PROCESS_MODE_MULTIPLE_CLIENTS)
  869. #endif
  870. {
  871. client = jackbridge_client_open(plugin->getName(), JackNullOption, nullptr);
  872. CARLA_SAFE_ASSERT_RETURN(client != nullptr, nullptr);
  873. jackbridge_set_thread_init_callback(client, carla_jack_thread_init_callback, nullptr);
  874. #ifndef BUILD_BRIDGE
  875. jackbridge_set_latency_callback(client, carla_jack_latency_callback_plugin, plugin);
  876. jackbridge_set_process_callback(client, carla_jack_process_callback_plugin, plugin);
  877. jackbridge_on_shutdown(client, carla_jack_shutdown_callback_plugin, plugin);
  878. #else
  879. fClient = client;
  880. pData->bufferSize = jackbridge_get_buffer_size(client);
  881. pData->sampleRate = jackbridge_get_sample_rate(client);
  882. pData->initTime(nullptr);
  883. jackbridge_set_buffer_size_callback(client, carla_jack_bufsize_callback, this);
  884. jackbridge_set_sample_rate_callback(client, carla_jack_srate_callback, this);
  885. jackbridge_set_freewheel_callback(client, carla_jack_freewheel_callback, this);
  886. jackbridge_set_latency_callback(client, carla_jack_latency_callback, this);
  887. jackbridge_set_process_callback(client, carla_jack_process_callback, this);
  888. jackbridge_on_shutdown(client, carla_jack_shutdown_callback, this);
  889. #endif
  890. }
  891. return new CarlaEngineJackClient(*this, client);
  892. }
  893. #ifndef BUILD_BRIDGE
  894. const char* renamePlugin(const uint id, const char* const newName) override
  895. {
  896. if (pData->options.processMode == ENGINE_PROCESS_MODE_CONTINUOUS_RACK)
  897. return CarlaEngine::renamePlugin(id, newName);
  898. CARLA_SAFE_ASSERT_RETURN(pData->plugins != nullptr, nullptr);
  899. CARLA_SAFE_ASSERT_RETURN(pData->curPluginCount != 0, nullptr);
  900. CARLA_SAFE_ASSERT_RETURN(id < pData->curPluginCount, nullptr);
  901. CARLA_SAFE_ASSERT_RETURN(newName != nullptr && newName[0] != '\0', nullptr);
  902. CarlaPlugin* const plugin(pData->plugins[id].plugin);
  903. CARLA_SAFE_ASSERT_RETURN_ERRN(plugin != nullptr, "Could not find plugin to rename");
  904. CARLA_SAFE_ASSERT_RETURN_ERRN(plugin->getId() == id, "Invalid engine internal data");
  905. // before we stop the engine thread we might need to get the plugin data
  906. const bool needsReinit = (pData->options.processMode == ENGINE_PROCESS_MODE_MULTIPLE_CLIENTS);
  907. const CarlaStateSave* saveStatePtr = nullptr;
  908. if (needsReinit)
  909. {
  910. const CarlaStateSave& saveState(plugin->getStateSave());
  911. saveStatePtr = &saveState;
  912. }
  913. CarlaString uniqueName;
  914. try {
  915. const char* const tmpName = getUniquePluginName(newName);
  916. uniqueName = tmpName;
  917. delete[] tmpName;
  918. } CARLA_SAFE_EXCEPTION("JACK renamePlugin getUniquePluginName");
  919. if (uniqueName.isEmpty())
  920. {
  921. setLastError("Failed to request new unique plugin name");
  922. return nullptr;
  923. }
  924. const ScopedThreadStopper sts(this);
  925. // rename on client client mode, just rename the ports
  926. if (pData->options.processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)
  927. {
  928. CarlaEngineJackClient* const client((CarlaEngineJackClient*)plugin->getEngineClient());
  929. if (! client->renameInSingleClient(uniqueName))
  930. {
  931. setLastError("Failed to rename some JACK ports, does your JACK version support proper port renaming?");
  932. return nullptr;
  933. }
  934. }
  935. // rename in multiple client mode
  936. else if (pData->options.processMode == ENGINE_PROCESS_MODE_MULTIPLE_CLIENTS)
  937. {
  938. CarlaEngineJackClient* const client((CarlaEngineJackClient*)plugin->getEngineClient());
  939. // we should not be able to do this, jack really needs to allow client rename
  940. if (jack_client_t* const jackClient = jackbridge_client_open(uniqueName, JackNullOption, nullptr))
  941. {
  942. // get new client name
  943. uniqueName = jackbridge_get_client_name(jackClient);
  944. // close client
  945. client->closeForRename(jackClient, uniqueName);
  946. // disable plugin
  947. plugin->setEnabled(false);
  948. // set new client data
  949. jackbridge_set_latency_callback(jackClient, carla_jack_latency_callback_plugin, plugin);
  950. jackbridge_set_process_callback(jackClient, carla_jack_process_callback_plugin, plugin);
  951. jackbridge_on_shutdown(jackClient, carla_jack_shutdown_callback_plugin, plugin);
  952. // NOTE: jack1 locks up here
  953. if (jackbridge_get_version_string() != nullptr)
  954. jackbridge_set_thread_init_callback(jackClient, carla_jack_thread_init_callback, nullptr);
  955. /* The following code is because of a tricky situation.
  956. We cannot lock or do jack operations during jack callbacks on jack1. jack2 events are asynchronous.
  957. When we close the client jack will trigger unregister-port callbacks, which we handle on a separate thread ASAP.
  958. But before that happens we already registered a new client with the same ports (the "renamed" one),
  959. and at this point the port we receive during that callback is actually the new one from the new client..
  960. JACK2 seems to be reusing ports to save space, which is understandable.
  961. Anyway, this means we have to remove all our port-related data before the new client ports are created.
  962. (we also stop the separate jack-events thread to avoid any race conditions while modying our port data) */
  963. stopThread(-1);
  964. const uint groupId(fUsedGroups.getGroupId(plugin->getName()));
  965. if (groupId > 0)
  966. {
  967. for (LinkedList<PortNameToId>::Itenerator it = fUsedPorts.list.begin2(); it.valid(); it.next())
  968. {
  969. for (LinkedList<ConnectionToId>::Itenerator it2 = fUsedConnections.list.begin2(); it2.valid(); it2.next())
  970. {
  971. static ConnectionToId connectionFallback = { 0, 0, 0, 0, 0 };
  972. ConnectionToId& connectionToId = it2.getValue(connectionFallback);
  973. CARLA_SAFE_ASSERT_CONTINUE(connectionToId.id != 0);
  974. if (connectionToId.groupA != groupId && connectionToId.groupB != groupId)
  975. continue;
  976. callback(ENGINE_CALLBACK_PATCHBAY_CONNECTION_REMOVED, connectionToId.id, 0, 0, 0.0f, nullptr);
  977. fUsedConnections.list.remove(it2);
  978. }
  979. static PortNameToId portNameFallback = { 0, 0, { '\0' }, { '\0' } };
  980. PortNameToId& portNameToId(it.getValue(portNameFallback));
  981. CARLA_SAFE_ASSERT_CONTINUE(portNameToId.group != 0);
  982. if (portNameToId.group != groupId)
  983. continue;
  984. callback(ENGINE_CALLBACK_PATCHBAY_PORT_REMOVED, portNameToId.group, static_cast<int>(portNameToId.port), 0, 0.0f, nullptr);
  985. fUsedPorts.list.remove(it);
  986. }
  987. }
  988. startThread();
  989. }
  990. else
  991. {
  992. setLastError("Failed to create new JACK client");
  993. return nullptr;
  994. }
  995. }
  996. // Rename
  997. plugin->setName(uniqueName);
  998. if (needsReinit)
  999. {
  1000. // reload plugin to recreate its ports
  1001. plugin->reload();
  1002. plugin->loadStateSave(*saveStatePtr);
  1003. plugin->setEnabled(true);
  1004. }
  1005. return plugin->getName();
  1006. }
  1007. // -------------------------------------------------------------------
  1008. // Patchbay
  1009. bool patchbayConnect(const uint groupA, const uint portA, const uint groupB, const uint portB) override
  1010. {
  1011. CARLA_SAFE_ASSERT_RETURN(fClient != nullptr, false);
  1012. const char* const fullPortNameA = fUsedPorts.getFullPortName(groupA, portA);
  1013. CARLA_SAFE_ASSERT_RETURN(fullPortNameA != nullptr && fullPortNameA[0] != '\0', false);
  1014. const char* const fullPortNameB = fUsedPorts.getFullPortName(groupB, portB);
  1015. CARLA_SAFE_ASSERT_RETURN(fullPortNameB != nullptr && fullPortNameB[0] != '\0', false);
  1016. if (! jackbridge_connect(fClient, fullPortNameA, fullPortNameB))
  1017. {
  1018. setLastError("JACK operation failed");
  1019. return false;
  1020. }
  1021. return true;
  1022. }
  1023. bool patchbayDisconnect(const uint connectionId) override
  1024. {
  1025. CARLA_SAFE_ASSERT_RETURN(fClient != nullptr, false);
  1026. ConnectionToId connectionToId = { 0, 0, 0, 0, 0 };
  1027. {
  1028. const CarlaMutexLocker cml(fUsedConnections.mutex);
  1029. for (LinkedList<ConnectionToId>::Itenerator it = fUsedConnections.list.begin2(); it.valid(); it.next())
  1030. {
  1031. connectionToId = it.getValue(connectionToId);
  1032. CARLA_SAFE_ASSERT_CONTINUE(connectionToId.id != 0);
  1033. if (connectionToId.id == connectionId)
  1034. break;
  1035. }
  1036. }
  1037. if (connectionToId.id == 0 || connectionToId.id != connectionId)
  1038. {
  1039. setLastError("Failed to find the requested connection");
  1040. return false;
  1041. }
  1042. const char* const fullPortNameA = fUsedPorts.getFullPortName(connectionToId.groupA, connectionToId.portA);
  1043. CARLA_SAFE_ASSERT_RETURN(fullPortNameA != nullptr && fullPortNameA[0] != '\0', false);
  1044. const char* const fullPortNameB = fUsedPorts.getFullPortName(connectionToId.groupB, connectionToId.portB);
  1045. CARLA_SAFE_ASSERT_RETURN(fullPortNameB != nullptr && fullPortNameB[0] != '\0', false);
  1046. if (! jackbridge_disconnect(fClient, fullPortNameA, fullPortNameB))
  1047. {
  1048. setLastError("JACK operation failed");
  1049. return false;
  1050. }
  1051. return true;
  1052. }
  1053. bool patchbayRefresh() override
  1054. {
  1055. CARLA_SAFE_ASSERT_RETURN(fClient != nullptr, false);
  1056. fUsedGroups.clear();
  1057. fUsedPorts.clear();
  1058. fUsedConnections.clear();
  1059. fNewGroups.clear();
  1060. initJackPatchbay(jackbridge_get_client_name(fClient));
  1061. return true;
  1062. }
  1063. // -------------------------------------------------------------------
  1064. // Transport
  1065. void transportPlay() noexcept override
  1066. {
  1067. if (pData->options.transportMode == ENGINE_TRANSPORT_MODE_INTERNAL)
  1068. return CarlaEngine::transportPlay();
  1069. if (fClient != nullptr)
  1070. {
  1071. if ((pData->timeInfo.valid & EngineTimeInfo::kValidBBT) == 0x0)
  1072. {
  1073. // old timebase master no longer active, make ourselves master again
  1074. pData->time.setNeedsReset();
  1075. fTimebaseMaster = jackbridge_set_timebase_callback(fClient, true, carla_jack_timebase_callback, this);
  1076. }
  1077. try {
  1078. jackbridge_transport_start(fClient);
  1079. } catch(...) {}
  1080. }
  1081. }
  1082. void transportPause() noexcept override
  1083. {
  1084. if (pData->options.transportMode == ENGINE_TRANSPORT_MODE_INTERNAL)
  1085. return CarlaEngine::transportPause();
  1086. if (fClient != nullptr)
  1087. {
  1088. try {
  1089. jackbridge_transport_stop(fClient);
  1090. } catch(...) {}
  1091. }
  1092. }
  1093. void transportBPM(const double bpm) noexcept override
  1094. {
  1095. CarlaEngine::transportBPM(bpm);
  1096. if (fClient == nullptr || fTimebaseMaster)
  1097. return;
  1098. jack_position_t jpos;
  1099. // invalidate
  1100. jpos.unique_1 = 1;
  1101. jpos.unique_2 = 2;
  1102. jackbridge_transport_query(fClient, &jpos);
  1103. if (jpos.unique_1 == jpos.unique_2 && (jpos.valid & JackPositionBBT) != 0)
  1104. {
  1105. carla_stdout("NOTE: Changing BPM without being JACK timebase master");
  1106. jpos.beats_per_minute = bpm;
  1107. try {
  1108. jackbridge_transport_reposition(fClient, &jpos);
  1109. } catch(...) {}
  1110. }
  1111. }
  1112. void transportRelocate(const uint64_t frame) noexcept override
  1113. {
  1114. if (pData->options.transportMode == ENGINE_TRANSPORT_MODE_INTERNAL)
  1115. return CarlaEngine::transportRelocate(frame);
  1116. if (fClient != nullptr)
  1117. {
  1118. try {
  1119. jackbridge_transport_locate(fClient, static_cast<jack_nframes_t>(frame));
  1120. } catch(...) {}
  1121. }
  1122. }
  1123. // -------------------------------------------------------------------
  1124. // Patchbay stuff
  1125. const char* const* getPatchbayConnections() const override
  1126. {
  1127. CARLA_SAFE_ASSERT_RETURN(fClient != nullptr, nullptr);
  1128. carla_debug("CarlaEngineJack::getPatchbayConnections()");
  1129. CarlaStringList connList;
  1130. if (const char** const ports = jackbridge_get_ports(fClient, nullptr, nullptr, JackPortIsOutput))
  1131. {
  1132. for (int i=0; ports[i] != nullptr; ++i)
  1133. {
  1134. const jack_port_t* const jackPort(jackbridge_port_by_name(fClient, ports[i]));
  1135. const char* const fullPortName(ports[i]);
  1136. CARLA_SAFE_ASSERT_CONTINUE(jackPort != nullptr);
  1137. if (const char** const connections = jackbridge_port_get_all_connections(fClient, jackPort))
  1138. {
  1139. for (int j=0; connections[j] != nullptr; ++j)
  1140. {
  1141. connList.append(fullPortName);
  1142. connList.append(connections[j]);
  1143. }
  1144. jackbridge_free(connections);
  1145. }
  1146. }
  1147. jackbridge_free(ports);
  1148. }
  1149. if (connList.count() == 0)
  1150. return nullptr;
  1151. fRetConns = connList.toCharStringListPtr();
  1152. return fRetConns;
  1153. }
  1154. void restorePatchbayConnection(const char* const connSource, const char* const connTarget) override
  1155. {
  1156. CARLA_SAFE_ASSERT_RETURN(fClient != nullptr,);
  1157. CARLA_SAFE_ASSERT_RETURN(connSource != nullptr && connSource[0] != '\0',);
  1158. CARLA_SAFE_ASSERT_RETURN(connTarget != nullptr && connTarget[0] != '\0',);
  1159. carla_debug("CarlaEngineJack::restorePatchbayConnection(\"%s\", \"%s\")", connSource, connTarget);
  1160. if (const jack_port_t* const port = jackbridge_port_by_name(fClient, connSource))
  1161. {
  1162. if (jackbridge_port_by_name(fClient, connTarget) == nullptr)
  1163. return;
  1164. if (! jackbridge_port_connected_to(port, connTarget))
  1165. jackbridge_connect(fClient, connSource, connTarget);
  1166. }
  1167. }
  1168. #endif
  1169. // -------------------------------------------------------------------
  1170. protected:
  1171. void handleJackBufferSizeCallback(const uint32_t newBufferSize)
  1172. {
  1173. if (pData->bufferSize == newBufferSize)
  1174. return;
  1175. pData->bufferSize = newBufferSize;
  1176. bufferSizeChanged(newBufferSize);
  1177. }
  1178. void handleJackSampleRateCallback(const double newSampleRate)
  1179. {
  1180. if (carla_isEqual(pData->sampleRate, newSampleRate))
  1181. return;
  1182. pData->sampleRate = newSampleRate;
  1183. sampleRateChanged(newSampleRate);
  1184. }
  1185. void handleJackFreewheelCallback(const bool isFreewheel)
  1186. {
  1187. if (fFreewheel == isFreewheel)
  1188. return;
  1189. fFreewheel = isFreewheel;
  1190. offlineModeChanged(isFreewheel);
  1191. }
  1192. void saveTransportInfo()
  1193. {
  1194. if (pData->options.transportMode != ENGINE_TRANSPORT_MODE_JACK)
  1195. return;
  1196. jack_position_t jpos;
  1197. // invalidate
  1198. jpos.unique_1 = 1;
  1199. jpos.unique_2 = 2;
  1200. pData->timeInfo.playing = (jackbridge_transport_query(fClient, &jpos) == JackTransportRolling);
  1201. if (jpos.unique_1 == jpos.unique_2)
  1202. {
  1203. pData->timeInfo.frame = jpos.frame;
  1204. pData->timeInfo.usecs = jpos.usecs;
  1205. if (jpos.valid & JackPositionBBT)
  1206. {
  1207. pData->timeInfo.valid = EngineTimeInfo::kValidBBT;
  1208. pData->timeInfo.bbt.bar = jpos.bar;
  1209. pData->timeInfo.bbt.beat = jpos.beat;
  1210. pData->timeInfo.bbt.tick = jpos.tick;
  1211. pData->timeInfo.bbt.barStartTick = jpos.bar_start_tick;
  1212. pData->timeInfo.bbt.beatsPerBar = jpos.beats_per_bar;
  1213. pData->timeInfo.bbt.beatType = jpos.beat_type;
  1214. pData->timeInfo.bbt.ticksPerBeat = jpos.ticks_per_beat;
  1215. pData->timeInfo.bbt.beatsPerMinute = jpos.beats_per_minute;
  1216. }
  1217. else
  1218. {
  1219. pData->timeInfo.valid = 0x0;
  1220. }
  1221. }
  1222. else
  1223. {
  1224. pData->timeInfo.frame = 0;
  1225. pData->timeInfo.valid = 0x0;
  1226. }
  1227. }
  1228. void handleJackProcessCallback(const uint32_t nframes)
  1229. {
  1230. const PendingRtEventsRunner prt(this, nframes);
  1231. CARLA_SAFE_ASSERT_RETURN(nframes == pData->bufferSize,);
  1232. saveTransportInfo();
  1233. #ifdef BUILD_BRIDGE
  1234. CarlaPlugin* const plugin(pData->plugins[0].plugin);
  1235. if (plugin != nullptr && plugin->isEnabled() && plugin->tryLock(fFreewheel))
  1236. {
  1237. plugin->initBuffers();
  1238. processPlugin(plugin, nframes);
  1239. plugin->unlock();
  1240. }
  1241. #else
  1242. if (pData->options.processMode == ENGINE_PROCESS_MODE_CONTINUOUS_RACK)
  1243. {
  1244. if (pData->aboutToClose)
  1245. {
  1246. if (float* const audioOut1 = (float*)jackbridge_port_get_buffer(fRackPorts[kRackPortAudioOut1], nframes))
  1247. FloatVectorOperations::clear(audioOut1, static_cast<int>(nframes));
  1248. if (float* const audioOut2 = (float*)jackbridge_port_get_buffer(fRackPorts[kRackPortAudioOut2], nframes))
  1249. FloatVectorOperations::clear(audioOut2, static_cast<int>(nframes));
  1250. }
  1251. else if (pData->curPluginCount == 0)
  1252. {
  1253. float* const audioIn1 = (float*)jackbridge_port_get_buffer(fRackPorts[kRackPortAudioIn1], nframes);
  1254. float* const audioIn2 = (float*)jackbridge_port_get_buffer(fRackPorts[kRackPortAudioIn2], nframes);
  1255. float* const audioOut1 = (float*)jackbridge_port_get_buffer(fRackPorts[kRackPortAudioOut1], nframes);
  1256. float* const audioOut2 = (float*)jackbridge_port_get_buffer(fRackPorts[kRackPortAudioOut2], nframes);
  1257. // assert buffers
  1258. CARLA_SAFE_ASSERT_RETURN(audioIn1 != nullptr,);
  1259. CARLA_SAFE_ASSERT_RETURN(audioIn2 != nullptr,);
  1260. CARLA_SAFE_ASSERT_RETURN(audioOut1 != nullptr,);
  1261. CARLA_SAFE_ASSERT_RETURN(audioOut2 != nullptr,);
  1262. // pass-through
  1263. FloatVectorOperations::copy(audioOut1, audioIn1, static_cast<int>(nframes));
  1264. FloatVectorOperations::copy(audioOut2, audioIn2, static_cast<int>(nframes));
  1265. // TODO pass-through MIDI as well
  1266. if (void* const eventOut = jackbridge_port_get_buffer(fRackPorts[kRackPortEventOut], nframes))
  1267. jackbridge_midi_clear_buffer(eventOut);
  1268. return;
  1269. }
  1270. }
  1271. if (pData->options.processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)
  1272. {
  1273. for (uint i=0; i < pData->curPluginCount; ++i)
  1274. {
  1275. CarlaPlugin* const plugin(pData->plugins[i].plugin);
  1276. if (plugin != nullptr && plugin->isEnabled() && plugin->tryLock(fFreewheel))
  1277. {
  1278. plugin->initBuffers();
  1279. processPlugin(plugin, nframes);
  1280. plugin->unlock();
  1281. }
  1282. }
  1283. }
  1284. else if (pData->options.processMode == ENGINE_PROCESS_MODE_CONTINUOUS_RACK)
  1285. {
  1286. CARLA_SAFE_ASSERT_RETURN(pData->events.in != nullptr,);
  1287. CARLA_SAFE_ASSERT_RETURN(pData->events.out != nullptr,);
  1288. // get buffers from jack
  1289. float* const audioIn1 = (float*)jackbridge_port_get_buffer(fRackPorts[kRackPortAudioIn1], nframes);
  1290. float* const audioIn2 = (float*)jackbridge_port_get_buffer(fRackPorts[kRackPortAudioIn2], nframes);
  1291. float* const audioOut1 = (float*)jackbridge_port_get_buffer(fRackPorts[kRackPortAudioOut1], nframes);
  1292. float* const audioOut2 = (float*)jackbridge_port_get_buffer(fRackPorts[kRackPortAudioOut2], nframes);
  1293. void* const eventIn = jackbridge_port_get_buffer(fRackPorts[kRackPortEventIn], nframes);
  1294. void* const eventOut = jackbridge_port_get_buffer(fRackPorts[kRackPortEventOut], nframes);
  1295. // assert buffers
  1296. CARLA_SAFE_ASSERT_RETURN(audioIn1 != nullptr,);
  1297. CARLA_SAFE_ASSERT_RETURN(audioIn2 != nullptr,);
  1298. CARLA_SAFE_ASSERT_RETURN(audioOut1 != nullptr,);
  1299. CARLA_SAFE_ASSERT_RETURN(audioOut2 != nullptr,);
  1300. // create audio buffers
  1301. const float* inBuf[2] = { audioIn1, audioIn2 };
  1302. /**/ float* outBuf[2] = { audioOut1, audioOut2 };
  1303. // initialize events
  1304. carla_zeroStructs(pData->events.in, kMaxEngineEventInternalCount);
  1305. carla_zeroStructs(pData->events.out, kMaxEngineEventInternalCount);
  1306. if (eventIn != nullptr)
  1307. {
  1308. ushort engineEventIndex = 0;
  1309. jack_midi_event_t jackEvent;
  1310. const uint32_t jackEventCount(jackbridge_midi_get_event_count(eventIn));
  1311. for (uint32_t jackEventIndex=0; jackEventIndex < jackEventCount; ++jackEventIndex)
  1312. {
  1313. if (! jackbridge_midi_event_get(&jackEvent, eventIn, jackEventIndex))
  1314. continue;
  1315. CARLA_SAFE_ASSERT_CONTINUE(jackEvent.size < 0xFF /* uint8_t max */);
  1316. EngineEvent& engineEvent(pData->events.in[engineEventIndex++]);
  1317. engineEvent.time = jackEvent.time;
  1318. engineEvent.fillFromMidiData(static_cast<uint8_t>(jackEvent.size), jackEvent.buffer, 0);
  1319. if (engineEventIndex >= kMaxEngineEventInternalCount)
  1320. break;
  1321. }
  1322. }
  1323. if (pData->options.processMode == ENGINE_PROCESS_MODE_CONTINUOUS_RACK)
  1324. pData->graph.processRack(pData, inBuf, outBuf, nframes);
  1325. else
  1326. pData->graph.process(pData, inBuf, outBuf, nframes);
  1327. // output control
  1328. if (eventOut != nullptr)
  1329. {
  1330. jackbridge_midi_clear_buffer(eventOut);
  1331. uint8_t size = 0;
  1332. uint8_t data[3] = { 0, 0, 0 };
  1333. const uint8_t* dataPtr = data;
  1334. for (ushort i=0; i < kMaxEngineEventInternalCount; ++i)
  1335. {
  1336. const EngineEvent& engineEvent(pData->events.out[i]);
  1337. if (engineEvent.type == kEngineEventTypeNull)
  1338. break;
  1339. else if (engineEvent.type == kEngineEventTypeControl)
  1340. {
  1341. const EngineControlEvent& ctrlEvent(engineEvent.ctrl);
  1342. ctrlEvent.convertToMidiData(engineEvent.channel, size, data);
  1343. dataPtr = data;
  1344. }
  1345. else if (engineEvent.type == kEngineEventTypeMidi)
  1346. {
  1347. const EngineMidiEvent& midiEvent(engineEvent.midi);
  1348. size = midiEvent.size;
  1349. if (size > EngineMidiEvent::kDataSize && midiEvent.dataExt != nullptr)
  1350. dataPtr = midiEvent.dataExt;
  1351. else
  1352. dataPtr = midiEvent.data;
  1353. }
  1354. else
  1355. {
  1356. continue;
  1357. }
  1358. if (size > 0)
  1359. jackbridge_midi_event_write(eventOut, engineEvent.time, dataPtr, size);
  1360. }
  1361. }
  1362. }
  1363. #endif // ! BUILD_BRIDGE
  1364. }
  1365. void handleJackLatencyCallback(const jack_latency_callback_mode_t /*mode*/)
  1366. {
  1367. // TODO
  1368. }
  1369. #ifndef BUILD_BRIDGE
  1370. void handleJackTimebaseCallback(jack_nframes_t nframes, jack_position_t* const pos, const int new_pos)
  1371. {
  1372. if (new_pos)
  1373. pData->time.setNeedsReset();
  1374. pData->time.fillJackTimeInfo(pos, nframes);
  1375. }
  1376. void handleJackClientRegistrationCallback(const char* const name, const bool reg)
  1377. {
  1378. CARLA_SAFE_ASSERT_RETURN(name != nullptr && name[0] != '\0',);
  1379. // do nothing on client registration, wait for first port
  1380. if (reg) return;
  1381. const uint groupId(fUsedGroups.getGroupId(name));
  1382. // clients might have been registered without ports
  1383. if (groupId == 0) return;
  1384. GroupNameToId groupNameToId;
  1385. groupNameToId.setData(groupId, name);
  1386. callback(ENGINE_CALLBACK_PATCHBAY_CLIENT_REMOVED, groupNameToId.group, 0, 0, 0.0f, nullptr);
  1387. fUsedGroups.list.removeOne(groupNameToId);
  1388. }
  1389. void handleJackPortRegistrationCallback(const jack_port_id_t port, const bool reg)
  1390. {
  1391. const jack_port_t* const jackPort(jackbridge_port_by_id(fClient, port));
  1392. CARLA_SAFE_ASSERT_RETURN(jackPort != nullptr,);
  1393. const char* const fullPortName(jackbridge_port_name(jackPort));
  1394. CARLA_SAFE_ASSERT_RETURN(fullPortName != nullptr && fullPortName[0] != '\0',);
  1395. if (reg)
  1396. {
  1397. const char* const shortPortName(jackbridge_port_short_name(jackPort));
  1398. CARLA_SAFE_ASSERT_RETURN(shortPortName != nullptr && shortPortName[0] != '\0',);
  1399. bool found;
  1400. CarlaString groupName(fullPortName);
  1401. groupName.truncate(groupName.rfind(shortPortName, &found)-1);
  1402. CARLA_SAFE_ASSERT_RETURN(found,);
  1403. const int jackPortFlags(jackbridge_port_flags(jackPort));
  1404. uint groupId(fUsedGroups.getGroupId(groupName));
  1405. if (groupId == 0)
  1406. {
  1407. groupId = ++fUsedGroups.lastId;
  1408. PatchbayIcon icon = (jackPortFlags & JackPortIsPhysical) ? PATCHBAY_ICON_HARDWARE : PATCHBAY_ICON_APPLICATION;
  1409. GroupNameToId groupNameToId;
  1410. groupNameToId.setData(groupId, groupName);
  1411. callback(ENGINE_CALLBACK_PATCHBAY_CLIENT_ADDED, groupNameToId.group, icon, -1, 0.0f, groupNameToId.name);
  1412. fNewGroups.append(groupId);
  1413. fUsedGroups.list.append(groupNameToId);
  1414. }
  1415. addPatchbayJackPort(groupId, jackPort, shortPortName, fullPortName, jackPortFlags);
  1416. }
  1417. else
  1418. {
  1419. const PortNameToId& portNameToId(fUsedPorts.getPortNameToId(fullPortName));
  1420. /* NOTE: Due to JACK2 async behaviour the port we get here might be the same of a previous rename-plugin request.
  1421. See the comment on CarlaEngineJack::renamePlugin() for more information. */
  1422. if (portNameToId.group <= 0 || portNameToId.port <= 0) return;
  1423. callback(ENGINE_CALLBACK_PATCHBAY_PORT_REMOVED, portNameToId.group, static_cast<int>(portNameToId.port), 0, 0.0f, nullptr);
  1424. fUsedPorts.list.removeOne(portNameToId);
  1425. }
  1426. }
  1427. void handleJackPortConnectCallback(const jack_port_id_t a, const jack_port_id_t b, const bool connect)
  1428. {
  1429. const jack_port_t* const jackPortA(jackbridge_port_by_id(fClient, a));
  1430. CARLA_SAFE_ASSERT_RETURN(jackPortA != nullptr,);
  1431. const jack_port_t* const jackPortB(jackbridge_port_by_id(fClient, b));
  1432. CARLA_SAFE_ASSERT_RETURN(jackPortB != nullptr,);
  1433. const char* const fullPortNameA(jackbridge_port_name(jackPortA));
  1434. CARLA_SAFE_ASSERT_RETURN(fullPortNameA != nullptr && fullPortNameA[0] != '\0',);
  1435. const char* const fullPortNameB(jackbridge_port_name(jackPortB));
  1436. CARLA_SAFE_ASSERT_RETURN(fullPortNameB != nullptr && fullPortNameB[0] != '\0',);
  1437. const PortNameToId& portNameToIdA(fUsedPorts.getPortNameToId(fullPortNameA));
  1438. const PortNameToId& portNameToIdB(fUsedPorts.getPortNameToId(fullPortNameB));
  1439. /* NOTE: Due to JACK2 async behaviour the port we get here might be the same of a previous rename-plugin request.
  1440. See the comment on CarlaEngineJack::renamePlugin() for more information. */
  1441. if (portNameToIdA.group <= 0 || portNameToIdA.port <= 0) return;
  1442. if (portNameToIdB.group <= 0 || portNameToIdB.port <= 0) return;
  1443. if (connect)
  1444. {
  1445. char strBuf[STR_MAX+1];
  1446. std::snprintf(strBuf, STR_MAX, "%i:%i:%i:%i", portNameToIdA.group, portNameToIdA.port, portNameToIdB.group, portNameToIdB.port);
  1447. strBuf[STR_MAX] = '\0';
  1448. ConnectionToId connectionToId;
  1449. connectionToId.setData(++fUsedConnections.lastId, portNameToIdA.group, portNameToIdA.port, portNameToIdB.group, portNameToIdB.port);
  1450. callback(ENGINE_CALLBACK_PATCHBAY_CONNECTION_ADDED, connectionToId.id, 0, 0, 0.0f, strBuf);
  1451. fUsedConnections.list.append(connectionToId);
  1452. }
  1453. else
  1454. {
  1455. ConnectionToId connectionToId = { 0, 0, 0, 0, 0 };
  1456. bool found = false;
  1457. {
  1458. const CarlaMutexLocker cml(fUsedConnections.mutex);
  1459. for (LinkedList<ConnectionToId>::Itenerator it = fUsedConnections.list.begin2(); it.valid(); it.next())
  1460. {
  1461. connectionToId = it.getValue(connectionToId);
  1462. CARLA_SAFE_ASSERT_CONTINUE(connectionToId.id != 0);
  1463. if (connectionToId.groupA == portNameToIdA.group && connectionToId.portA == portNameToIdA.port &&
  1464. connectionToId.groupB == portNameToIdB.group && connectionToId.portB == portNameToIdB.port)
  1465. {
  1466. found = true;
  1467. fUsedConnections.list.remove(it);
  1468. break;
  1469. }
  1470. }
  1471. }
  1472. if (found)
  1473. callback(ENGINE_CALLBACK_PATCHBAY_CONNECTION_REMOVED, connectionToId.id, 0, 0, 0.0f, nullptr);
  1474. }
  1475. }
  1476. void handleJackPortRenameCallback(const jack_port_id_t port, const char* const oldFullName, const char* const newFullName)
  1477. {
  1478. CARLA_SAFE_ASSERT_RETURN(oldFullName != nullptr && oldFullName[0] != '\0',);
  1479. CARLA_SAFE_ASSERT_RETURN(newFullName != nullptr && newFullName[0] != '\0',);
  1480. const jack_port_t* const jackPort(jackbridge_port_by_id(fClient, port));
  1481. CARLA_SAFE_ASSERT_RETURN(jackPort != nullptr,);
  1482. const char* const shortPortName(jackbridge_port_short_name(jackPort));
  1483. CARLA_SAFE_ASSERT_RETURN(shortPortName != nullptr && shortPortName[0] != '\0',);
  1484. bool found;
  1485. CarlaString groupName(newFullName);
  1486. groupName.truncate(groupName.rfind(shortPortName, &found)-1);
  1487. CARLA_SAFE_ASSERT_RETURN(found,);
  1488. const uint groupId(fUsedGroups.getGroupId(groupName));
  1489. CARLA_SAFE_ASSERT_RETURN(groupId > 0,);
  1490. for (LinkedList<PortNameToId>::Itenerator it = fUsedPorts.list.begin2(); it.valid(); it.next())
  1491. {
  1492. static PortNameToId portNameFallback = { 0, 0, { '\0' }, { '\0' } };
  1493. PortNameToId& portNameToId(it.getValue(portNameFallback));
  1494. CARLA_SAFE_ASSERT_CONTINUE(portNameToId.group != 0);
  1495. if (std::strncmp(portNameToId.fullName, oldFullName, STR_MAX) == 0)
  1496. {
  1497. CARLA_SAFE_ASSERT_CONTINUE(portNameToId.group == groupId);
  1498. portNameToId.rename(shortPortName, newFullName);
  1499. callback(ENGINE_CALLBACK_PATCHBAY_PORT_RENAMED, portNameToId.group, static_cast<int>(portNameToId.port), 0, 0.0f, portNameToId.name);
  1500. break;
  1501. }
  1502. }
  1503. }
  1504. #endif
  1505. void handleJackShutdownCallback()
  1506. {
  1507. #ifndef BUILD_BRIDGE
  1508. signalThreadShouldExit();
  1509. #endif
  1510. const PendingRtEventsRunner prt(this, pData->bufferSize);
  1511. for (uint i=0; i < pData->curPluginCount; ++i)
  1512. {
  1513. if (CarlaPlugin* const plugin = pData->plugins[i].plugin)
  1514. {
  1515. plugin->tryLock(true);
  1516. if (CarlaEngineJackClient* const client = (CarlaEngineJackClient*)plugin->getEngineClient())
  1517. client->invalidate();
  1518. plugin->unlock();
  1519. }
  1520. }
  1521. fClient = nullptr;
  1522. #ifndef BUILD_BRIDGE
  1523. carla_zeroPointers(fRackPorts, kRackPortCount);
  1524. #endif
  1525. callback(ENGINE_CALLBACK_QUIT, 0, 0, 0, 0.0f, nullptr);
  1526. }
  1527. // -------------------------------------------------------------------
  1528. void handlePluginJackShutdownCallback(CarlaPlugin* const plugin)
  1529. {
  1530. CarlaEngineJackClient* const engineClient((CarlaEngineJackClient*)plugin->getEngineClient());
  1531. CARLA_SAFE_ASSERT_RETURN(engineClient != nullptr,);
  1532. plugin->tryLock(true);
  1533. engineClient->invalidate();
  1534. plugin->unlock();
  1535. //if (pData->nextAction.pluginId == plugin->getId())
  1536. // pData->nextAction.clearAndReset();
  1537. callback(ENGINE_CALLBACK_PLUGIN_UNAVAILABLE, plugin->getId(), 0, 0, 0.0f, "Killed by JACK");
  1538. }
  1539. // -------------------------------------------------------------------
  1540. private:
  1541. jack_client_t* fClient;
  1542. bool fFreewheel;
  1543. // -------------------------------------------------------------------
  1544. #ifdef BUILD_BRIDGE
  1545. bool fIsRunning;
  1546. #else
  1547. enum RackPorts {
  1548. kRackPortAudioIn1 = 0,
  1549. kRackPortAudioIn2 = 1,
  1550. kRackPortAudioOut1 = 2,
  1551. kRackPortAudioOut2 = 3,
  1552. kRackPortEventIn = 4,
  1553. kRackPortEventOut = 5,
  1554. kRackPortCount = 6
  1555. };
  1556. jack_port_t* fRackPorts[kRackPortCount];
  1557. bool fTimebaseMaster;
  1558. PatchbayGroupList fUsedGroups;
  1559. PatchbayPortList fUsedPorts;
  1560. PatchbayConnectionList fUsedConnections;
  1561. LinkedList<uint> fNewGroups;
  1562. mutable CharStringListPtr fRetConns;
  1563. bool findPluginIdAndIcon(const char* const clientName, int& pluginId, PatchbayIcon& icon) noexcept
  1564. {
  1565. carla_debug("CarlaEngineJack::findPluginIdAndIcon(\"%s\", ...)", clientName);
  1566. // TODO - this currently only works in multi-client mode
  1567. if (pData->options.processMode != ENGINE_PROCESS_MODE_MULTIPLE_CLIENTS)
  1568. return false;
  1569. for (uint i=0; i < pData->curPluginCount; ++i)
  1570. {
  1571. CarlaPlugin* const plugin(pData->plugins[i].plugin);
  1572. if (plugin == nullptr || ! plugin->isEnabled())
  1573. continue;
  1574. const CarlaEngineJackClient* const engineClient((const CarlaEngineJackClient*)plugin->getEngineClient());
  1575. CARLA_SAFE_ASSERT_CONTINUE(engineClient != nullptr);
  1576. const char* const engineClientName(engineClient->getJackClientName());
  1577. CARLA_SAFE_ASSERT_CONTINUE(engineClientName != nullptr && engineClientName[0] != '\0');
  1578. if (std::strcmp(clientName, engineClientName) != 0)
  1579. continue;
  1580. pluginId = static_cast<int>(i);
  1581. icon = PATCHBAY_ICON_PLUGIN;
  1582. if (const char* const pluginIcon = plugin->getIconName())
  1583. {
  1584. if (pluginIcon[0] == '\0')
  1585. pass();
  1586. else if (std::strcmp(pluginIcon, "app") == 0 || std::strcmp(pluginIcon, "application") == 0)
  1587. icon = PATCHBAY_ICON_APPLICATION;
  1588. else if (std::strcmp(pluginIcon, "plugin") == 0)
  1589. icon = PATCHBAY_ICON_PLUGIN;
  1590. else if (std::strcmp(pluginIcon, "hardware") == 0)
  1591. icon = PATCHBAY_ICON_HARDWARE;
  1592. else if (std::strcmp(pluginIcon, "carla") == 0)
  1593. icon = PATCHBAY_ICON_CARLA;
  1594. else if (std::strcmp(pluginIcon, "distrho") == 0)
  1595. icon = PATCHBAY_ICON_DISTRHO;
  1596. else if (std::strcmp(pluginIcon, "file") == 0)
  1597. icon = PATCHBAY_ICON_FILE;
  1598. }
  1599. return true;
  1600. }
  1601. return false;
  1602. }
  1603. void initJackPatchbay(const char* const ourName)
  1604. {
  1605. CARLA_SAFE_ASSERT_RETURN(ourName != nullptr && ourName[0] != '\0',);
  1606. StringArray parsedGroups;
  1607. // add our client first
  1608. {
  1609. parsedGroups.add(String(ourName));
  1610. GroupNameToId groupNameToId;
  1611. groupNameToId.setData(++fUsedGroups.lastId, ourName);
  1612. callback(ENGINE_CALLBACK_PATCHBAY_CLIENT_ADDED, groupNameToId.group, PATCHBAY_ICON_CARLA, -1, 0.0f, groupNameToId.name);
  1613. fUsedGroups.list.append(groupNameToId);
  1614. }
  1615. // query all jack ports
  1616. if (const char** const ports = jackbridge_get_ports(fClient, nullptr, nullptr, 0))
  1617. {
  1618. for (int i=0; ports[i] != nullptr; ++i)
  1619. {
  1620. const char* const fullPortName(ports[i]);
  1621. CARLA_SAFE_ASSERT_CONTINUE(fullPortName != nullptr && fullPortName[0] != '\0');
  1622. const jack_port_t* const jackPort(jackbridge_port_by_name(fClient, fullPortName));
  1623. CARLA_SAFE_ASSERT_CONTINUE(jackPort != nullptr);
  1624. const char* const shortPortName(jackbridge_port_short_name(jackPort));
  1625. CARLA_SAFE_ASSERT_CONTINUE(shortPortName != nullptr && shortPortName[0] != '\0');
  1626. const int jackPortFlags(jackbridge_port_flags(jackPort));
  1627. uint groupId = 0;
  1628. bool found;
  1629. CarlaString groupName(fullPortName);
  1630. groupName.truncate(groupName.rfind(shortPortName, &found)-1);
  1631. CARLA_SAFE_ASSERT_CONTINUE(found);
  1632. String jGroupName(groupName.buffer());
  1633. if (parsedGroups.contains(jGroupName))
  1634. {
  1635. groupId = fUsedGroups.getGroupId(groupName);
  1636. CARLA_SAFE_ASSERT_CONTINUE(groupId > 0);
  1637. }
  1638. else
  1639. {
  1640. groupId = ++fUsedGroups.lastId;
  1641. parsedGroups.add(jGroupName);
  1642. int pluginId = -1;
  1643. PatchbayIcon icon = (jackPortFlags & JackPortIsPhysical) ? PATCHBAY_ICON_HARDWARE : PATCHBAY_ICON_APPLICATION;
  1644. findPluginIdAndIcon(groupName, pluginId, icon);
  1645. GroupNameToId groupNameToId;
  1646. groupNameToId.setData(groupId, groupName);
  1647. callback(ENGINE_CALLBACK_PATCHBAY_CLIENT_ADDED, groupNameToId.group, icon, pluginId, 0.0f, groupNameToId.name);
  1648. fUsedGroups.list.append(groupNameToId);
  1649. }
  1650. addPatchbayJackPort(groupId, jackPort, shortPortName, fullPortName, jackPortFlags);
  1651. }
  1652. jackbridge_free(ports);
  1653. }
  1654. // query connections, after all ports are in place
  1655. if (const char** const ports = jackbridge_get_ports(fClient, nullptr, nullptr, JackPortIsOutput))
  1656. {
  1657. char strBuf[STR_MAX+1];
  1658. for (int i=0; ports[i] != nullptr; ++i)
  1659. {
  1660. const char* const fullPortName(ports[i]);
  1661. CARLA_SAFE_ASSERT_CONTINUE(fullPortName != nullptr && fullPortName[0] != '\0');
  1662. const jack_port_t* const jackPort(jackbridge_port_by_name(fClient, fullPortName));
  1663. CARLA_SAFE_ASSERT_CONTINUE(jackPort != nullptr);
  1664. const PortNameToId& thisPort(fUsedPorts.getPortNameToId(fullPortName));
  1665. CARLA_SAFE_ASSERT_CONTINUE(thisPort.group > 0);
  1666. CARLA_SAFE_ASSERT_CONTINUE(thisPort.port > 0);
  1667. if (const char** const connections = jackbridge_port_get_all_connections(fClient, jackPort))
  1668. {
  1669. for (int j=0; connections[j] != nullptr; ++j)
  1670. {
  1671. const char* const connection(connections[j]);
  1672. CARLA_SAFE_ASSERT_CONTINUE(connection != nullptr && connection[0] != '\0');
  1673. const PortNameToId& targetPort(fUsedPorts.getPortNameToId(connection));
  1674. CARLA_SAFE_ASSERT_CONTINUE(targetPort.group > 0);
  1675. CARLA_SAFE_ASSERT_CONTINUE(targetPort.port > 0);
  1676. std::snprintf(strBuf, STR_MAX, "%i:%i:%i:%i", thisPort.group, thisPort.port, targetPort.group, targetPort.port);
  1677. strBuf[STR_MAX] = '\0';
  1678. ConnectionToId connectionToId;
  1679. connectionToId.setData(++fUsedConnections.lastId, thisPort.group, thisPort.port, targetPort.group, targetPort.port);
  1680. callback(ENGINE_CALLBACK_PATCHBAY_CONNECTION_ADDED, connectionToId.id, 0, 0, 0.0f, strBuf);
  1681. fUsedConnections.list.append(connectionToId);
  1682. }
  1683. jackbridge_free(connections);
  1684. }
  1685. }
  1686. jackbridge_free(ports);
  1687. }
  1688. }
  1689. void addPatchbayJackPort(const uint groupId, const jack_port_t* const jackPort, const char* const shortPortName, const char* const fullPortName, const int jackPortFlags)
  1690. {
  1691. bool portIsInput = (jackPortFlags & JackPortIsInput);
  1692. bool portIsAudio = (std::strcmp(jackbridge_port_type(jackPort), JACK_DEFAULT_AUDIO_TYPE) == 0);
  1693. bool portIsMIDI = (std::strcmp(jackbridge_port_type(jackPort), JACK_DEFAULT_MIDI_TYPE) == 0);
  1694. bool portIsCV = false;
  1695. bool portIsOSC = false;
  1696. if (const jack_uuid_t uuid = jackbridge_port_uuid(jackPort))
  1697. {
  1698. char* value = nullptr;
  1699. char* type = nullptr;
  1700. if (jackbridge_get_property(uuid, JACKEY_SIGNAL_TYPE, &value, &type) && value != nullptr && type != nullptr && std::strcmp(type, "text/plain") == 0)
  1701. {
  1702. portIsCV = (std::strcmp(value, "CV") == 0);
  1703. portIsOSC = (std::strcmp(value, "OSC") == 0);
  1704. }
  1705. }
  1706. uint canvasPortFlags = 0x0;
  1707. canvasPortFlags |= portIsInput ? PATCHBAY_PORT_IS_INPUT : 0x0;
  1708. if (portIsCV)
  1709. canvasPortFlags |= PATCHBAY_PORT_TYPE_CV;
  1710. else if (portIsAudio)
  1711. canvasPortFlags |= PATCHBAY_PORT_TYPE_AUDIO;
  1712. else if (portIsMIDI)
  1713. canvasPortFlags |= PATCHBAY_PORT_TYPE_MIDI;
  1714. PortNameToId portNameToId;
  1715. portNameToId.setData(groupId, ++fUsedPorts.lastId, shortPortName, fullPortName);
  1716. callback(ENGINE_CALLBACK_PATCHBAY_PORT_ADDED, portNameToId.group, static_cast<int>(portNameToId.port), static_cast<int>(canvasPortFlags), 0.0f, portNameToId.name);
  1717. fUsedPorts.list.append(portNameToId);
  1718. return; // unused
  1719. (void)portIsOSC;
  1720. }
  1721. #endif
  1722. // -------------------------------------------------------------------
  1723. void processPlugin(CarlaPlugin* const plugin, const uint32_t nframes)
  1724. {
  1725. const uint32_t audioInCount(plugin->getAudioInCount());
  1726. const uint32_t audioOutCount(plugin->getAudioOutCount());
  1727. const uint32_t cvInCount(plugin->getCVInCount());
  1728. const uint32_t cvOutCount(plugin->getCVOutCount());
  1729. const float* audioIn[audioInCount];
  1730. /* */ float* audioOut[audioOutCount];
  1731. const float* cvIn[cvInCount];
  1732. /* */ float* cvOut[cvOutCount];
  1733. for (uint32_t i=0; i < audioInCount; ++i)
  1734. {
  1735. CarlaEngineAudioPort* const port(plugin->getAudioInPort(i));
  1736. audioIn[i] = port->getBuffer();
  1737. }
  1738. for (uint32_t i=0; i < audioOutCount; ++i)
  1739. {
  1740. CarlaEngineAudioPort* const port(plugin->getAudioOutPort(i));
  1741. audioOut[i] = port->getBuffer();
  1742. }
  1743. for (uint32_t i=0; i < cvInCount; ++i)
  1744. {
  1745. CarlaEngineCVPort* const port(plugin->getCVInPort(i));
  1746. cvIn[i] = port->getBuffer();
  1747. }
  1748. for (uint32_t i=0; i < cvOutCount; ++i)
  1749. {
  1750. CarlaEngineCVPort* const port(plugin->getCVOutPort(i));
  1751. cvOut[i] = port->getBuffer();
  1752. }
  1753. float inPeaks[2] = { 0.0f };
  1754. float outPeaks[2] = { 0.0f };
  1755. for (uint32_t i=0; i < audioInCount && i < 2; ++i)
  1756. {
  1757. for (uint32_t j=0; j < nframes; ++j)
  1758. {
  1759. const float absV(std::abs(audioIn[i][j]));
  1760. if (absV > inPeaks[i])
  1761. inPeaks[i] = absV;
  1762. }
  1763. }
  1764. plugin->process(audioIn, audioOut, cvIn, cvOut, nframes);
  1765. for (uint32_t i=0; i < audioOutCount && i < 2; ++i)
  1766. {
  1767. for (uint32_t j=0; j < nframes; ++j)
  1768. {
  1769. const float absV(std::abs(audioOut[i][j]));
  1770. if (absV > outPeaks[i])
  1771. outPeaks[i] = absV;
  1772. }
  1773. }
  1774. setPluginPeaks(plugin->getId(), inPeaks, outPeaks);
  1775. }
  1776. #ifndef BUILD_BRIDGE
  1777. // -------------------------------------------------------------------
  1778. struct PostPonedJackEvent {
  1779. enum Type {
  1780. kTypeNull = 0,
  1781. kTypeClientRegister,
  1782. kTypePortRegister,
  1783. kTypePortConnect,
  1784. kTypePortRename
  1785. };
  1786. Type type;
  1787. bool action; // register or connect
  1788. jack_port_id_t port1;
  1789. jack_port_id_t port2;
  1790. char name1[STR_MAX+1];
  1791. char name2[STR_MAX+1];
  1792. };
  1793. LinkedList<PostPonedJackEvent> fPostPonedEvents;
  1794. CarlaMutex fPostPonedEventsMutex;
  1795. void postPoneJackCallback(const PostPonedJackEvent& ev)
  1796. {
  1797. const CarlaMutexLocker cml(fPostPonedEventsMutex);
  1798. fPostPonedEvents.append(ev);
  1799. }
  1800. void run() override
  1801. {
  1802. LinkedList<PostPonedJackEvent> events;
  1803. LinkedList<uint> newPlugins;
  1804. PostPonedJackEvent nullEvent;
  1805. carla_zeroStruct(nullEvent);
  1806. for (; ! shouldThreadExit();)
  1807. {
  1808. {
  1809. const CarlaMutexLocker cml(fPostPonedEventsMutex);
  1810. if (fPostPonedEvents.count() > 0)
  1811. fPostPonedEvents.moveTo(events);
  1812. if (fNewGroups.count() > 0)
  1813. fNewGroups.moveTo(newPlugins);
  1814. }
  1815. if (fClient == nullptr)
  1816. break;
  1817. if (events.count() == 0 && newPlugins.count() == 0)
  1818. {
  1819. carla_msleep(200);
  1820. continue;
  1821. }
  1822. for (LinkedList<PostPonedJackEvent>::Itenerator it = events.begin2(); it.valid(); it.next())
  1823. {
  1824. const PostPonedJackEvent& ev(it.getValue(nullEvent));
  1825. CARLA_SAFE_ASSERT_CONTINUE(ev.type != PostPonedJackEvent::kTypeNull);
  1826. switch (ev.type)
  1827. {
  1828. case PostPonedJackEvent::kTypeNull:
  1829. break;
  1830. case PostPonedJackEvent::kTypeClientRegister:
  1831. handleJackClientRegistrationCallback(ev.name1, ev.action);
  1832. break;
  1833. case PostPonedJackEvent::kTypePortRegister:
  1834. handleJackPortRegistrationCallback(ev.port1, ev.action);
  1835. break;
  1836. case PostPonedJackEvent::kTypePortConnect:
  1837. handleJackPortConnectCallback(ev.port1, ev.port2, ev.action);
  1838. break;
  1839. case PostPonedJackEvent::kTypePortRename:
  1840. handleJackPortRenameCallback(ev.port1, ev.name1, ev.name2);
  1841. break;
  1842. }
  1843. }
  1844. for (LinkedList<uint>::Itenerator it = newPlugins.begin2(); it.valid(); it.next())
  1845. {
  1846. const uint groupId(it.getValue(0));
  1847. CARLA_SAFE_ASSERT_CONTINUE(groupId > 0);
  1848. const char* const groupName(fUsedGroups.getGroupName(groupId));
  1849. CARLA_SAFE_ASSERT_CONTINUE(groupName != nullptr && groupName[0] != '\0');
  1850. int pluginId = -1;
  1851. PatchbayIcon icon = PATCHBAY_ICON_PLUGIN;
  1852. if (findPluginIdAndIcon(groupName, pluginId, icon))
  1853. callback(ENGINE_CALLBACK_PATCHBAY_CLIENT_DATA_CHANGED, groupId, icon, pluginId, 0.0f, nullptr);
  1854. }
  1855. events.clear();
  1856. newPlugins.clear();
  1857. }
  1858. events.clear();
  1859. newPlugins.clear();
  1860. }
  1861. #endif // BUILD_BRIDGE
  1862. // -------------------------------------------------------------------
  1863. // disable -Wattributes warnings
  1864. #if defined(__clang__)
  1865. # pragma clang diagnostic push
  1866. # pragma clang diagnostic ignored "-Wattributes"
  1867. #elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
  1868. # pragma GCC diagnostic push
  1869. # pragma GCC diagnostic ignored "-Wattributes"
  1870. #endif
  1871. #define handlePtr ((CarlaEngineJack*)arg)
  1872. static void JACKBRIDGE_API carla_jack_thread_init_callback(void*)
  1873. {
  1874. #ifdef __SSE2_MATH__
  1875. // Set FTZ and DAZ flags
  1876. _mm_setcsr(_mm_getcsr() | 0x8040);
  1877. #endif
  1878. }
  1879. static int JACKBRIDGE_API carla_jack_bufsize_callback(jack_nframes_t newBufferSize, void* arg)
  1880. {
  1881. handlePtr->handleJackBufferSizeCallback(newBufferSize);
  1882. return 0;
  1883. }
  1884. static int JACKBRIDGE_API carla_jack_srate_callback(jack_nframes_t newSampleRate, void* arg)
  1885. {
  1886. handlePtr->handleJackSampleRateCallback(newSampleRate);
  1887. return 0;
  1888. }
  1889. static void JACKBRIDGE_API carla_jack_freewheel_callback(int starting, void* arg)
  1890. {
  1891. handlePtr->handleJackFreewheelCallback(bool(starting));
  1892. }
  1893. static int JACKBRIDGE_API carla_jack_process_callback(jack_nframes_t nframes, void* arg) __attribute__((annotate("realtime")))
  1894. {
  1895. handlePtr->handleJackProcessCallback(nframes);
  1896. return 0;
  1897. }
  1898. static void JACKBRIDGE_API carla_jack_latency_callback(jack_latency_callback_mode_t mode, void* arg)
  1899. {
  1900. handlePtr->handleJackLatencyCallback(mode);
  1901. }
  1902. #ifndef BUILD_BRIDGE
  1903. static void JACKBRIDGE_API carla_jack_timebase_callback(jack_transport_state_t, jack_nframes_t nframes, jack_position_t* pos, int new_pos, void* arg) __attribute__((annotate("realtime")))
  1904. {
  1905. handlePtr->handleJackTimebaseCallback(nframes, pos, new_pos);
  1906. }
  1907. static void JACKBRIDGE_API carla_jack_client_registration_callback(const char* name, int reg, void* arg)
  1908. {
  1909. PostPonedJackEvent ev;
  1910. carla_zeroStruct(ev);
  1911. ev.type = PostPonedJackEvent::kTypeClientRegister;
  1912. ev.action = (reg != 0);
  1913. std::strncpy(ev.name1, name, STR_MAX);
  1914. handlePtr->postPoneJackCallback(ev);
  1915. }
  1916. static void JACKBRIDGE_API carla_jack_port_registration_callback(jack_port_id_t port, int reg, void* arg)
  1917. {
  1918. PostPonedJackEvent ev;
  1919. carla_zeroStruct(ev);
  1920. ev.type = PostPonedJackEvent::kTypePortRegister;
  1921. ev.action = (reg != 0);
  1922. ev.port1 = port;
  1923. handlePtr->postPoneJackCallback(ev);
  1924. }
  1925. static void JACKBRIDGE_API carla_jack_port_connect_callback(jack_port_id_t a, jack_port_id_t b, int connect, void* arg)
  1926. {
  1927. PostPonedJackEvent ev;
  1928. carla_zeroStruct(ev);
  1929. ev.type = PostPonedJackEvent::kTypePortConnect;
  1930. ev.action = (connect != 0);
  1931. ev.port1 = a;
  1932. ev.port2 = b;
  1933. handlePtr->postPoneJackCallback(ev);
  1934. }
  1935. static void JACKBRIDGE_API carla_jack_port_rename_callback(jack_port_id_t port, const char* oldName, const char* newName, void* arg)
  1936. {
  1937. PostPonedJackEvent ev;
  1938. carla_zeroStruct(ev);
  1939. ev.type = PostPonedJackEvent::kTypePortRename;
  1940. ev.port1 = port;
  1941. std::strncpy(ev.name1, oldName, STR_MAX);
  1942. std::strncpy(ev.name2, newName, STR_MAX);
  1943. handlePtr->postPoneJackCallback(ev);
  1944. }
  1945. #endif
  1946. static void JACKBRIDGE_API carla_jack_shutdown_callback(void* arg)
  1947. {
  1948. handlePtr->handleJackShutdownCallback();
  1949. }
  1950. #undef handlePtr
  1951. // -------------------------------------------------------------------
  1952. #ifndef BUILD_BRIDGE
  1953. static int JACKBRIDGE_API carla_jack_process_callback_plugin(jack_nframes_t nframes, void* arg) __attribute__((annotate("realtime")))
  1954. {
  1955. CarlaPlugin* const plugin((CarlaPlugin*)arg);
  1956. CARLA_SAFE_ASSERT_RETURN(plugin != nullptr && plugin->isEnabled(), 0);
  1957. CarlaEngineJack* const engine((CarlaEngineJack*)plugin->getEngine());
  1958. CARLA_SAFE_ASSERT_RETURN(engine != nullptr, 0);
  1959. if (plugin->tryLock(engine->fFreewheel))
  1960. {
  1961. plugin->initBuffers();
  1962. engine->saveTransportInfo();
  1963. engine->processPlugin(plugin, nframes);
  1964. plugin->unlock();
  1965. }
  1966. return 0;
  1967. }
  1968. static void JACKBRIDGE_API carla_jack_latency_callback_plugin(jack_latency_callback_mode_t /*mode*/, void* /*arg*/)
  1969. {
  1970. // TODO
  1971. }
  1972. static void JACKBRIDGE_API carla_jack_shutdown_callback_plugin(void* arg)
  1973. {
  1974. CarlaPlugin* const plugin((CarlaPlugin*)arg);
  1975. CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);
  1976. CarlaEngineJack* const engine((CarlaEngineJack*)plugin->getEngine());
  1977. CARLA_SAFE_ASSERT_RETURN(engine != nullptr,);
  1978. engine->handlePluginJackShutdownCallback(plugin);
  1979. }
  1980. #endif
  1981. // enable -Wattributes again
  1982. #if defined(__clang__)
  1983. # pragma clang diagnostic pop
  1984. #elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
  1985. # pragma GCC diagnostic pop
  1986. #endif
  1987. CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaEngineJack)
  1988. };
  1989. // -----------------------------------------------------------------------
  1990. CarlaEngine* CarlaEngine::newJack()
  1991. {
  1992. carla_debug("CarlaEngine::newJack()");
  1993. return new CarlaEngineJack();
  1994. }
  1995. // -----------------------------------------------------------------------
  1996. CARLA_BACKEND_END_NAMESPACE