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.

1228 lines
39KB

  1. /*
  2. * Carla JACK Engine
  3. * Copyright (C) 2011-2012 Filipe Coelho <falktx@falktx.com>
  4. *
  5. * This program is free software; you can redistribute it and/or modify
  6. * it under the terms of the GNU General Public License as published by
  7. * the Free Software Foundation; either version 2 of the License, or
  8. * 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 COPYING file
  16. */
  17. #ifdef CARLA_ENGINE_JACK
  18. #include "carla_engine_internal.hpp"
  19. #include "carla_backend_utils.hpp"
  20. #include "carla_midi.h"
  21. #include "jackbridge/jackbridge.h"
  22. CARLA_BACKEND_START_NAMESPACE
  23. #if 0
  24. } // Fix editor indentation
  25. #endif
  26. // -------------------------------------------------------------------------------------------------------------------
  27. // Engine port (JackAudio)
  28. class CarlaEngineJackAudioPort : public CarlaEngineAudioPort
  29. {
  30. public:
  31. CarlaEngineJackAudioPort(const bool isInput, const ProcessMode processMode, jack_client_t* const client, jack_port_t* const port)
  32. : CarlaEngineAudioPort(isInput, processMode),
  33. m_client(client),
  34. m_port(port)
  35. {
  36. qDebug("CarlaEngineJackAudioPort::CarlaEngineJackAudioPort(%s, %s, %p, %p)", bool2str(isInput), ProcessMode2Str(processMode), client, port);
  37. if (processMode == PROCESS_MODE_SINGLE_CLIENT || processMode == PROCESS_MODE_MULTIPLE_CLIENTS)
  38. CARLA_ASSERT(m_client && m_port);
  39. else
  40. CARLA_ASSERT(! (m_client || m_port));
  41. }
  42. ~CarlaEngineJackAudioPort()
  43. {
  44. qDebug("CarlaEngineJackAudioPort::~CarlaEngineJackAudioPort()");
  45. if (m_client && m_port)
  46. jackbridge_port_unregister(m_client, m_port);
  47. }
  48. void initBuffer(CarlaEngine* const engine)
  49. {
  50. CARLA_ASSERT(engine);
  51. if (! engine)
  52. {
  53. buffer = nullptr;
  54. return;
  55. }
  56. if (! m_port)
  57. return CarlaEngineAudioPort::initBuffer(engine);
  58. //buffer = jackbridge_port_get_buffer(m_port, engine->getBufferSize());
  59. }
  60. float* getBuffer() const
  61. {
  62. return (float*)buffer;
  63. }
  64. private:
  65. jack_client_t* const m_client;
  66. jack_port_t* const m_port;
  67. CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaEngineJackAudioPort)
  68. };
  69. // -------------------------------------------------------------------------------------------------------------------
  70. // Engine port (JackControl)
  71. class CarlaEngineJackControlPort : public CarlaEngineControlPort
  72. {
  73. public:
  74. CarlaEngineJackControlPort(const bool isInput, const ProcessMode processMode, jack_client_t* const client, jack_port_t* const port)
  75. : CarlaEngineControlPort(isInput, processMode),
  76. m_client(client),
  77. m_port(port)
  78. {
  79. qDebug("CarlaEngineJackControlPort::CarlaEngineJackControlPort(%s, %s, %p, %p)", bool2str(isInput), ProcessMode2Str(processMode), client, port);
  80. if (processMode == PROCESS_MODE_SINGLE_CLIENT || processMode == PROCESS_MODE_MULTIPLE_CLIENTS)
  81. CARLA_ASSERT(m_client && m_port);
  82. else
  83. CARLA_ASSERT(! (m_client || m_port));
  84. }
  85. ~CarlaEngineJackControlPort()
  86. {
  87. qDebug("CarlaEngineJackControlPort::~CarlaEngineJackControlPort()");
  88. if (m_client && m_port)
  89. jackbridge_port_unregister(m_client, m_port);
  90. }
  91. void initBuffer(CarlaEngine* const engine)
  92. {
  93. CARLA_ASSERT(engine);
  94. if (! engine)
  95. {
  96. buffer = nullptr;
  97. return;
  98. }
  99. if (! m_port)
  100. return CarlaEngineControlPort::initBuffer(engine);
  101. //buffer = jackbridge_port_get_buffer(m_port, engine->getBufferSize());
  102. if (! isInput)
  103. jackbridge_midi_clear_buffer(buffer);
  104. }
  105. uint32_t getEventCount()
  106. {
  107. if (! m_port)
  108. return CarlaEngineControlPort::getEventCount();
  109. if (! isInput)
  110. return 0;
  111. CARLA_ASSERT(buffer);
  112. if (! buffer)
  113. return 0;
  114. return jackbridge_midi_get_event_count(buffer);
  115. }
  116. const CarlaEngineControlEvent* getEvent(const uint32_t index)
  117. {
  118. if (! m_port)
  119. return CarlaEngineControlPort::getEvent(index);
  120. if (! isInput)
  121. return nullptr;
  122. CARLA_ASSERT(buffer);
  123. if (! buffer)
  124. return nullptr;
  125. jack_midi_event_t jackEvent;
  126. if (jackbridge_midi_event_get(&jackEvent, buffer, index) != 0)
  127. return nullptr;
  128. const uint8_t midiStatus = jackEvent.buffer[0];
  129. const uint8_t midiChannel = midiStatus & 0x0F;
  130. m_retEvent.clear();
  131. m_retEvent.time = jackEvent.time;
  132. m_retEvent.channel = midiChannel;
  133. if (MIDI_IS_STATUS_CONTROL_CHANGE(midiStatus))
  134. {
  135. const uint8_t midiControl = jackEvent.buffer[1];
  136. if (MIDI_IS_CONTROL_BANK_SELECT(midiControl))
  137. {
  138. const uint8_t midiBank = jackEvent.buffer[2];
  139. m_retEvent.type = CarlaEngineControlEventTypeMidiBankChange;
  140. m_retEvent.value = midiBank;
  141. }
  142. else if (midiControl == MIDI_CONTROL_ALL_SOUND_OFF)
  143. {
  144. m_retEvent.type = CarlaEngineControlEventTypeAllSoundOff;
  145. }
  146. else if (midiControl == MIDI_CONTROL_ALL_NOTES_OFF)
  147. {
  148. m_retEvent.type = CarlaEngineControlEventTypeAllNotesOff;
  149. }
  150. else
  151. {
  152. const uint8_t midiValue = jackEvent.buffer[2];
  153. m_retEvent.type = CarlaEngineControlEventTypeParameterChange;
  154. m_retEvent.parameter = midiControl;
  155. m_retEvent.value = double(midiValue)/127;
  156. }
  157. return &m_retEvent;
  158. }
  159. if (MIDI_IS_STATUS_PROGRAM_CHANGE(midiStatus))
  160. {
  161. const uint8_t midiProgram = jackEvent.buffer[1];
  162. m_retEvent.type = CarlaEngineControlEventTypeMidiProgramChange;
  163. m_retEvent.value = midiProgram;
  164. return &m_retEvent;
  165. }
  166. return nullptr;
  167. }
  168. void writeEvent(const CarlaEngineControlEventType type, const uint32_t time, const uint8_t channel, const uint16_t parameter, const double value)
  169. {
  170. if (! m_port)
  171. return CarlaEngineControlPort::writeEvent(type, time, channel, parameter, value);
  172. if (isInput)
  173. return;
  174. CARLA_ASSERT(buffer);
  175. CARLA_ASSERT(type != CarlaEngineControlEventTypeNull);
  176. CARLA_ASSERT(channel < 16);
  177. if (! buffer)
  178. return;
  179. if (type == CarlaEngineControlEventTypeNull)
  180. return;
  181. if (type == CarlaEngineControlEventTypeParameterChange)
  182. CARLA_ASSERT(! MIDI_IS_CONTROL_BANK_SELECT(parameter));
  183. if (channel >= 16)
  184. return;
  185. uint8_t data[3] = { 0 };
  186. uint8_t size = 0;
  187. switch (type)
  188. {
  189. case CarlaEngineControlEventTypeNull:
  190. break;
  191. case CarlaEngineControlEventTypeParameterChange:
  192. data[0] = MIDI_STATUS_CONTROL_CHANGE + channel;
  193. data[1] = parameter;
  194. data[2] = value * 127;
  195. size = 3;
  196. break;
  197. case CarlaEngineControlEventTypeMidiBankChange:
  198. data[0] = MIDI_STATUS_CONTROL_CHANGE + channel;
  199. data[1] = MIDI_CONTROL_BANK_SELECT;
  200. data[2] = value;
  201. size = 3;
  202. break;
  203. case CarlaEngineControlEventTypeMidiProgramChange:
  204. data[0] = MIDI_STATUS_PROGRAM_CHANGE + channel;
  205. data[1] = value;
  206. size = 2;
  207. break;
  208. case CarlaEngineControlEventTypeAllSoundOff:
  209. data[0] = MIDI_STATUS_CONTROL_CHANGE + channel;
  210. data[1] = MIDI_CONTROL_ALL_SOUND_OFF;
  211. size = 2;
  212. break;
  213. case CarlaEngineControlEventTypeAllNotesOff:
  214. data[0] = MIDI_STATUS_CONTROL_CHANGE + channel;
  215. data[1] = MIDI_CONTROL_ALL_NOTES_OFF;
  216. size = 2;
  217. break;
  218. }
  219. if (size > 0)
  220. jackbridge_midi_event_write(buffer, time, data, size);
  221. }
  222. private:
  223. jack_client_t* const m_client;
  224. jack_port_t* const m_port;
  225. CarlaEngineControlEvent m_retEvent;
  226. CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaEngineJackControlPort)
  227. };
  228. // -------------------------------------------------------------------------------------------------------------------
  229. // Engine port (JackMIDI)
  230. class CarlaEngineJackMidiPort : public CarlaEngineMidiPort
  231. {
  232. public:
  233. CarlaEngineJackMidiPort(const bool isInput, const ProcessMode processMode, jack_client_t* const client, jack_port_t* const port)
  234. : CarlaEngineMidiPort(isInput, processMode),
  235. m_client(client),
  236. m_port(port)
  237. {
  238. qDebug("CarlaEngineJackMidiPort::CarlaEngineJackMidiPort(%s, %s, %p, %p)", bool2str(isInput), ProcessMode2Str(processMode), client, port);
  239. if (processMode == PROCESS_MODE_SINGLE_CLIENT || processMode == PROCESS_MODE_MULTIPLE_CLIENTS)
  240. CARLA_ASSERT(m_client && m_port);
  241. else
  242. CARLA_ASSERT(! (m_client || m_port));
  243. }
  244. ~CarlaEngineJackMidiPort()
  245. {
  246. qDebug("CarlaEngineJackMidiPort::~CarlaEngineJackMidiPort()");
  247. if (m_client && m_port)
  248. jackbridge_port_unregister(m_client, m_port);
  249. }
  250. void initBuffer(CarlaEngine* const engine)
  251. {
  252. CARLA_ASSERT(engine);
  253. if (! engine)
  254. {
  255. buffer = nullptr;
  256. return;
  257. }
  258. if (! m_port)
  259. return CarlaEngineMidiPort::initBuffer(engine);
  260. //buffer = jackbridge_port_get_buffer(m_port, engine->getBufferSize());
  261. if (! isInput)
  262. jackbridge_midi_clear_buffer(buffer);
  263. }
  264. uint32_t getEventCount()
  265. {
  266. if (! m_port)
  267. return CarlaEngineMidiPort::getEventCount();
  268. if (! isInput)
  269. return 0;
  270. CARLA_ASSERT(buffer);
  271. return jackbridge_midi_get_event_count(buffer);
  272. }
  273. const CarlaEngineMidiEvent* getEvent(const uint32_t index)
  274. {
  275. if (! m_port)
  276. return CarlaEngineMidiPort::getEvent(index);
  277. if (! isInput)
  278. return nullptr;
  279. CARLA_ASSERT(buffer);
  280. if (! buffer)
  281. return nullptr;
  282. jack_midi_event_t jackEvent;
  283. if (jackbridge_midi_event_get(&jackEvent, buffer, index) != 0 || jackEvent.size > 3)
  284. return nullptr;
  285. m_retEvent.clear();
  286. m_retEvent.time = jackEvent.time;
  287. m_retEvent.size = jackEvent.size;
  288. memcpy(m_retEvent.data, jackEvent.buffer, jackEvent.size);
  289. return &m_retEvent;
  290. }
  291. void writeEvent(const uint32_t time, const uint8_t* const data, const uint8_t size)
  292. {
  293. if (! m_port)
  294. return CarlaEngineMidiPort::writeEvent(time, data, size);
  295. if (isInput)
  296. return;
  297. CARLA_ASSERT(buffer);
  298. CARLA_ASSERT(data);
  299. CARLA_ASSERT(size > 0);
  300. if (! (buffer && data && size > 0))
  301. return;
  302. jackbridge_midi_event_write(buffer, time, data, size);
  303. }
  304. private:
  305. jack_client_t* const m_client;
  306. jack_port_t* const m_port;
  307. CarlaEngineMidiEvent m_retEvent;
  308. CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaEngineJackMidiPort)
  309. };
  310. // -------------------------------------------------------------------------------------------------------------------
  311. // Jack Engine client
  312. class CarlaEngineJackClient : public CarlaEngineClient
  313. {
  314. public:
  315. CarlaEngineJackClient(const CarlaEngineType engineType, const ProcessMode processMode, jack_client_t* const client)
  316. : CarlaEngineClient(engineType, processMode),
  317. m_client(client),
  318. m_usesClient(processMode == PROCESS_MODE_SINGLE_CLIENT || processMode == PROCESS_MODE_MULTIPLE_CLIENTS)
  319. {
  320. qDebug("CarlaEngineJackClient::CarlaEngineJackClient(%s, %s, %p)", CarlaEngineType2Str(engineType), ProcessMode2Str(processMode), client);
  321. if (m_usesClient)
  322. CARLA_ASSERT(m_client);
  323. else
  324. CARLA_ASSERT(! m_client);
  325. }
  326. ~CarlaEngineJackClient()
  327. {
  328. qDebug("CarlaEngineClient::~CarlaEngineClient()");
  329. if (processMode == PROCESS_MODE_MULTIPLE_CLIENTS)
  330. {
  331. if (m_client)
  332. jackbridge_client_close(m_client);
  333. }
  334. }
  335. void activate()
  336. {
  337. qDebug("CarlaEngineClient::activate()");
  338. if (processMode == PROCESS_MODE_MULTIPLE_CLIENTS)
  339. {
  340. if (m_client && ! isActive())
  341. jackbridge_activate(m_client);
  342. }
  343. CarlaEngineClient::activate();
  344. }
  345. void deactivate()
  346. {
  347. qDebug("CarlaEngineClient::deactivate()");
  348. if (processMode == PROCESS_MODE_MULTIPLE_CLIENTS)
  349. {
  350. if (m_client && isActive())
  351. jackbridge_deactivate(m_client);
  352. }
  353. CarlaEngineClient::deactivate();
  354. }
  355. bool isOk() const
  356. {
  357. qDebug("CarlaEngineClient::isOk()");
  358. if (m_usesClient)
  359. return bool(m_client);
  360. return CarlaEngineClient::isOk();
  361. }
  362. void setLatency(const uint32_t samples)
  363. {
  364. CarlaEngineClient::setLatency(samples);
  365. if (m_usesClient)
  366. jackbridge_recompute_total_latencies(m_client);
  367. }
  368. const CarlaEnginePort* addPort(const CarlaEnginePortType portType, const char* const name, const bool isInput)
  369. {
  370. qDebug("CarlaJackEngineClient::addPort(%s, \"%s\", %s)", CarlaEnginePortType2Str(portType), name, bool2str(isInput));
  371. jack_port_t* port = nullptr;
  372. // Create Jack port if needed
  373. if (m_usesClient)
  374. {
  375. switch (portType)
  376. {
  377. case CarlaEnginePortTypeNull:
  378. break;
  379. case CarlaEnginePortTypeAudio:
  380. port = jackbridge_port_register(m_client, name, JACK_DEFAULT_AUDIO_TYPE, isInput ? JackPortIsInput : JackPortIsOutput, 0);
  381. break;
  382. case CarlaEnginePortTypeControl:
  383. case CarlaEnginePortTypeMIDI:
  384. port = jackbridge_port_register(m_client, name, JACK_DEFAULT_MIDI_TYPE, isInput ? JackPortIsInput : JackPortIsOutput, 0);
  385. break;
  386. }
  387. }
  388. // Create Engine port
  389. switch (portType)
  390. {
  391. case CarlaEnginePortTypeNull:
  392. break;
  393. case CarlaEnginePortTypeAudio:
  394. return new CarlaEngineJackAudioPort(isInput, processMode, m_client, port);
  395. case CarlaEnginePortTypeControl:
  396. return new CarlaEngineJackControlPort(isInput, processMode, m_client, port);
  397. case CarlaEnginePortTypeMIDI:
  398. return new CarlaEngineJackMidiPort(isInput, processMode, m_client, port);
  399. }
  400. qCritical("CarlaJackEngineClient::addPort(%i, \"%s\", %s) - invalid type", portType, name, bool2str(isInput));
  401. return nullptr;
  402. }
  403. private:
  404. jack_client_t* const m_client;
  405. const bool m_usesClient;
  406. CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaEngineJackClient)
  407. };
  408. // -------------------------------------------------------------------------------------------------------------------
  409. // Jack Engine
  410. class CarlaEngineJack : public CarlaEngine
  411. {
  412. public:
  413. CarlaEngineJack()
  414. : CarlaEngine()
  415. #ifndef BUILD_BRIDGE
  416. , m_rackPorts{nullptr}
  417. #endif
  418. {
  419. qDebug("CarlaEngineJack::CarlaEngineJack()");
  420. m_client = nullptr;
  421. m_state = JackTransportStopped;
  422. m_freewheel = false;
  423. memset(&m_pos, 0, sizeof(jack_position_t));
  424. #ifdef BUILD_BRIDGE
  425. hasQuit = false;
  426. #endif
  427. }
  428. ~CarlaEngineJack()
  429. {
  430. qDebug("CarlaEngineJack::~CarlaEngineJack()");
  431. CARLA_ASSERT(! m_client);
  432. }
  433. // -------------------------------------------------------------------
  434. // Maximum values
  435. int maxClientNameSize()
  436. {
  437. #ifndef BUILD_BRIDGE
  438. if (options.processMode == PROCESS_MODE_SINGLE_CLIENT || options.processMode == PROCESS_MODE_MULTIPLE_CLIENTS)
  439. #endif
  440. return jackbridge_client_name_size() - 3; // reserve space for "_2" forced-stereo ports
  441. return CarlaEngine::maxClientNameSize();
  442. }
  443. int maxPortNameSize()
  444. {
  445. #ifndef BUILD_BRIDGE
  446. if (options.processMode == PROCESS_MODE_SINGLE_CLIENT || options.processMode == PROCESS_MODE_MULTIPLE_CLIENTS)
  447. #endif
  448. return jackbridge_port_name_size();
  449. return CarlaEngine::maxPortNameSize();
  450. }
  451. // -------------------------------------------------------------------
  452. // Virtual, per-engine type calls
  453. bool init(const char* const clientName)
  454. {
  455. qDebug("CarlaEngineJack::init(\"%s\")", clientName);
  456. #if 0
  457. m_state = JackTransportStopped;
  458. m_freewheel = false;
  459. #ifndef BUILD_BRIDGE
  460. m_client = jackbridge_client_open(clientName, JackNullOption, nullptr);
  461. if (m_client)
  462. {
  463. bufferSize = jackbridge_get_buffer_size(m_client);
  464. sampleRate = jackbridge_get_sample_rate(m_client);
  465. jackbridge_set_buffer_size_callback(m_client, carla_jack_bufsize_callback, this);
  466. jackbridge_set_sample_rate_callback(m_client, carla_jack_srate_callback, this);
  467. jackbridge_set_freewheel_callback(m_client, carla_jack_freewheel_callback, this);
  468. jackbridge_set_process_callback(m_client, carla_jack_process_callback, this);
  469. jackbridge_set_latency_callback(m_client, carla_jack_latency_callback, this);
  470. jackbridge_on_shutdown(m_client, carla_jack_shutdown_callback, this);
  471. if (options.processMode == PROCESS_MODE_CONTINUOUS_RACK)
  472. {
  473. m_rackPorts[rackPortAudioIn1] = jackbridge_port_register(m_client, "in1", JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0);
  474. m_rackPorts[rackPortAudioIn2] = jackbridge_port_register(m_client, "in2", JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0);
  475. m_rackPorts[rackPortAudioOut1] = jackbridge_port_register(m_client, "out1", JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0);
  476. m_rackPorts[rackPortAudioOut2] = jackbridge_port_register(m_client, "out2", JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0);
  477. m_rackPorts[rackPortControlIn] = jackbridge_port_register(m_client, "control-in", JACK_DEFAULT_MIDI_TYPE, JackPortIsInput, 0);
  478. m_rackPorts[rackPortControlOut] = jackbridge_port_register(m_client, "control-out", JACK_DEFAULT_MIDI_TYPE, JackPortIsOutput, 0);
  479. m_rackPorts[rackPortMidiIn] = jackbridge_port_register(m_client, "midi-in", JACK_DEFAULT_MIDI_TYPE, JackPortIsInput, 0);
  480. m_rackPorts[rackPortMidiOut] = jackbridge_port_register(m_client, "midi-out", JACK_DEFAULT_MIDI_TYPE, JackPortIsOutput, 0);
  481. }
  482. if (jackbridge_activate(m_client) == 0)
  483. {
  484. name = jackbridge_get_client_name(m_client);
  485. name.toBasic();
  486. CarlaEngine::init(name);
  487. return true;
  488. }
  489. else
  490. {
  491. setLastError("Failed to activate the JACK client");
  492. m_client = nullptr;
  493. }
  494. }
  495. else
  496. setLastError("Failed to create new JACK client");
  497. return false;
  498. #else
  499. // open temp client to get initial buffer-size and sample-rate values
  500. if (bufferSize == 0 || sampleRate == 0.0)
  501. {
  502. m_client = jackbridge_client_open(clientName, JackNullOption, nullptr);
  503. if (m_client)
  504. {
  505. bufferSize = jackbridge_get_buffer_size(m_client);
  506. sampleRate = jackbridge_get_sample_rate(m_client);
  507. jackbridge_client_close(m_client);
  508. m_client = nullptr;
  509. }
  510. }
  511. name = clientName;
  512. name.toBasic();
  513. CarlaEngine::init(name);
  514. return true;
  515. #endif
  516. #endif
  517. return false;
  518. }
  519. bool close()
  520. {
  521. qDebug("CarlaEngineJack::close()");
  522. CarlaEngine::close();
  523. #if 0
  524. #ifdef BUILD_BRIDGE
  525. hasQuit = true;
  526. m_client = nullptr;
  527. return true;
  528. #else
  529. if (jackbridge_deactivate(m_client) == 0)
  530. {
  531. if (options.processMode == PROCESS_MODE_CONTINUOUS_RACK)
  532. {
  533. jackbridge_port_unregister(m_client, m_rackPorts[rackPortAudioIn1]);
  534. jackbridge_port_unregister(m_client, m_rackPorts[rackPortAudioIn2]);
  535. jackbridge_port_unregister(m_client, m_rackPorts[rackPortAudioOut1]);
  536. jackbridge_port_unregister(m_client, m_rackPorts[rackPortAudioOut2]);
  537. jackbridge_port_unregister(m_client, m_rackPorts[rackPortControlIn]);
  538. jackbridge_port_unregister(m_client, m_rackPorts[rackPortControlOut]);
  539. jackbridge_port_unregister(m_client, m_rackPorts[rackPortMidiIn]);
  540. jackbridge_port_unregister(m_client, m_rackPorts[rackPortMidiOut]);
  541. }
  542. if (jackbridge_client_close(m_client) == 0)
  543. {
  544. m_client = nullptr;
  545. return true;
  546. }
  547. else
  548. setLastError("Failed to close the JACK client");
  549. }
  550. else
  551. setLastError("Failed to deactivate the JACK client");
  552. m_client = nullptr;
  553. #endif
  554. #endif
  555. return false;
  556. }
  557. bool isRunning() const
  558. {
  559. #ifdef BUILD_BRIDGE
  560. return bool(m_client || ! hasQuit);
  561. #else
  562. return bool(m_client);
  563. #endif
  564. }
  565. bool isOffline() const
  566. {
  567. return m_freewheel;
  568. }
  569. CarlaEngineType type() const
  570. {
  571. return CarlaEngineTypeJack;
  572. }
  573. CarlaEngineClient* addClient(CarlaPlugin* const plugin)
  574. {
  575. jack_client_t* client = nullptr;
  576. #if 0
  577. #ifdef BUILD_BRIDGE
  578. client = m_client = jackbridge_client_open(plugin->name(), JackNullOption, nullptr);
  579. bufferSize = jackbridge_get_buffer_size(client);
  580. sampleRate = jackbridge_get_sample_rate(client);
  581. jackbridge_set_buffer_size_callback(client, carla_jack_bufsize_callback, this);
  582. jackbridge_set_sample_rate_callback(client, carla_jack_srate_callback, this);
  583. jackbridge_set_freewheel_callback(client, carla_jack_freewheel_callback, this);
  584. jackbridge_set_process_callback(client, carla_jack_process_callback, this);
  585. jackbridge_set_latency_callback(client, carla_jack_latency_callback, this);
  586. jackbridge_on_shutdown(client, carla_jack_shutdown_callback, this);
  587. #else
  588. if (options.processMode == PROCESS_MODE_SINGLE_CLIENT)
  589. {
  590. client = m_client;
  591. }
  592. else if (options.processMode == PROCESS_MODE_MULTIPLE_CLIENTS)
  593. {
  594. client = jackbridge_client_open(plugin->name(), JackNullOption, nullptr);
  595. jackbridge_set_process_callback(client, carla_jack_process_callback_plugin, plugin);
  596. jackbridge_set_latency_callback(client, carla_jack_latency_callback_plugin, plugin);
  597. }
  598. #endif
  599. #endif
  600. #ifdef BUILD_BRIDGE
  601. return new CarlaEngineJackClient(CarlaEngineTypeJack, PROCESS_MODE_MULTIPLE_CLIENTS, client);
  602. #else
  603. return new CarlaEngineJackClient(CarlaEngineTypeJack, options.processMode, client);
  604. #endif
  605. }
  606. #if 0
  607. // -------------------------------------
  608. protected:
  609. void handleJackBufferSizeCallback(const uint32_t newBufferSize)
  610. {
  611. bufferSize = newBufferSize;
  612. #ifndef BUILD_BRIDGE
  613. if (options.processHighPrecision)
  614. return;
  615. #endif
  616. bufferSizeChanged(newBufferSize);
  617. }
  618. void handleJackSampleRateCallback(const double newSampleRate)
  619. {
  620. sampleRate = newSampleRate;
  621. }
  622. void handleJackFreewheelCallback(const bool isFreewheel)
  623. {
  624. m_freewheel = isFreewheel;
  625. }
  626. void handleJackProcessCallback(const uint32_t nframes)
  627. {
  628. #ifndef BUILD_BRIDGE
  629. if (maxPluginNumber() == 0)
  630. return;
  631. #endif
  632. m_pos.unique_1 = m_pos.unique_2 + 1; // invalidate
  633. m_state = jackbridge_transport_query(m_client, &m_pos);
  634. timeInfo.playing = (m_state != JackTransportStopped);
  635. if (m_pos.unique_1 == m_pos.unique_2)
  636. {
  637. timeInfo.frame = m_pos.frame;
  638. timeInfo.time = m_pos.usecs;
  639. if (m_pos.valid & JackPositionBBT)
  640. {
  641. timeInfo.valid = timeInfo.ValidBBT;
  642. timeInfo.bbt.bar = m_pos.bar;
  643. timeInfo.bbt.beat = m_pos.beat;
  644. timeInfo.bbt.tick = m_pos.tick;
  645. timeInfo.bbt.barStartTick = m_pos.bar_start_tick;
  646. timeInfo.bbt.beatsPerBar = m_pos.beats_per_bar;
  647. timeInfo.bbt.beatType = m_pos.beat_type;
  648. timeInfo.bbt.ticksPerBeat = m_pos.ticks_per_beat;
  649. timeInfo.bbt.beatsPerMinute = m_pos.beats_per_minute;
  650. }
  651. else
  652. timeInfo.valid = 0;
  653. }
  654. else
  655. {
  656. timeInfo.frame = 0;
  657. timeInfo.valid = 0;
  658. }
  659. #ifndef BUILD_BRIDGE
  660. if (options.processMode == PROCESS_MODE_SINGLE_CLIENT)
  661. {
  662. for (unsigned short i=0, max=maxPluginNumber(); i < max; i++)
  663. {
  664. CarlaPlugin* const plugin = getPluginUnchecked(i);
  665. #else
  666. CarlaPlugin* const plugin = getPluginUnchecked(0);
  667. #endif
  668. if (plugin && plugin->enabled())
  669. {
  670. processLock();
  671. plugin->initBuffers();
  672. processPlugin(plugin, nframes);
  673. processUnlock();
  674. }
  675. #ifndef BUILD_BRIDGE
  676. }
  677. }
  678. else if (options.processMode == PROCESS_MODE_CONTINUOUS_RACK)
  679. {
  680. // get buffers from jack
  681. float* audioIn1 = (float*)jackbridge_port_get_buffer(m_rackPorts[rackPortAudioIn1], nframes);
  682. float* audioIn2 = (float*)jackbridge_port_get_buffer(m_rackPorts[rackPortAudioIn2], nframes);
  683. float* audioOut1 = (float*)jackbridge_port_get_buffer(m_rackPorts[rackPortAudioOut1], nframes);
  684. float* audioOut2 = (float*)jackbridge_port_get_buffer(m_rackPorts[rackPortAudioOut2], nframes);
  685. void* controlIn = jackbridge_port_get_buffer(m_rackPorts[rackPortControlIn], nframes);
  686. void* controlOut = jackbridge_port_get_buffer(m_rackPorts[rackPortControlOut], nframes);
  687. void* midiIn = jackbridge_port_get_buffer(m_rackPorts[rackPortMidiIn], nframes);
  688. void* midiOut = jackbridge_port_get_buffer(m_rackPorts[rackPortMidiOut], nframes);
  689. // assert buffers
  690. CARLA_ASSERT(audioIn1);
  691. CARLA_ASSERT(audioIn2);
  692. CARLA_ASSERT(audioOut1);
  693. CARLA_ASSERT(audioOut2);
  694. CARLA_ASSERT(controlIn);
  695. CARLA_ASSERT(controlOut);
  696. CARLA_ASSERT(midiIn);
  697. CARLA_ASSERT(midiOut);
  698. // create audio buffers
  699. float* inBuf[2] = { audioIn1, audioIn2 };
  700. float* outBuf[2] = { audioOut1, audioOut2 };
  701. // initialize control input
  702. memset(rackControlEventsIn, 0, sizeof(CarlaEngineControlEvent)*MAX_CONTROL_EVENTS);
  703. {
  704. jack_midi_event_t jackEvent;
  705. const uint32_t jackEventCount = jackbridge_midi_get_event_count(controlIn);
  706. uint32_t carlaEventIndex = 0;
  707. for (uint32_t jackEventIndex=0; jackEventIndex < jackEventCount; jackEventIndex++)
  708. {
  709. if (jackbridge_midi_event_get(&jackEvent, controlIn, jackEventIndex) != 0)
  710. continue;
  711. CarlaEngineControlEvent* const carlaEvent = &rackControlEventsIn[carlaEventIndex++];
  712. const uint8_t midiStatus = jackEvent.buffer[0];
  713. const uint8_t midiChannel = midiStatus & 0x0F;
  714. carlaEvent->time = jackEvent.time;
  715. carlaEvent->channel = midiChannel;
  716. if (MIDI_IS_STATUS_CONTROL_CHANGE(midiStatus))
  717. {
  718. const uint8_t midiControl = jackEvent.buffer[1];
  719. if (MIDI_IS_CONTROL_BANK_SELECT(midiControl))
  720. {
  721. const uint8_t midiBank = jackEvent.buffer[2];
  722. carlaEvent->type = CarlaEngineMidiBankChangeEvent;
  723. carlaEvent->value = midiBank;
  724. }
  725. else if (midiControl == MIDI_CONTROL_ALL_SOUND_OFF)
  726. {
  727. carlaEvent->type = CarlaEngineAllSoundOffEvent;
  728. }
  729. else if (midiControl == MIDI_CONTROL_ALL_NOTES_OFF)
  730. {
  731. carlaEvent->type = CarlaEngineAllNotesOffEvent;
  732. }
  733. else
  734. {
  735. const uint8_t midiValue = jackEvent.buffer[2];
  736. carlaEvent->type = CarlaEngineParameterChangeEvent;
  737. carlaEvent->parameter = midiControl;
  738. carlaEvent->value = double(midiValue)/127;
  739. }
  740. }
  741. else if (MIDI_IS_STATUS_PROGRAM_CHANGE(midiStatus))
  742. {
  743. const uint8_t midiProgram = jackEvent.buffer[1];
  744. carlaEvent->type = CarlaEngineMidiProgramChangeEvent;
  745. carlaEvent->value = midiProgram;
  746. }
  747. }
  748. }
  749. // initialize midi input
  750. memset(rackMidiEventsIn, 0, sizeof(CarlaEngineMidiEvent)*MAX_MIDI_EVENTS);
  751. {
  752. uint32_t i = 0, j = 0;
  753. jack_midi_event_t jackEvent;
  754. while (jackbridge_midi_event_get(&jackEvent, midiIn, j++) == 0)
  755. {
  756. if (i == MAX_MIDI_EVENTS)
  757. break;
  758. if (jackEvent.size < 4)
  759. {
  760. rackMidiEventsIn[i].time = jackEvent.time;
  761. rackMidiEventsIn[i].size = jackEvent.size;
  762. memcpy(rackMidiEventsIn[i].data, jackEvent.buffer, jackEvent.size);
  763. i += 1;
  764. }
  765. }
  766. }
  767. // process rack
  768. processRack(inBuf, outBuf, nframes);
  769. // output control
  770. {
  771. jackbridge_midi_clear_buffer(controlOut);
  772. for (unsigned short i=0; i < MAX_CONTROL_EVENTS; i++)
  773. {
  774. CarlaEngineControlEvent* const event = &rackControlEventsOut[i];
  775. if (event->type == CarlaEngineParameterChangeEvent && MIDI_IS_CONTROL_BANK_SELECT(event->parameter))
  776. event->type = CarlaEngineMidiBankChangeEvent;
  777. uint8_t data[4] = { 0 };
  778. switch (event->type)
  779. {
  780. case CarlaEngineNullEvent:
  781. break;
  782. case CarlaEngineParameterChangeEvent:
  783. data[0] = MIDI_STATUS_CONTROL_CHANGE + event->channel;
  784. data[1] = event->parameter;
  785. data[2] = event->value * 127;
  786. jackbridge_midi_event_write(controlOut, event->time, data, 3);
  787. break;
  788. case CarlaEngineMidiBankChangeEvent:
  789. data[0] = MIDI_STATUS_CONTROL_CHANGE + event->channel;
  790. data[1] = MIDI_CONTROL_BANK_SELECT;
  791. data[2] = event->value;
  792. jackbridge_midi_event_write(controlOut, event->time, data, 3);
  793. break;
  794. case CarlaEngineMidiProgramChangeEvent:
  795. data[0] = MIDI_STATUS_PROGRAM_CHANGE + event->channel;
  796. data[1] = event->value;
  797. jackbridge_midi_event_write(controlOut, event->time, data, 2);
  798. break;
  799. case CarlaEngineAllSoundOffEvent:
  800. data[0] = MIDI_STATUS_CONTROL_CHANGE + event->channel;
  801. data[1] = MIDI_CONTROL_ALL_SOUND_OFF;
  802. jackbridge_midi_event_write(controlOut, event->time, data, 2);
  803. break;
  804. case CarlaEngineAllNotesOffEvent:
  805. data[0] = MIDI_STATUS_CONTROL_CHANGE + event->channel;
  806. data[1] = MIDI_CONTROL_ALL_NOTES_OFF;
  807. jackbridge_midi_event_write(controlOut, event->time, data, 2);
  808. break;
  809. }
  810. }
  811. }
  812. // output midi
  813. {
  814. jackbridge_midi_clear_buffer(midiOut);
  815. for (unsigned short i=0; i < MAX_MIDI_EVENTS; i++)
  816. {
  817. if (rackMidiEventsOut[i].size == 0)
  818. break;
  819. jackbridge_midi_event_write(midiOut, rackMidiEventsOut[i].time, rackMidiEventsOut[i].data, rackMidiEventsOut[i].size);
  820. }
  821. }
  822. }
  823. #endif
  824. }
  825. void handleJackLatencyCallback(const jack_latency_callback_mode_t mode)
  826. {
  827. #ifndef BUILD_BRIDGE
  828. if (options.processMode != PROCESS_MODE_SINGLE_CLIENT)
  829. return;
  830. #endif
  831. for (unsigned short i=0, max=maxPluginNumber(); i < max; i++)
  832. {
  833. CarlaPlugin* const plugin = getPluginUnchecked(i);
  834. if (plugin && plugin->enabled())
  835. latencyPlugin(plugin, mode);
  836. }
  837. }
  838. void handleJackShutdownCallback()
  839. {
  840. for (unsigned short i=0, max=maxPluginNumber(); i < max; i++)
  841. {
  842. //CarlaPlugin* const plugin = getPluginUnchecked(i);
  843. //if (plugin)
  844. // plugin->x_client = nullptr;
  845. }
  846. m_client = nullptr;
  847. callback(CALLBACK_QUIT, 0, 0, 0, 0.0, nullptr);
  848. }
  849. // -------------------------------------
  850. #endif
  851. private:
  852. jack_client_t* m_client;
  853. jack_transport_state_t m_state;
  854. jack_position_t m_pos;
  855. bool m_freewheel;
  856. // -------------------------------------
  857. #ifdef BUILD_BRIDGE
  858. bool hasQuit;
  859. #else
  860. enum RackPorts {
  861. rackPortAudioIn1 = 0,
  862. rackPortAudioIn2 = 1,
  863. rackPortAudioOut1 = 2,
  864. rackPortAudioOut2 = 3,
  865. rackPortControlIn = 4,
  866. rackPortControlOut = 5,
  867. rackPortMidiIn = 6,
  868. rackPortMidiOut = 7,
  869. rackPortCount = 8
  870. };
  871. jack_port_t* m_rackPorts[rackPortCount];
  872. #endif
  873. #if 0
  874. // -------------------------------------
  875. static void processPlugin(CarlaPlugin* const p, const uint32_t nframes)
  876. {
  877. #if 0
  878. float* inBuffer[p->aIn.count];
  879. float* outBuffer[p->aOut.count];
  880. for (uint32_t i=0; i < p->aIn.count; i++)
  881. inBuffer[i] = ((CarlaEngineJackAudioPort*)p->aIn.ports[i])->getBuffer();
  882. for (uint32_t i=0; i < p->aOut.count; i++)
  883. outBuffer[i] = ((CarlaEngineJackAudioPort*)p->aOut.ports[i])->getBuffer();
  884. if (p->m_processHighPrecision)
  885. {
  886. float* inBuffer2[p->aIn.count];
  887. float* outBuffer2[p->aOut.count];
  888. for (uint32_t i=0, j; i < nframes; i += 8)
  889. {
  890. for (j=0; j < p->aIn.count; j++)
  891. inBuffer2[j] = inBuffer[j] + i;
  892. for (j=0; j < p->aOut.count; j++)
  893. outBuffer2[j] = outBuffer[j] + i;
  894. p->process(inBuffer2, outBuffer2, 8, i);
  895. }
  896. }
  897. else
  898. p->process(inBuffer, outBuffer, nframes);
  899. #endif
  900. }
  901. static void latencyPlugin(CarlaPlugin* const p, jack_latency_callback_mode_t mode)
  902. {
  903. #if 0
  904. jack_latency_range_t range;
  905. uint32_t pluginLatency = p->x_client->getLatency();
  906. if (pluginLatency == 0)
  907. return;
  908. if (mode == JackCaptureLatency)
  909. {
  910. for (uint32_t i=0; i < p->aIn.count; i++)
  911. {
  912. uint aOutI = (i >= p->aOut.count) ? p->aOut.count : i;
  913. jack_port_t* const portIn = ((CarlaEngineJackAudioPort*)p->aIn.ports[i])->m_port;
  914. jack_port_t* const portOut = ((CarlaEngineJackAudioPort*)p->aOut.ports[aOutI])->m_port;
  915. jackbridge_port_get_latency_range(portIn, mode, &range);
  916. range.min += pluginLatency;
  917. range.max += pluginLatency;
  918. jackbridge_port_set_latency_range(portOut, mode, &range);
  919. }
  920. }
  921. else
  922. {
  923. for (uint32_t i=0; i < p->aOut.count; i++)
  924. {
  925. uint aInI = (i >= p->aIn.count) ? p->aIn.count : i;
  926. jack_port_t* const portIn = ((CarlaEngineJackAudioPort*)p->aIn.ports[aInI])->m_port;
  927. jack_port_t* const portOut = ((CarlaEngineJackAudioPort*)p->aOut.ports[i])->m_port;
  928. jackbridge_port_get_latency_range(portOut, mode, &range);
  929. range.min += pluginLatency;
  930. range.max += pluginLatency;
  931. jackbridge_port_set_latency_range(portIn, mode, &range);
  932. }
  933. }
  934. #endif
  935. }
  936. // -------------------------------------
  937. static int carla_jack_srate_callback(jack_nframes_t newSampleRate, void* arg)
  938. {
  939. CarlaEngineJack* const _this_ = (CarlaEngineJack*)arg;
  940. _this_->handleJackSampleRateCallback(newSampleRate);
  941. return 0;
  942. }
  943. static int carla_jack_bufsize_callback(jack_nframes_t newBufferSize, void* arg)
  944. {
  945. CarlaEngineJack* const _this_ = (CarlaEngineJack*)arg;
  946. _this_->handleJackBufferSizeCallback(newBufferSize);
  947. return 0;
  948. }
  949. static void carla_jack_freewheel_callback(int starting, void* arg)
  950. {
  951. CarlaEngineJack* const _this_ = (CarlaEngineJack*)arg;
  952. _this_->handleJackFreewheelCallback(bool(starting));
  953. }
  954. static int carla_jack_process_callback(jack_nframes_t nframes, void* arg)
  955. {
  956. CarlaEngineJack* const _this_ = (CarlaEngineJack*)arg;
  957. _this_->handleJackProcessCallback(nframes);
  958. return 0;
  959. }
  960. static void carla_jack_latency_callback(jack_latency_callback_mode_t mode, void* arg)
  961. {
  962. CarlaEngineJack* const _this_ = (CarlaEngineJack*)arg;
  963. _this_->handleJackLatencyCallback(mode);
  964. }
  965. static void carla_jack_shutdown_callback(void* arg)
  966. {
  967. CarlaEngineJack* const _this_ = (CarlaEngineJack*)arg;
  968. _this_->handleJackShutdownCallback();
  969. }
  970. // -------------------------------------
  971. static int carla_jack_process_callback_plugin(jack_nframes_t nframes, void* arg)
  972. {
  973. CarlaPlugin* const plugin = (CarlaPlugin*)arg;
  974. if (plugin && plugin->enabled())
  975. {
  976. plugin->engineProcessLock();
  977. plugin->initBuffers();
  978. processPlugin(plugin, nframes);
  979. plugin->engineProcessUnlock();
  980. }
  981. return 0;
  982. }
  983. static void carla_jack_latency_callback_plugin(jack_latency_callback_mode_t mode, void* arg)
  984. {
  985. CarlaPlugin* const plugin = (CarlaPlugin*)arg;
  986. if (plugin && plugin->enabled())
  987. latencyPlugin(plugin, mode);
  988. }
  989. #endif
  990. CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaEngineJack)
  991. };
  992. // -----------------------------------------
  993. CarlaEngine* CarlaEngine::newJack()
  994. {
  995. return new CarlaEngineJack();
  996. }
  997. // -----------------------------------------
  998. CARLA_BACKEND_END_NAMESPACE
  999. #endif // CARLA_ENGINE_JACK