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.

2503 lines
83KB

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