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.

1686 lines
56KB

  1. /*
  2. * Carla JACK Engine
  3. * Copyright (C) 2012-2013 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 GPL.txt file
  16. */
  17. #ifdef WANT_JACK
  18. #include "CarlaEngineInternal.hpp"
  19. #include "CarlaBackendUtils.hpp"
  20. #include "CarlaMIDI.h"
  21. #include "jackbridge/jackbridge.h"
  22. #include <cmath>
  23. CARLA_BACKEND_START_NAMESPACE
  24. #if 0
  25. } // Fix editor indentation
  26. #endif
  27. // -------------------------------------------------------------------
  28. // Plugin Helpers, defined in CarlaPlugin.cpp
  29. extern CarlaEngine* CarlaPluginGetEngine(CarlaPlugin* const plugin);
  30. extern CarlaEngineAudioPort* CarlaPluginGetAudioInPort(CarlaPlugin* const plugin, uint32_t index);
  31. extern CarlaEngineAudioPort* CarlaPluginGetAudioOutPort(CarlaPlugin* const plugin, uint32_t index);
  32. // -------------------------------------------------------------------------------------------------------------------
  33. // Carla Engine JACK-Audio port
  34. class CarlaEngineJackAudioPort : public CarlaEngineAudioPort
  35. {
  36. public:
  37. CarlaEngineJackAudioPort(const bool isInput, const ProcessMode processMode, jack_client_t* const client, jack_port_t* const port)
  38. : CarlaEngineAudioPort(isInput, processMode),
  39. kClient(client),
  40. kPort(port)
  41. {
  42. carla_debug("CarlaEngineJackAudioPort::CarlaEngineJackAudioPort(%s, %s, %p, %p)", bool2str(isInput), ProcessMode2Str(processMode), client, port);
  43. if (processMode == PROCESS_MODE_SINGLE_CLIENT || processMode == PROCESS_MODE_MULTIPLE_CLIENTS)
  44. {
  45. CARLA_ASSERT(client != nullptr && port != nullptr);
  46. }
  47. else
  48. {
  49. CARLA_ASSERT(client == nullptr && port == nullptr);
  50. }
  51. }
  52. ~CarlaEngineJackAudioPort()
  53. {
  54. carla_debug("CarlaEngineJackAudioPort::~CarlaEngineJackAudioPort()");
  55. if (kClient != nullptr && kPort != nullptr)
  56. jackbridge_port_unregister(kClient, kPort);
  57. }
  58. void initBuffer(CarlaEngine* const engine)
  59. {
  60. CARLA_ASSERT(engine != nullptr);
  61. if (engine == nullptr)
  62. {
  63. fBuffer = nullptr;
  64. return;
  65. }
  66. if (kPort == nullptr)
  67. return CarlaEngineAudioPort::initBuffer(engine);
  68. fBuffer = (float*)jackbridge_port_get_buffer(kPort, engine->getBufferSize());
  69. if (! kIsInput)
  70. carla_zeroFloat(fBuffer, engine->getBufferSize());
  71. }
  72. private:
  73. jack_client_t* const kClient;
  74. jack_port_t* const kPort;
  75. friend class CarlaEngineJack;
  76. CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaEngineJackAudioPort)
  77. };
  78. // -------------------------------------------------------------------------------------------------------------------
  79. // Carla Engine JACK-Event port
  80. static const EngineEvent kFallbackJackEngineEvent;
  81. class CarlaEngineJackEventPort : public CarlaEngineEventPort
  82. {
  83. public:
  84. CarlaEngineJackEventPort(const bool isInput, const ProcessMode processMode, jack_client_t* const client, jack_port_t* const port)
  85. : CarlaEngineEventPort(isInput, processMode),
  86. kClient(client),
  87. kPort(port),
  88. fJackBuffer(nullptr)
  89. {
  90. carla_debug("CarlaEngineJackEventPort::CarlaEngineJackEventPort(%s, %s, %p, %p)", bool2str(isInput), ProcessMode2Str(processMode), client, port);
  91. if (processMode == PROCESS_MODE_SINGLE_CLIENT || processMode == PROCESS_MODE_MULTIPLE_CLIENTS)
  92. {
  93. CARLA_ASSERT(client != nullptr && port != nullptr);
  94. }
  95. else
  96. {
  97. CARLA_ASSERT(client == nullptr && port == nullptr);
  98. }
  99. }
  100. ~CarlaEngineJackEventPort()
  101. {
  102. carla_debug("CarlaEngineJackEventPort::~CarlaEngineJackEventPort()");
  103. if (kClient != nullptr && kPort != nullptr)
  104. jackbridge_port_unregister(kClient, kPort);
  105. }
  106. void initBuffer(CarlaEngine* const engine)
  107. {
  108. CARLA_ASSERT(engine != nullptr);
  109. if (engine == nullptr)
  110. {
  111. fJackBuffer = nullptr;
  112. return;
  113. }
  114. if (kPort == nullptr)
  115. return CarlaEngineEventPort::initBuffer(engine);
  116. fJackBuffer = jackbridge_port_get_buffer(kPort, engine->getBufferSize());
  117. if (! kIsInput)
  118. jackbridge_midi_clear_buffer(fJackBuffer);
  119. }
  120. uint32_t getEventCount()
  121. {
  122. if (kPort == nullptr)
  123. return CarlaEngineEventPort::getEventCount();
  124. CARLA_ASSERT(kIsInput);
  125. CARLA_ASSERT(fJackBuffer != nullptr);
  126. if (! kIsInput)
  127. return 0;
  128. if (fJackBuffer == nullptr)
  129. return 0;
  130. return jackbridge_midi_get_event_count(fJackBuffer);
  131. }
  132. const EngineEvent& getEvent(const uint32_t index)
  133. {
  134. if (kPort == nullptr)
  135. return CarlaEngineEventPort::getEvent(index);
  136. CARLA_ASSERT(kIsInput);
  137. CARLA_ASSERT(fJackBuffer != nullptr);
  138. if (! kIsInput)
  139. return kFallbackJackEngineEvent;
  140. if (fJackBuffer == nullptr)
  141. return kFallbackJackEngineEvent;
  142. jack_midi_event_t jackEvent;
  143. if (jackbridge_midi_event_get(&jackEvent, fJackBuffer, index) != 0 || jackEvent.size > 3)
  144. return kFallbackJackEngineEvent;
  145. fRetEvent.clear();
  146. const uint8_t midiStatus = MIDI_GET_STATUS_FROM_DATA(jackEvent.buffer);
  147. const uint8_t midiChannel = MIDI_GET_CHANNEL_FROM_DATA(jackEvent.buffer);
  148. fRetEvent.time = jackEvent.time;
  149. fRetEvent.channel = midiChannel;
  150. if (MIDI_IS_STATUS_CONTROL_CHANGE(midiStatus))
  151. {
  152. const uint8_t midiControl = jackEvent.buffer[1];
  153. fRetEvent.type = kEngineEventTypeControl;
  154. if (MIDI_IS_CONTROL_BANK_SELECT(midiControl))
  155. {
  156. const uint8_t midiBank = jackEvent.buffer[2];
  157. fRetEvent.ctrl.type = kEngineControlEventTypeMidiBank;
  158. fRetEvent.ctrl.param = midiBank;
  159. fRetEvent.ctrl.value = 0.0;
  160. }
  161. else if (midiControl == MIDI_CONTROL_ALL_SOUND_OFF)
  162. {
  163. fRetEvent.ctrl.type = kEngineControlEventTypeAllSoundOff;
  164. fRetEvent.ctrl.param = 0;
  165. fRetEvent.ctrl.value = 0.0;
  166. }
  167. else if (midiControl == MIDI_CONTROL_ALL_NOTES_OFF)
  168. {
  169. fRetEvent.ctrl.type = kEngineControlEventTypeAllNotesOff;
  170. fRetEvent.ctrl.param = 0;
  171. fRetEvent.ctrl.value = 0.0;
  172. }
  173. else
  174. {
  175. const uint8_t midiValue = jackEvent.buffer[2];
  176. fRetEvent.ctrl.type = kEngineControlEventTypeParameter;
  177. fRetEvent.ctrl.param = midiControl;
  178. fRetEvent.ctrl.value = double(midiValue)/127.0;
  179. }
  180. }
  181. else if (MIDI_IS_STATUS_PROGRAM_CHANGE(midiStatus))
  182. {
  183. const uint8_t midiProgram = jackEvent.buffer[1];
  184. fRetEvent.type = kEngineEventTypeControl;
  185. fRetEvent.ctrl.type = kEngineControlEventTypeMidiProgram;
  186. fRetEvent.ctrl.param = midiProgram;
  187. fRetEvent.ctrl.value = 0.0;
  188. }
  189. else
  190. {
  191. fRetEvent.type = kEngineEventTypeMidi;
  192. fRetEvent.midi.data[0] = midiStatus;
  193. fRetEvent.midi.data[1] = jackEvent.buffer[1];
  194. fRetEvent.midi.data[2] = jackEvent.buffer[2];
  195. fRetEvent.midi.size = static_cast<uint8_t>(jackEvent.size);
  196. }
  197. return fRetEvent;
  198. }
  199. void writeControlEvent(const uint32_t time, const uint8_t channel, const EngineControlEventType type, const uint16_t param, const double value)
  200. {
  201. if (kPort == nullptr)
  202. return CarlaEngineEventPort::writeControlEvent(time, channel, type, param, value);
  203. CARLA_ASSERT(! kIsInput);
  204. CARLA_ASSERT(fJackBuffer != nullptr);
  205. CARLA_ASSERT(type != kEngineControlEventTypeNull);
  206. CARLA_ASSERT(channel < MAX_MIDI_CHANNELS);
  207. CARLA_ASSERT(param < MAX_MIDI_VALUE);
  208. CARLA_SAFE_ASSERT(value >= 0.0 && value <= 1.0);
  209. if (kIsInput)
  210. return;
  211. if (fJackBuffer == nullptr)
  212. return;
  213. if (type == kEngineControlEventTypeNull)
  214. return;
  215. if (channel >= MAX_MIDI_CHANNELS)
  216. return;
  217. if (param >= MAX_MIDI_VALUE)
  218. return;
  219. if (type == kEngineControlEventTypeParameter)
  220. {
  221. CARLA_ASSERT(! MIDI_IS_CONTROL_BANK_SELECT(param));
  222. }
  223. const double fixedValue = carla_fixValue<double>(0.0, 1.0, value);
  224. uint8_t data[3] = { 0 };
  225. uint8_t size = 0;
  226. switch (type)
  227. {
  228. case kEngineControlEventTypeNull:
  229. break;
  230. case kEngineControlEventTypeParameter:
  231. data[0] = MIDI_STATUS_CONTROL_CHANGE + channel;
  232. data[1] = static_cast<uint8_t>(param);
  233. data[2] = uint8_t(fixedValue * 127.0);
  234. size = 3;
  235. break;
  236. case kEngineControlEventTypeMidiBank:
  237. data[0] = MIDI_STATUS_CONTROL_CHANGE + channel;
  238. data[1] = MIDI_CONTROL_BANK_SELECT;
  239. data[2] = static_cast<uint8_t>(param);
  240. size = 3;
  241. break;
  242. case kEngineControlEventTypeMidiProgram:
  243. data[0] = MIDI_STATUS_PROGRAM_CHANGE + channel;
  244. data[1] = static_cast<uint8_t>(param);
  245. size = 2;
  246. break;
  247. case kEngineControlEventTypeAllSoundOff:
  248. data[0] = MIDI_STATUS_CONTROL_CHANGE + channel;
  249. data[1] = MIDI_CONTROL_ALL_SOUND_OFF;
  250. size = 2;
  251. break;
  252. case kEngineControlEventTypeAllNotesOff:
  253. data[0] = MIDI_STATUS_CONTROL_CHANGE + channel;
  254. data[1] = MIDI_CONTROL_ALL_NOTES_OFF;
  255. size = 2;
  256. break;
  257. }
  258. if (size > 0)
  259. jackbridge_midi_event_write(fJackBuffer, time, data, size);
  260. }
  261. void writeMidiEvent(const uint32_t time, const uint8_t channel, const uint8_t port, const uint8_t* const data, const uint8_t size)
  262. {
  263. if (kPort == nullptr)
  264. return CarlaEngineEventPort::writeMidiEvent(time, channel, port, data, size);
  265. CARLA_ASSERT(! kIsInput);
  266. CARLA_ASSERT(fJackBuffer != nullptr);
  267. CARLA_ASSERT(channel < MAX_MIDI_CHANNELS);
  268. CARLA_ASSERT(data != nullptr);
  269. CARLA_ASSERT(size > 0);
  270. if (kIsInput)
  271. return;
  272. if (fJackBuffer == nullptr)
  273. return;
  274. if (channel >= MAX_MIDI_CHANNELS)
  275. return;
  276. if (data == nullptr)
  277. return;
  278. if (size == 0)
  279. return;
  280. uint8_t jdata[size];
  281. carla_copy<uint8_t>(jdata, data, size);
  282. jdata[0] = data[0] + channel;
  283. jackbridge_midi_event_write(fJackBuffer, time, jdata, size);
  284. }
  285. private:
  286. jack_client_t* const kClient;
  287. jack_port_t* const kPort;
  288. void* fJackBuffer;
  289. EngineEvent fRetEvent;
  290. CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaEngineJackEventPort)
  291. };
  292. // -------------------------------------------------------------------------------------------------------------------
  293. // Jack Engine client
  294. class CarlaEngineJackClient : public CarlaEngineClient
  295. {
  296. public:
  297. CarlaEngineJackClient(const EngineType engineType, const ProcessMode processMode, jack_client_t* const client)
  298. : CarlaEngineClient(engineType, processMode),
  299. kClient(client),
  300. kUseClient(processMode == PROCESS_MODE_SINGLE_CLIENT || processMode == PROCESS_MODE_MULTIPLE_CLIENTS)
  301. {
  302. carla_debug("CarlaEngineJackClient::CarlaEngineJackClient(%s, %s, %p)", EngineType2Str(engineType), ProcessMode2Str(processMode), client);
  303. if (kUseClient)
  304. {
  305. CARLA_ASSERT(kClient != nullptr);
  306. }
  307. else
  308. {
  309. CARLA_ASSERT(kClient == nullptr);
  310. }
  311. }
  312. ~CarlaEngineJackClient()
  313. {
  314. carla_debug("CarlaEngineClient::~CarlaEngineClient()");
  315. if (kProcessMode == PROCESS_MODE_MULTIPLE_CLIENTS)
  316. {
  317. if (kClient)
  318. jackbridge_client_close(kClient);
  319. }
  320. }
  321. void activate()
  322. {
  323. carla_debug("CarlaEngineJackClient::activate()");
  324. if (kProcessMode == PROCESS_MODE_MULTIPLE_CLIENTS)
  325. {
  326. CARLA_ASSERT(kClient && ! fActive);
  327. if (kClient && ! fActive)
  328. jackbridge_activate(kClient);
  329. }
  330. CarlaEngineClient::activate();
  331. }
  332. void deactivate()
  333. {
  334. carla_debug("CarlaEngineJackClient::deactivate()");
  335. if (kProcessMode == PROCESS_MODE_MULTIPLE_CLIENTS)
  336. {
  337. CARLA_ASSERT(kClient && fActive);
  338. if (kClient && fActive)
  339. jackbridge_deactivate(kClient);
  340. }
  341. CarlaEngineClient::deactivate();
  342. }
  343. bool isOk() const
  344. {
  345. carla_debug("CarlaEngineJackClient::isOk()");
  346. if (kUseClient)
  347. return bool(kClient);
  348. return CarlaEngineClient::isOk();
  349. }
  350. #if WANT_JACK_LATENCY
  351. void setLatency(const uint32_t samples)
  352. {
  353. CarlaEngineClient::setLatency(samples);
  354. if (kUseClient)
  355. jackbridge_recompute_total_latencies(kClient);
  356. }
  357. #endif
  358. CarlaEnginePort* addPort(const EnginePortType portType, const char* const name, const bool isInput)
  359. {
  360. carla_debug("CarlaEngineJackClient::addPort(%s, \"%s\", %s)", EnginePortType2Str(portType), name, bool2str(isInput));
  361. jack_port_t* port = nullptr;
  362. // Create JACK port first, if needed
  363. if (kUseClient)
  364. {
  365. switch (portType)
  366. {
  367. case kEnginePortTypeNull:
  368. break;
  369. case kEnginePortTypeAudio:
  370. port = jackbridge_port_register(kClient, name, JACK_DEFAULT_AUDIO_TYPE, isInput ? JackPortIsInput : JackPortIsOutput, 0);
  371. break;
  372. case kEnginePortTypeEvent:
  373. port = jackbridge_port_register(kClient, name, JACK_DEFAULT_MIDI_TYPE, isInput ? JackPortIsInput : JackPortIsOutput, 0);
  374. break;
  375. }
  376. }
  377. // Create Engine port
  378. switch (portType)
  379. {
  380. case kEnginePortTypeNull:
  381. break;
  382. case kEnginePortTypeAudio:
  383. return new CarlaEngineJackAudioPort(isInput, kProcessMode, kClient, port);
  384. case kEnginePortTypeEvent:
  385. return new CarlaEngineJackEventPort(isInput, kProcessMode, kClient, port);
  386. }
  387. carla_stderr("CarlaEngineJackClient::addPort(%s, \"%s\", %s) - invalid type", EnginePortType2Str(portType), name, bool2str(isInput));
  388. return nullptr;
  389. }
  390. private:
  391. jack_client_t* const kClient;
  392. const bool kUseClient;
  393. CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaEngineJackClient)
  394. };
  395. // -------------------------------------------------------------------------------------------------------------------
  396. // Jack Engine
  397. class CarlaEngineJack : public CarlaEngine
  398. {
  399. public:
  400. CarlaEngineJack()
  401. : CarlaEngine(),
  402. fClient(nullptr),
  403. fTransportState(JackTransportStopped),
  404. fFreewheel(false),
  405. #ifdef BUILD_BRIDGE
  406. fHasQuit(false)
  407. #else
  408. # ifndef QTCREATOR_TEST
  409. fRackPorts{nullptr},
  410. fLastGroupId(0),
  411. # endif
  412. fLastPortId(0),
  413. fLastConnectionId(0)
  414. #endif
  415. {
  416. carla_debug("CarlaEngineJack::CarlaEngineJack()");
  417. #ifdef BUILD_BRIDGE
  418. fOptions.processMode = PROCESS_MODE_MULTIPLE_CLIENTS;
  419. #endif
  420. // FIXME: Always enable JACK transport for now
  421. fOptions.transportMode = TRANSPORT_MODE_JACK;
  422. carla_zeroStruct<jack_position_t>(fTransportPos);
  423. }
  424. ~CarlaEngineJack()
  425. {
  426. carla_debug("CarlaEngineJack::~CarlaEngineJack()");
  427. CARLA_ASSERT(fClient == nullptr);
  428. #ifndef BUILD_BRIDGE
  429. fUsedGroupNames.clear();
  430. fUsedPortNames.clear();
  431. fUsedConnections.clear();
  432. #endif
  433. }
  434. // -------------------------------------------------------------------
  435. // Maximum values
  436. unsigned int maxClientNameSize()
  437. {
  438. if (fOptions.processMode == PROCESS_MODE_SINGLE_CLIENT || fOptions.processMode == PROCESS_MODE_MULTIPLE_CLIENTS)
  439. return static_cast<unsigned int>(jackbridge_client_name_size());
  440. return CarlaEngine::maxClientNameSize();
  441. }
  442. unsigned int maxPortNameSize()
  443. {
  444. if (fOptions.processMode == PROCESS_MODE_SINGLE_CLIENT || fOptions.processMode == PROCESS_MODE_MULTIPLE_CLIENTS)
  445. return static_cast<unsigned int>(jackbridge_port_name_size());
  446. return CarlaEngine::maxPortNameSize();
  447. }
  448. // -------------------------------------------------------------------
  449. // Virtual, per-engine type calls
  450. bool init(const char* const clientName)
  451. {
  452. carla_debug("CarlaEngineJack::init(\"%s\")", clientName);
  453. fFreewheel = false;
  454. fTransportState = JackTransportStopped;
  455. carla_zeroStruct<jack_position_t>(fTransportPos);
  456. #ifndef BUILD_BRIDGE
  457. fLastGroupId = 0;
  458. fLastPortId = 0;
  459. fLastConnectionId = 0;
  460. fUsedGroupNames.clear();
  461. fUsedPortNames.clear();
  462. fUsedConnections.clear();
  463. fClient = jackbridge_client_open(clientName, JackNullOption, nullptr);
  464. if (fClient != nullptr)
  465. {
  466. fBufferSize = jackbridge_get_buffer_size(fClient);
  467. fSampleRate = jackbridge_get_sample_rate(fClient);
  468. jackbridge_set_buffer_size_callback(fClient, carla_jack_bufsize_callback, this);
  469. jackbridge_set_sample_rate_callback(fClient, carla_jack_srate_callback, this);
  470. jackbridge_set_freewheel_callback(fClient, carla_jack_freewheel_callback, this);
  471. jackbridge_set_process_callback(fClient, carla_jack_process_callback, this);
  472. jackbridge_on_shutdown(fClient, carla_jack_shutdown_callback, this);
  473. # if WANT_JACK_LATENCY
  474. jackbridge_set_latency_callback(fClient, carla_jack_latency_callback, this);
  475. # endif
  476. const char* const jackClientName = jackbridge_get_client_name(fClient);
  477. initJackPatchbay(jackClientName);
  478. // TODO - update jackbridge
  479. jack_set_client_registration_callback(fClient, carla_jack_client_registration_callback, this);
  480. jack_set_port_registration_callback(fClient, carla_jack_port_registration_callback, this);
  481. jack_set_port_connect_callback(fClient, carla_jack_port_connect_callback, this);
  482. #ifdef WANT_JACK_PORT_RENAME
  483. if (jack_set_port_rename_callback)
  484. jack_set_port_rename_callback(fClient, carla_jack_port_rename_callback, this);
  485. #endif
  486. if (fOptions.processMode == PROCESS_MODE_CONTINUOUS_RACK)
  487. {
  488. fRackPorts[rackPortAudioIn1] = jackbridge_port_register(fClient, "audio-in1", JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0);
  489. fRackPorts[rackPortAudioIn2] = jackbridge_port_register(fClient, "audio-in2", JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0);
  490. fRackPorts[rackPortAudioOut1] = jackbridge_port_register(fClient, "audio-out1", JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0);
  491. fRackPorts[rackPortAudioOut2] = jackbridge_port_register(fClient, "audio-out2", JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0);
  492. fRackPorts[rackPortEventIn] = jackbridge_port_register(fClient, "events-in", JACK_DEFAULT_MIDI_TYPE, JackPortIsInput, 0);
  493. fRackPorts[rackPortEventOut] = jackbridge_port_register(fClient, "events-out", JACK_DEFAULT_MIDI_TYPE, JackPortIsOutput, 0);
  494. }
  495. if (jackbridge_activate(fClient) == 0)
  496. {
  497. return CarlaEngine::init(jackClientName);
  498. }
  499. else
  500. {
  501. setLastError("Failed to activate the JACK client");
  502. jackbridge_client_close(fClient);
  503. fClient = nullptr;
  504. }
  505. }
  506. else
  507. setLastError("Failed to create new JACK client");
  508. return false;
  509. #else
  510. if (fBufferSize == 0 || fSampleRate == 0.0)
  511. {
  512. // open temp client to get initial buffer-size and sample-rate values
  513. if (jack_client_t* tmpClient = jackbridge_client_open(clientName, JackNullOption, nullptr))
  514. {
  515. fBufferSize = jackbridge_get_buffer_size(tmpClient);
  516. fSampleRate = jackbridge_get_sample_rate(tmpClient);
  517. jackbridge_client_close(tmpClient);
  518. }
  519. }
  520. return CarlaEngine::init(clientName);
  521. #endif
  522. }
  523. bool close()
  524. {
  525. carla_debug("CarlaEngineJack::close()");
  526. CarlaEngine::close();
  527. #ifdef BUILD_BRIDGE
  528. fClient = nullptr;
  529. fHasQuit = true;
  530. return true;
  531. #else
  532. if (jackbridge_deactivate(fClient) == 0)
  533. {
  534. if (fOptions.processMode == PROCESS_MODE_CONTINUOUS_RACK)
  535. {
  536. jackbridge_port_unregister(fClient, fRackPorts[rackPortAudioIn1]);
  537. jackbridge_port_unregister(fClient, fRackPorts[rackPortAudioIn2]);
  538. jackbridge_port_unregister(fClient, fRackPorts[rackPortAudioOut1]);
  539. jackbridge_port_unregister(fClient, fRackPorts[rackPortAudioOut2]);
  540. jackbridge_port_unregister(fClient, fRackPorts[rackPortEventIn]);
  541. jackbridge_port_unregister(fClient, fRackPorts[rackPortEventOut]);
  542. }
  543. if (jackbridge_client_close(fClient) == 0)
  544. {
  545. fClient = nullptr;
  546. return true;
  547. }
  548. else
  549. setLastError("Failed to close the JACK client");
  550. }
  551. else
  552. setLastError("Failed to deactivate the JACK client");
  553. fClient = nullptr;
  554. fUsedGroupNames.clear();
  555. fUsedPortNames.clear();
  556. fUsedConnections.clear();
  557. #endif
  558. return false;
  559. }
  560. bool isRunning() const
  561. {
  562. #ifdef BUILD_BRIDGE
  563. return (fClient != nullptr || ! fHasQuit);
  564. #else
  565. return (fClient != nullptr);
  566. #endif
  567. }
  568. bool isOffline() const
  569. {
  570. return fFreewheel;
  571. }
  572. EngineType type() const
  573. {
  574. return kEngineTypeJack;
  575. }
  576. CarlaEngineClient* addClient(CarlaPlugin* const plugin)
  577. {
  578. jack_client_t* client = nullptr;
  579. #ifdef BUILD_BRIDGE
  580. client = fClient = jackbridge_client_open(plugin->name(), JackNullOption, nullptr);
  581. fBufferSize = jackbridge_get_buffer_size(client);
  582. fSampleRate = jackbridge_get_sample_rate(client);
  583. jackbridge_set_buffer_size_callback(client, carla_jack_bufsize_callback, this);
  584. jackbridge_set_sample_rate_callback(client, carla_jack_srate_callback, this);
  585. jackbridge_set_freewheel_callback(client, carla_jack_freewheel_callback, this);
  586. jackbridge_set_process_callback(client, carla_jack_process_callback, this);
  587. jackbridge_on_shutdown(client, carla_jack_shutdown_callback, this);
  588. # if WANT_JACK_LATENCY
  589. jackbridge_set_latency_callback(client, carla_jack_latency_callback, this);
  590. # endif
  591. #else
  592. if (fOptions.processMode == PROCESS_MODE_SINGLE_CLIENT)
  593. {
  594. client = fClient;
  595. }
  596. else if (fOptions.processMode == PROCESS_MODE_MULTIPLE_CLIENTS)
  597. {
  598. client = jackbridge_client_open(plugin->name(), JackNullOption, nullptr);
  599. jackbridge_set_process_callback(client, carla_jack_process_callback_plugin, plugin);
  600. # if WANT_JACK_LATENCY
  601. jackbridge_set_latency_callback(client, carla_jack_latency_callback_plugin, plugin);
  602. # endif
  603. }
  604. #endif
  605. return new CarlaEngineJackClient(kEngineTypeJack, fOptions.processMode, client);
  606. }
  607. #ifndef BUILD_BRIDGE
  608. // -------------------------------------------------------------------
  609. // Patchbay
  610. void patchbayConnect(int portA, int portB)
  611. {
  612. if (fClient == nullptr)
  613. return;
  614. const char* const portNameA = getFullPortName(portA).toUtf8().constData();
  615. const char* const portNameB = getFullPortName(portB).toUtf8().constData();
  616. jack_connect(fClient, portNameA, portNameB);
  617. }
  618. void patchbayDisconnect(int connectionId)
  619. {
  620. if (fClient == nullptr)
  621. return;
  622. for (int i=0, count=fUsedConnections.count(); i < count; i++)
  623. {
  624. if (fUsedConnections[i].id == connectionId)
  625. {
  626. const char* const portNameA = getFullPortName(fUsedConnections[i].portOut).toUtf8().constData();
  627. const char* const portNameB = getFullPortName(fUsedConnections[i].portIn).toUtf8().constData();
  628. jack_disconnect(fClient, portNameA, portNameB);
  629. break;
  630. }
  631. }
  632. }
  633. #endif
  634. // -------------------------------------------------------------------
  635. // Transport
  636. void transportPlay()
  637. {
  638. if (fOptions.transportMode == TRANSPORT_MODE_INTERNAL)
  639. CarlaEngine::transportPlay();
  640. else if (fClient != nullptr)
  641. jackbridge_transport_start(fClient);
  642. }
  643. void transportPause()
  644. {
  645. if (fOptions.transportMode == TRANSPORT_MODE_INTERNAL)
  646. CarlaEngine::transportPause();
  647. else if (fClient != nullptr)
  648. jackbridge_transport_stop(fClient);
  649. }
  650. void transportRelocate(const uint32_t frame)
  651. {
  652. if (fOptions.transportMode == TRANSPORT_MODE_INTERNAL)
  653. CarlaEngine::transportRelocate(frame);
  654. else if (fClient != nullptr)
  655. jackbridge_transport_locate(fClient, frame);
  656. }
  657. // -------------------------------------
  658. protected:
  659. void handleJackBufferSizeCallback(const uint32_t newBufferSize)
  660. {
  661. if (fBufferSize != newBufferSize)
  662. {
  663. fBufferSize = newBufferSize;
  664. bufferSizeChanged(newBufferSize);
  665. }
  666. }
  667. void handleJackSampleRateCallback(const double newSampleRate)
  668. {
  669. if (fSampleRate != newSampleRate)
  670. {
  671. fSampleRate = newSampleRate;
  672. sampleRateChanged(newSampleRate);
  673. }
  674. }
  675. void handleJackFreewheelCallback(const bool isFreewheel)
  676. {
  677. fFreewheel = isFreewheel;
  678. }
  679. void saveTransportInfo()
  680. {
  681. if (fOptions.transportMode != TRANSPORT_MODE_JACK)
  682. return;
  683. fTransportPos.unique_1 = fTransportPos.unique_2 + 1; // invalidate
  684. fTransportState = jackbridge_transport_query(fClient, &fTransportPos);
  685. fTimeInfo.playing = (fTransportState == JackTransportRolling);
  686. if (fTransportPos.unique_1 == fTransportPos.unique_2)
  687. {
  688. fTimeInfo.frame = fTransportPos.frame;
  689. fTimeInfo.time = fTransportPos.usecs;
  690. if (fTransportPos.valid & JackPositionBBT)
  691. {
  692. fTimeInfo.valid = EngineTimeInfo::ValidBBT;
  693. fTimeInfo.bbt.bar = fTransportPos.bar;
  694. fTimeInfo.bbt.beat = fTransportPos.beat;
  695. fTimeInfo.bbt.tick = fTransportPos.tick;
  696. fTimeInfo.bbt.barStartTick = fTransportPos.bar_start_tick;
  697. fTimeInfo.bbt.beatsPerBar = fTransportPos.beats_per_bar;
  698. fTimeInfo.bbt.beatType = fTransportPos.beat_type;
  699. fTimeInfo.bbt.ticksPerBeat = fTransportPos.ticks_per_beat;
  700. fTimeInfo.bbt.beatsPerMinute = fTransportPos.beats_per_minute;
  701. }
  702. else
  703. fTimeInfo.valid = 0x0;
  704. }
  705. else
  706. {
  707. fTimeInfo.frame = 0;
  708. fTimeInfo.valid = 0x0;
  709. }
  710. }
  711. void handleJackProcessCallback(const uint32_t nframes)
  712. {
  713. #ifndef BUILD_BRIDGE
  714. if (kData->curPluginCount == 0)
  715. {
  716. // pass-through
  717. if (fOptions.processMode == PROCESS_MODE_CONTINUOUS_RACK)
  718. {
  719. float* const audioIn1 = (float*)jackbridge_port_get_buffer(fRackPorts[rackPortAudioIn1], nframes);
  720. float* const audioIn2 = (float*)jackbridge_port_get_buffer(fRackPorts[rackPortAudioIn2], nframes);
  721. float* const audioOut1 = (float*)jackbridge_port_get_buffer(fRackPorts[rackPortAudioOut1], nframes);
  722. float* const audioOut2 = (float*)jackbridge_port_get_buffer(fRackPorts[rackPortAudioOut2], nframes);
  723. void* const eventOut = jackbridge_port_get_buffer(fRackPorts[rackPortEventOut], nframes);
  724. CARLA_ASSERT(audioIn1 != nullptr);
  725. CARLA_ASSERT(audioIn2 != nullptr);
  726. CARLA_ASSERT(audioOut1 != nullptr);
  727. CARLA_ASSERT(audioOut2 != nullptr);
  728. CARLA_ASSERT(eventOut != nullptr);
  729. carla_copyFloat(audioOut1, audioIn1, nframes);
  730. carla_copyFloat(audioOut2, audioIn2, nframes);
  731. jackbridge_midi_clear_buffer(eventOut);
  732. }
  733. return proccessPendingEvents();
  734. }
  735. #endif
  736. saveTransportInfo();
  737. #ifdef BUILD_BRIDGE
  738. CarlaPlugin* const plugin = getPluginUnchecked(0);
  739. if (plugin && plugin->enabled() && plugin->tryLock())
  740. {
  741. plugin->initBuffers();
  742. processPlugin(plugin, nframes);
  743. plugin->unlock();
  744. }
  745. #else
  746. if (fOptions.processMode == PROCESS_MODE_SINGLE_CLIENT)
  747. {
  748. for (unsigned int i=0; i < kData->curPluginCount; i++)
  749. {
  750. CarlaPlugin* const plugin = getPluginUnchecked(i);
  751. if (plugin && plugin->enabled() && plugin->tryLock())
  752. {
  753. plugin->initBuffers();
  754. processPlugin(plugin, nframes);
  755. plugin->unlock();
  756. }
  757. }
  758. }
  759. else if (fOptions.processMode == PROCESS_MODE_CONTINUOUS_RACK)
  760. {
  761. // get buffers from jack
  762. float* const audioIn1 = (float*)jackbridge_port_get_buffer(fRackPorts[rackPortAudioIn1], nframes);
  763. float* const audioIn2 = (float*)jackbridge_port_get_buffer(fRackPorts[rackPortAudioIn2], nframes);
  764. float* const audioOut1 = (float*)jackbridge_port_get_buffer(fRackPorts[rackPortAudioOut1], nframes);
  765. float* const audioOut2 = (float*)jackbridge_port_get_buffer(fRackPorts[rackPortAudioOut2], nframes);
  766. void* const eventIn = jackbridge_port_get_buffer(fRackPorts[rackPortEventIn], nframes);
  767. void* const eventOut = jackbridge_port_get_buffer(fRackPorts[rackPortEventOut], nframes);
  768. // assert buffers
  769. CARLA_ASSERT(audioIn1 != nullptr);
  770. CARLA_ASSERT(audioIn2 != nullptr);
  771. CARLA_ASSERT(audioOut1 != nullptr);
  772. CARLA_ASSERT(audioOut2 != nullptr);
  773. CARLA_ASSERT(eventIn != nullptr);
  774. CARLA_ASSERT(eventOut != nullptr);
  775. // create audio buffers
  776. float* inBuf[2] = { audioIn1, audioIn2 };
  777. float* outBuf[2] = { audioOut1, audioOut2 };
  778. // initialize input events
  779. carla_zeroMem(kData->rack.in, sizeof(EngineEvent)*RACK_EVENT_COUNT);
  780. {
  781. uint32_t engineEventIndex = 0;
  782. jack_midi_event_t jackEvent;
  783. const uint32_t jackEventCount = jackbridge_midi_get_event_count(eventIn);
  784. for (uint32_t jackEventIndex=0; jackEventIndex < jackEventCount; jackEventIndex++)
  785. {
  786. if (jackbridge_midi_event_get(&jackEvent, eventIn, jackEventIndex) != 0)
  787. continue;
  788. EngineEvent* const engineEvent = &kData->rack.in[engineEventIndex++];
  789. engineEvent->clear();
  790. const uint8_t midiStatus = MIDI_GET_STATUS_FROM_DATA(jackEvent.buffer);
  791. const uint8_t midiChannel = MIDI_GET_CHANNEL_FROM_DATA(jackEvent.buffer);
  792. engineEvent->time = jackEvent.time;
  793. engineEvent->channel = midiChannel;
  794. if (MIDI_IS_STATUS_CONTROL_CHANGE(midiStatus))
  795. {
  796. const uint8_t midiControl = jackEvent.buffer[1];
  797. engineEvent->type = kEngineEventTypeControl;
  798. if (MIDI_IS_CONTROL_BANK_SELECT(midiControl))
  799. {
  800. const uint8_t midiBank = jackEvent.buffer[2];
  801. engineEvent->ctrl.type = kEngineControlEventTypeMidiBank;
  802. engineEvent->ctrl.param = midiBank;
  803. engineEvent->ctrl.value = 0.0;
  804. }
  805. else if (midiControl == MIDI_CONTROL_ALL_SOUND_OFF)
  806. {
  807. engineEvent->ctrl.type = kEngineControlEventTypeAllSoundOff;
  808. engineEvent->ctrl.param = 0;
  809. engineEvent->ctrl.value = 0.0;
  810. }
  811. else if (midiControl == MIDI_CONTROL_ALL_NOTES_OFF)
  812. {
  813. engineEvent->ctrl.type = kEngineControlEventTypeAllNotesOff;
  814. engineEvent->ctrl.param = 0;
  815. engineEvent->ctrl.value = 0.0;
  816. }
  817. else
  818. {
  819. const uint8_t midiValue = jackEvent.buffer[2];
  820. engineEvent->ctrl.type = kEngineControlEventTypeParameter;
  821. engineEvent->ctrl.param = midiControl;
  822. engineEvent->ctrl.value = double(midiValue)/127.0;
  823. }
  824. }
  825. else if (MIDI_IS_STATUS_PROGRAM_CHANGE(midiStatus))
  826. {
  827. const uint8_t midiProgram = jackEvent.buffer[1];
  828. engineEvent->type = kEngineEventTypeControl;
  829. engineEvent->ctrl.type = kEngineControlEventTypeMidiProgram;
  830. engineEvent->ctrl.param = midiProgram;
  831. engineEvent->ctrl.value = 0.0;
  832. }
  833. else
  834. {
  835. engineEvent->type = kEngineEventTypeMidi;
  836. engineEvent->midi.data[0] = midiStatus;
  837. engineEvent->midi.data[1] = jackEvent.buffer[1];
  838. engineEvent->midi.data[2] = jackEvent.buffer[2];
  839. engineEvent->midi.size = static_cast<uint8_t>(jackEvent.size);
  840. }
  841. if (engineEventIndex >= RACK_EVENT_COUNT)
  842. break;
  843. }
  844. }
  845. // process rack
  846. processRack(inBuf, outBuf, nframes);
  847. // output control
  848. {
  849. jackbridge_midi_clear_buffer(eventOut);
  850. for (unsigned short i=0; i < RACK_EVENT_COUNT; i++)
  851. {
  852. EngineEvent* const engineEvent = &kData->rack.out[i];
  853. uint8_t data[3] = { 0 };
  854. uint8_t size = 0;
  855. switch (engineEvent->type)
  856. {
  857. case kEngineEventTypeNull:
  858. break;
  859. case kEngineEventTypeControl:
  860. {
  861. EngineControlEvent* const ctrlEvent = &engineEvent->ctrl;
  862. if (ctrlEvent->type == kEngineControlEventTypeParameter && MIDI_IS_CONTROL_BANK_SELECT(ctrlEvent->param))
  863. {
  864. // FIXME?
  865. ctrlEvent->type = kEngineControlEventTypeMidiBank;
  866. ctrlEvent->param = ctrlEvent->value;
  867. ctrlEvent->value = 0.0;
  868. }
  869. switch (ctrlEvent->type)
  870. {
  871. case kEngineControlEventTypeNull:
  872. break;
  873. case kEngineControlEventTypeParameter:
  874. data[0] = MIDI_STATUS_CONTROL_CHANGE + engineEvent->channel;
  875. data[1] = static_cast<uint8_t>(ctrlEvent->param);
  876. data[2] = uint8_t(ctrlEvent->value * 127.0);
  877. size = 3;
  878. break;
  879. case kEngineControlEventTypeMidiBank:
  880. data[0] = MIDI_STATUS_CONTROL_CHANGE + engineEvent->channel;
  881. data[1] = MIDI_CONTROL_BANK_SELECT;
  882. data[2] = static_cast<uint8_t>(ctrlEvent->param);
  883. size = 3;
  884. break;
  885. case kEngineControlEventTypeMidiProgram:
  886. data[0] = MIDI_STATUS_PROGRAM_CHANGE + engineEvent->channel;
  887. data[1] = static_cast<uint8_t>(ctrlEvent->param);
  888. size = 2;
  889. break;
  890. case kEngineControlEventTypeAllSoundOff:
  891. data[0] = MIDI_STATUS_CONTROL_CHANGE + engineEvent->channel;
  892. data[1] = MIDI_CONTROL_ALL_SOUND_OFF;
  893. size = 2;
  894. break;
  895. case kEngineControlEventTypeAllNotesOff:
  896. data[0] = MIDI_STATUS_CONTROL_CHANGE + engineEvent->channel;
  897. data[1] = MIDI_CONTROL_ALL_NOTES_OFF;
  898. size = 2;
  899. break;
  900. }
  901. break;
  902. }
  903. case kEngineEventTypeMidi:
  904. {
  905. EngineMidiEvent* const midiEvent = &engineEvent->midi;
  906. data[0] = midiEvent->data[0];
  907. data[1] = midiEvent->data[1];
  908. data[2] = midiEvent->data[2];
  909. size = midiEvent->size;
  910. break;
  911. }
  912. }
  913. if (size > 0)
  914. jackbridge_midi_event_write(eventOut, engineEvent->time, data, size);
  915. }
  916. }
  917. }
  918. #endif // ! BUILD_BRIDGE
  919. proccessPendingEvents();
  920. }
  921. #if WANT_JACK_LATENCY
  922. void handleJackLatencyCallback(const jack_latency_callback_mode_t mode)
  923. {
  924. if (fOptions.processMode != PROCESS_MODE_SINGLE_CLIENT)
  925. return;
  926. for (unsigned int i=0; i < kData->curPluginCount; i++)
  927. {
  928. CarlaPlugin* const plugin = getPluginUnchecked(i);
  929. if (plugin && plugin->enabled())
  930. latencyPlugin(plugin, mode);
  931. }
  932. }
  933. #endif
  934. #ifndef BUILD_BRIDGE
  935. void handleJackClientRegistrationCallback(const char* name, bool reg)
  936. {
  937. if (reg)
  938. {
  939. GroupNameToId groupNameToId;
  940. groupNameToId.id = fLastGroupId;
  941. groupNameToId.name = name;
  942. callback(CALLBACK_PATCHBAY_CLIENT_ADDED, 0, fLastGroupId, 0, 0.0f, name);
  943. fUsedGroupNames.append(groupNameToId);
  944. fLastGroupId++;
  945. }
  946. else
  947. {
  948. for (int i=0, count=fUsedGroupNames.count(); i < count; i++)
  949. {
  950. if (fUsedGroupNames[i].name == name)
  951. {
  952. callback(CALLBACK_PATCHBAY_CLIENT_REMOVED, 0, fUsedGroupNames[i].id, 0, 0.0f, nullptr);
  953. fUsedGroupNames.takeAt(i);
  954. break;
  955. }
  956. }
  957. }
  958. }
  959. void handleJackPortRegistrationCallback(jack_port_id_t port, bool reg)
  960. {
  961. jack_port_t* jackPort = jack_port_by_id(fClient, port);
  962. QString fullName(jack_port_name(jackPort));
  963. QString groupName = fullName.split(":").at(0);
  964. int groupId = getGroupId(groupName);
  965. const char* portName = jack_port_short_name(jackPort);
  966. if (reg)
  967. {
  968. bool portIsInput = (jack_port_flags(jackPort) & JackPortIsInput);
  969. bool portIsAudio = (std::strcmp(jack_port_type(jackPort), JACK_DEFAULT_AUDIO_TYPE) == 0);
  970. unsigned int portFlags = 0x0;
  971. portFlags |= portIsInput ? PATCHBAY_PORT_IS_INPUT : PATCHBAY_PORT_IS_OUTPUT;
  972. portFlags |= portIsAudio ? PATCHBAY_PORT_IS_AUDIO : PATCHBAY_PORT_IS_MIDI;
  973. PortNameToId portNameToId;
  974. portNameToId.groupId = groupId;
  975. portNameToId.portId = fLastPortId;
  976. portNameToId.name = portName;
  977. portNameToId.fullName = fullName;
  978. fUsedPortNames.append(portNameToId);
  979. callback(CALLBACK_PATCHBAY_PORT_ADDED, 0, groupId, fLastPortId, portFlags, portName);
  980. fLastPortId++;
  981. }
  982. else
  983. {
  984. for (int i=0, count=fUsedPortNames.count(); i < count; i++)
  985. {
  986. if (fUsedPortNames[i].groupId == groupId && fUsedPortNames[i].name == portName)
  987. {
  988. callback(CALLBACK_PATCHBAY_PORT_REMOVED, 0, fUsedPortNames[i].portId, 0, 0.0f, nullptr);
  989. fUsedPortNames.takeAt(i);
  990. break;
  991. }
  992. }
  993. }
  994. }
  995. void handleJackPortConnectCallback(jack_port_id_t a, jack_port_id_t b, bool connect)
  996. {
  997. jack_port_t* jackPortA = jack_port_by_id(fClient, a);
  998. jack_port_t* jackPortB = jack_port_by_id(fClient, b);
  999. int portIdA = getPortId(QString(jack_port_name(jackPortA)));
  1000. int portIdB = getPortId(QString(jack_port_name(jackPortB)));
  1001. if (connect)
  1002. {
  1003. ConnectionToId connectionToId;
  1004. connectionToId.id = fLastConnectionId;
  1005. connectionToId.portOut = portIdA;
  1006. connectionToId.portIn = portIdB;
  1007. fUsedConnections.append(connectionToId);
  1008. callback(CALLBACK_PATCHBAY_CONNECTION_ADDED, 0, fLastConnectionId, portIdA, portIdB, nullptr);
  1009. fLastConnectionId++;
  1010. }
  1011. else
  1012. {
  1013. for (int i=0, count=fUsedConnections.count(); i < count; i++)
  1014. {
  1015. if (fUsedConnections[i].portOut == portIdA && fUsedConnections[i].portIn == portIdB)
  1016. {
  1017. callback(CALLBACK_PATCHBAY_CONNECTION_REMOVED, 0, fUsedConnections[i].id, 0, 0.0f, nullptr);
  1018. fUsedConnections.takeAt(i);
  1019. break;
  1020. }
  1021. }
  1022. }
  1023. }
  1024. void handleJackPortRenameCallback(jack_port_id_t port, const char* oldName, const char* newName)
  1025. {
  1026. jack_port_t* jackPort = jack_port_by_id(fClient, port);
  1027. QString fullName(oldName);
  1028. QString groupName = fullName.split(":").at(0);
  1029. int groupId = getGroupId(groupName);
  1030. const char* portName = jack_port_short_name(jackPort);
  1031. for (int i=0, count=fUsedPortNames.count(); i < count; i++)
  1032. {
  1033. if (fUsedPortNames[i].groupId == groupId && fUsedPortNames[i].name == portName)
  1034. {
  1035. callback(CALLBACK_PATCHBAY_PORT_RENAMED, 0, fUsedPortNames[i].portId, 0, 0.0f, newName);
  1036. fUsedPortNames[i].name = newName;
  1037. break;
  1038. }
  1039. }
  1040. }
  1041. #endif
  1042. void handleJackShutdownCallback()
  1043. {
  1044. for (unsigned int i=0; i < kData->curPluginCount; i++)
  1045. {
  1046. //CarlaPlugin* const plugin = getPluginUnchecked(i);
  1047. //if (plugin)
  1048. // plugin->x_client = nullptr;
  1049. }
  1050. fClient = nullptr;
  1051. callback(CALLBACK_QUIT, 0, 0, 0, 0.0f, nullptr);
  1052. }
  1053. // -------------------------------------
  1054. private:
  1055. jack_client_t* fClient;
  1056. jack_position_t fTransportPos;
  1057. jack_transport_state_t fTransportState;
  1058. bool fFreewheel;
  1059. // -------------------------------------
  1060. #ifdef BUILD_BRIDGE
  1061. bool fHasQuit;
  1062. #else
  1063. enum RackPorts {
  1064. rackPortAudioIn1 = 0,
  1065. rackPortAudioIn2 = 1,
  1066. rackPortAudioOut1 = 2,
  1067. rackPortAudioOut2 = 3,
  1068. rackPortEventIn = 4,
  1069. rackPortEventOut = 5,
  1070. rackPortCount = 8
  1071. };
  1072. jack_port_t* fRackPorts[rackPortCount];
  1073. struct GroupNameToId {
  1074. int id;
  1075. QString name;
  1076. };
  1077. struct PortNameToId {
  1078. int groupId;
  1079. int portId;
  1080. QString name;
  1081. QString fullName;
  1082. };
  1083. struct ConnectionToId {
  1084. int id;
  1085. int portOut;
  1086. int portIn;
  1087. };
  1088. int fLastGroupId;
  1089. int fLastPortId;
  1090. int fLastConnectionId ;
  1091. QList<GroupNameToId> fUsedGroupNames;
  1092. QList<PortNameToId> fUsedPortNames;
  1093. QList<ConnectionToId> fUsedConnections;
  1094. int getGroupId(QString groupName)
  1095. {
  1096. for (int i=0, count=fUsedGroupNames.count(); i < count; i++)
  1097. {
  1098. if (fUsedGroupNames[i].name == groupName)
  1099. {
  1100. return fUsedGroupNames[i].id;
  1101. }
  1102. }
  1103. return -1;
  1104. }
  1105. int getPortId(QString fullPortName)
  1106. {
  1107. QString groupName = fullPortName.split(":").at(0);
  1108. QString portName = fullPortName.replace(groupName+":", "");
  1109. int groupId = getGroupId(groupName);
  1110. for (int i=0, count=fUsedPortNames.count(); i < count; i++)
  1111. {
  1112. if (fUsedPortNames[i].groupId == groupId && fUsedPortNames[i].name == portName)
  1113. {
  1114. return fUsedPortNames[i].portId;
  1115. }
  1116. }
  1117. return -1;
  1118. }
  1119. QString& getFullPortName(int portId)
  1120. {
  1121. static QString fallbackString;
  1122. for (int i=0, count=fUsedPortNames.count(); i < count; i++)
  1123. {
  1124. if (fUsedPortNames[i].portId == portId)
  1125. {
  1126. return fUsedPortNames[i].fullName;
  1127. }
  1128. }
  1129. return fallbackString;
  1130. }
  1131. void initJackPatchbay(const char* const ourName)
  1132. {
  1133. // query initial jack ports
  1134. QList<QString> parsedGroups;
  1135. // our client
  1136. {
  1137. GroupNameToId groupNameToId;
  1138. groupNameToId.id = fLastGroupId;
  1139. groupNameToId.name = ourName;
  1140. callback(CALLBACK_PATCHBAY_CLIENT_ADDED, 0, fLastGroupId, 0, 0.0f, ourName);
  1141. fUsedGroupNames.append(groupNameToId);
  1142. fLastGroupId++;
  1143. parsedGroups.append(QString(ourName));
  1144. }
  1145. if (const char** ports = jack_get_ports(fClient, nullptr, nullptr, 0))
  1146. {
  1147. for (int i=0; ports[i] != nullptr; i++)
  1148. {
  1149. jack_port_t* jackPort = jack_port_by_name(fClient, ports[i]);
  1150. const char* portName = jack_port_short_name(jackPort);
  1151. QString fullName(ports[i]);
  1152. QString groupName(fullName.split(":").at(0));
  1153. int groupId = -1;
  1154. if (groupName == ourName)
  1155. continue;
  1156. if (parsedGroups.contains(groupName))
  1157. {
  1158. groupId = getGroupId(groupName);
  1159. }
  1160. else
  1161. {
  1162. groupId = fLastGroupId++;
  1163. GroupNameToId groupNameToId;
  1164. groupNameToId.id = groupId;
  1165. groupNameToId.name = groupName;
  1166. fUsedGroupNames.append(groupNameToId);
  1167. parsedGroups.append(groupName);
  1168. callback(CALLBACK_PATCHBAY_CLIENT_ADDED, 0, groupId, 0, 0.0f, groupName.toUtf8().constData());
  1169. }
  1170. bool portIsInput = (jack_port_flags(jackPort) & JackPortIsInput);
  1171. bool portIsAudio = (std::strcmp(jack_port_type(jackPort), JACK_DEFAULT_AUDIO_TYPE) == 0);
  1172. unsigned int portFlags = 0x0;
  1173. portFlags |= portIsInput ? PATCHBAY_PORT_IS_INPUT : PATCHBAY_PORT_IS_OUTPUT;
  1174. portFlags |= portIsAudio ? PATCHBAY_PORT_IS_AUDIO : PATCHBAY_PORT_IS_MIDI;
  1175. PortNameToId portNameToId;
  1176. portNameToId.groupId = groupId;
  1177. portNameToId.portId = fLastPortId;
  1178. portNameToId.name = portName;
  1179. portNameToId.fullName = fullName;
  1180. fUsedPortNames.append(portNameToId);
  1181. callback(CALLBACK_PATCHBAY_PORT_ADDED, 0, groupId, fLastPortId, portFlags, portName);
  1182. fLastPortId++;
  1183. }
  1184. jack_free(ports);
  1185. }
  1186. // query connections, after all ports are in place
  1187. if (const char** ports = jack_get_ports(fClient, nullptr, nullptr, JackPortIsOutput))
  1188. {
  1189. for (int i=0; ports[i] != nullptr; i++)
  1190. {
  1191. jack_port_t* jackPort = jack_port_by_name(fClient, ports[i]);
  1192. int thisPortId = getPortId(QString(ports[i]));
  1193. if (const char** jackConnections = jack_port_get_connections(jackPort))
  1194. {
  1195. for (int j=0; jackConnections[j] != nullptr; j++)
  1196. {
  1197. int targetPortId = getPortId(QString(jackConnections[j]));
  1198. ConnectionToId connectionToId;
  1199. connectionToId.id = fLastConnectionId;
  1200. connectionToId.portOut = thisPortId;
  1201. connectionToId.portIn = targetPortId;
  1202. fUsedConnections.append(connectionToId);
  1203. callback(CALLBACK_PATCHBAY_CONNECTION_ADDED, 0, fLastConnectionId, thisPortId, targetPortId, nullptr);
  1204. fLastConnectionId++;
  1205. }
  1206. jack_free(jackConnections);
  1207. }
  1208. }
  1209. jack_free(ports);
  1210. }
  1211. }
  1212. #endif
  1213. // -------------------------------------
  1214. void processPlugin(CarlaPlugin* const plugin, const uint32_t nframes)
  1215. {
  1216. const uint32_t inCount = plugin->audioInCount();
  1217. const uint32_t outCount = plugin->audioOutCount();
  1218. float* inBuffer[inCount];
  1219. float* outBuffer[outCount];
  1220. float inPeaks[inCount];
  1221. float outPeaks[outCount];
  1222. if (inCount > 0)
  1223. carla_zeroFloat(inPeaks, inCount);
  1224. if (outCount > 0)
  1225. carla_zeroFloat(outPeaks, outCount);
  1226. for (uint32_t i=0; i < inCount; i++)
  1227. {
  1228. CarlaEngineAudioPort* const port = CarlaPluginGetAudioInPort(plugin, i);
  1229. inBuffer[i] = port->getBuffer();
  1230. }
  1231. for (uint32_t i=0; i < outCount; i++)
  1232. {
  1233. CarlaEngineAudioPort* const port = CarlaPluginGetAudioOutPort(plugin, i);
  1234. outBuffer[i] = port->getBuffer();
  1235. }
  1236. for (uint32_t i=0; i < inCount; i++)
  1237. {
  1238. for (uint32_t j=0; j < nframes; j++)
  1239. {
  1240. const float absV = std::fabs(inBuffer[i][j]);
  1241. if (absV > inPeaks[i])
  1242. inPeaks[i] = absV;
  1243. }
  1244. }
  1245. plugin->process(inBuffer, outBuffer, nframes);
  1246. for (uint32_t i=0; i < outCount; i++)
  1247. {
  1248. for (uint32_t j=0; j < nframes; j++)
  1249. {
  1250. const float absV = std::fabs(outBuffer[i][j]);
  1251. if (absV > outPeaks[i])
  1252. outPeaks[i] = absV;
  1253. }
  1254. }
  1255. setPeaks(plugin->id(), inPeaks, outPeaks);
  1256. }
  1257. #if WANT_JACK_LATENCY
  1258. void latencyPlugin(CarlaPlugin* const plugin, jack_latency_callback_mode_t mode)
  1259. {
  1260. const uint32_t inCount = plugin->audioInCount();
  1261. const uint32_t outCount = plugin->audioOutCount();
  1262. jack_latency_range_t range;
  1263. uint32_t pluginLatency = plugin->latency();
  1264. if (pluginLatency == 0)
  1265. return;
  1266. if (mode == JackCaptureLatency)
  1267. {
  1268. for (uint32_t i=0; i < inCount; i++)
  1269. {
  1270. uint32_t aOutI = (i >= outCount) ? outCount : i;
  1271. jack_port_t* const portIn = ((CarlaEngineJackAudioPort*)CarlaPluginGetAudioInPort(plugin, i))->kPort;
  1272. jack_port_t* const portOut = ((CarlaEngineJackAudioPort*)CarlaPluginGetAudioOutPort(plugin, aOutI))->kPort;
  1273. jackbridge_port_get_latency_range(portIn, mode, &range);
  1274. range.min += pluginLatency;
  1275. range.max += pluginLatency;
  1276. jackbridge_port_set_latency_range(portOut, mode, &range);
  1277. }
  1278. }
  1279. else
  1280. {
  1281. for (uint32_t i=0; i < outCount; i++)
  1282. {
  1283. uint32_t aInI = (i >= inCount) ? inCount : i;
  1284. jack_port_t* const portIn = ((CarlaEngineJackAudioPort*)CarlaPluginGetAudioInPort(plugin, aInI))->kPort;
  1285. jack_port_t* const portOut = ((CarlaEngineJackAudioPort*)CarlaPluginGetAudioOutPort(plugin, i))->kPort;
  1286. jackbridge_port_get_latency_range(portOut, mode, &range);
  1287. range.min += pluginLatency;
  1288. range.max += pluginLatency;
  1289. jackbridge_port_set_latency_range(portIn, mode, &range);
  1290. }
  1291. }
  1292. }
  1293. #endif
  1294. // -------------------------------------
  1295. #define handlePtr ((CarlaEngineJack*)arg)
  1296. static int carla_jack_srate_callback(jack_nframes_t newSampleRate, void* arg)
  1297. {
  1298. handlePtr->handleJackSampleRateCallback(newSampleRate);
  1299. return 0;
  1300. }
  1301. static int carla_jack_bufsize_callback(jack_nframes_t newBufferSize, void* arg)
  1302. {
  1303. handlePtr->handleJackBufferSizeCallback(newBufferSize);
  1304. return 0;
  1305. }
  1306. static void carla_jack_freewheel_callback(int starting, void* arg)
  1307. {
  1308. handlePtr->handleJackFreewheelCallback(bool(starting));
  1309. }
  1310. static int carla_jack_process_callback(jack_nframes_t nframes, void* arg)
  1311. {
  1312. handlePtr->handleJackProcessCallback(nframes);
  1313. return 0;
  1314. }
  1315. #if WANT_JACK_LATENCY
  1316. static void carla_jack_latency_callback(jack_latency_callback_mode_t mode, void* arg)
  1317. {
  1318. handlePtr->handleJackLatencyCallback(mode);
  1319. }
  1320. #endif
  1321. #ifndef BUILD_BRIDGE
  1322. static void carla_jack_client_registration_callback(const char* name, int reg, void* arg)
  1323. {
  1324. handlePtr->handleJackClientRegistrationCallback(name, (reg != 0));
  1325. }
  1326. static void carla_jack_port_registration_callback(jack_port_id_t port, int reg, void* arg)
  1327. {
  1328. handlePtr->handleJackPortRegistrationCallback(port, (reg != 0));
  1329. }
  1330. static void carla_jack_port_connect_callback(jack_port_id_t a, jack_port_id_t b, int connect, void* arg)
  1331. {
  1332. handlePtr->handleJackPortConnectCallback(a, b, (connect != 0));
  1333. }
  1334. static int carla_jack_port_rename_callback(jack_port_id_t port, const char* oldName, const char* newName, void* arg)
  1335. {
  1336. handlePtr->handleJackPortRenameCallback(port, oldName, newName);
  1337. return 0;
  1338. }
  1339. #endif
  1340. static void carla_jack_shutdown_callback(void* arg)
  1341. {
  1342. handlePtr->handleJackShutdownCallback();
  1343. }
  1344. #undef handlePtr
  1345. // -------------------------------------
  1346. #ifndef BUILD_BRIDGE
  1347. static int carla_jack_process_callback_plugin(jack_nframes_t nframes, void* arg)
  1348. {
  1349. CarlaPlugin* const plugin = (CarlaPlugin*)arg;
  1350. if (plugin != nullptr && plugin->enabled() && plugin->tryLock())
  1351. {
  1352. CarlaEngineJack* const engine = (CarlaEngineJack*)CarlaPluginGetEngine(plugin);
  1353. plugin->initBuffers();
  1354. engine->saveTransportInfo();
  1355. engine->processPlugin(plugin, nframes);
  1356. plugin->unlock();
  1357. }
  1358. else
  1359. carla_stdout("Plugin not enabled or locked");
  1360. return 0;
  1361. }
  1362. # if WANT_JACK_LATENCY
  1363. static void carla_jack_latency_callback_plugin(jack_latency_callback_mode_t mode, void* arg)
  1364. {
  1365. CarlaPlugin* const plugin = (CarlaPlugin*)arg;
  1366. if (plugin != nullptr && plugin->enabled())
  1367. {
  1368. CarlaEngineJack* const engine = (CarlaEngineJack*)CarlaPluginGetEngine(plugin);
  1369. engine->latencyPlugin(plugin, mode);
  1370. }
  1371. }
  1372. # endif
  1373. #endif
  1374. CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaEngineJack)
  1375. };
  1376. // -----------------------------------------
  1377. CarlaEngine* CarlaEngine::newJack()
  1378. {
  1379. return new CarlaEngineJack();
  1380. }
  1381. // -----------------------------------------
  1382. CARLA_BACKEND_END_NAMESPACE
  1383. #endif // CARLA_ENGINE_JACK