falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 42 Activity
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.
4904 Commits
16 Branches
361MB
Tree: 0c197e12b1
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '0c197e12b1'
${ noResults }
Carla/source/backend/engine/CarlaEngineJack.cpp

3064 lines
107KB
Raw Blame History 

  1. /*

  2.  * Carla Plugin Host

  3.  * Copyright (C) 2011-2019 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. 

  18. #include "CarlaEngineInternal.hpp"

  19. #include "CarlaPlugin.hpp"

  20. 

  21. #include "CarlaBackendUtils.hpp"

  22. #include "CarlaEngineUtils.hpp"

  23. #include "CarlaMathUtils.hpp"

  24. #include "CarlaMIDI.h"

  25. #include "CarlaPatchbayUtils.hpp"

  26. #include "CarlaStringList.hpp"

  27. 

  28. #include "jackey.h"

  29. 

  30. #ifdef USING_JUCE

  31. # if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))

  32. #  pragma GCC diagnostic push

  33. #  pragma GCC diagnostic ignored "-Wconversion"

  34. #  pragma GCC diagnostic ignored "-Weffc++"

  35. #  pragma GCC diagnostic ignored "-Wsign-conversion"

  36. #  pragma GCC diagnostic ignored "-Wundef"

  37. # endif

  38. 

  39. # include "AppConfig.h"

  40. # include "juce_events/juce_events.h"

  41. 

  42. # if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))

  43. #  pragma GCC diagnostic pop

  44. # endif

  45. #endif

  46. 

  47. #ifdef __SSE2_MATH__

  48. # include <xmmintrin.h>

  49. #endif

  50. 

  51. // must be last

  52. #include "jackbridge/JackBridge.hpp"

  53. 

  54. #define URI_CANVAS_ICON "http://kxstudio.sf.net/ns/canvas/icon"

  55. 

  56. CARLA_BACKEND_START_NAMESPACE

  57. 

  58. class CarlaEngineJack;

  59. class CarlaEngineJackClient;

  60. 

  61. #ifndef BUILD_BRIDGE

  62. // FIXME temporary function while jack2 client uuids are broken

  63. static int buggy_jack2_uuid_parse(const char* b, jack_uuid_t* u)

  64. {

  65.     if (sscanf (b, P_UINT64, u) == 1) {

  66. 

  67.         if (*u < (0x1LLU << 32)) {

  68.             // FIXME: bug in jack2, client bit not set

  69.             // *u = (0x2LLU << 32) | *u;

  70.             return -1;

  71.         }

  72. 

  73.         return 0;

  74.     }

  75. 

  76.     return -1;

  77. }

  78. #endif

  79. 

  80. // -----------------------------------------------------------------------

  81. // Fallback data

  82. 

  83. static const EngineEvent kFallbackJackEngineEvent = { kEngineEventTypeNull, 0, 0, {{ kEngineControlEventTypeNull, 0, 0.0f }} };

  84. 

  85. // -----------------------------------------------------------------------

  86. // Carla Engine Port removal helper

  87. 

  88. class CarlaEngineJackAudioPort;

  89. class CarlaEngineJackCVPort;

  90. class CarlaEngineJackEventPort;

  91. 

  92. struct JackPortDeletionCallback {

  93.     virtual ~JackPortDeletionCallback() noexcept {}

  94.     virtual void jackAudioPortDeleted(CarlaEngineJackAudioPort* const) noexcept = 0;

  95.     virtual void jackCVPortDeleted(CarlaEngineJackCVPort* const) noexcept = 0;

  96.     virtual void jackEventPortDeleted(CarlaEngineJackEventPort* const) noexcept = 0;

  97. };

  98. 

  99. // -----------------------------------------------------------------------

  100. // Carla Engine JACK-Audio port

  101. 

  102. class CarlaEngineJackAudioPort : public CarlaEngineAudioPort

  103. {

  104. public:

  105.     CarlaEngineJackAudioPort(const CarlaEngineClient& client, const bool isInputPort, const uint32_t indexOffset, jack_client_t* const jackClient, jack_port_t* const jackPort, JackPortDeletionCallback* const delCallback) noexcept

  106.         : CarlaEngineAudioPort(client, isInputPort, indexOffset),

  107.           fJackClient(jackClient),

  108.           fJackPort(jackPort),

  109.           kDeletionCallback(delCallback)

  110.     {

  111.         carla_debug("CarlaEngineJackAudioPort::CarlaEngineJackAudioPort(%s, %p, %p)", bool2str(isInputPort), jackClient, jackPort);

  112. 

  113.         switch (kClient.getEngine().getProccessMode())

  114.         {

  115.         case ENGINE_PROCESS_MODE_SINGLE_CLIENT:

  116.         case ENGINE_PROCESS_MODE_MULTIPLE_CLIENTS:

  117.             CARLA_SAFE_ASSERT_RETURN(jackClient != nullptr && jackPort != nullptr,);

  118. #ifndef BUILD_BRIDGE

  119.             if (const jack_uuid_t uuid = jackbridge_port_uuid(jackPort))

  120.                 jackbridge_set_property(jackClient, uuid, JACKEY_SIGNAL_TYPE, "AUDIO", "text/plain");

  121. #endif

  122.             break;

  123. 

  124.         default:

  125.             CARLA_SAFE_ASSERT(jackClient == nullptr && jackPort == nullptr);

  126.             break;

  127.         }

  128.     }

  129. 

  130.     ~CarlaEngineJackAudioPort() noexcept override

  131.     {

  132.         carla_debug("CarlaEngineJackAudioPort::~CarlaEngineJackAudioPort()");

  133. 

  134.         if (fJackClient != nullptr && fJackPort != nullptr)

  135.         {

  136. #ifndef BUILD_BRIDGE

  137.             try {

  138.                 if (const jack_uuid_t uuid = jackbridge_port_uuid(fJackPort))

  139.                     jackbridge_remove_property(fJackClient, uuid, JACKEY_SIGNAL_TYPE);

  140.             } CARLA_SAFE_EXCEPTION("Audio port remove meta type");

  141. #endif

  142. 

  143.             try {

  144.                 jackbridge_port_unregister(fJackClient, fJackPort);

  145.             } CARLA_SAFE_EXCEPTION("Audio port unregister");

  146. 

  147.             fJackClient = nullptr;

  148.             fJackPort   = nullptr;

  149.         }

  150. 

  151.         if (kDeletionCallback != nullptr)

  152.             kDeletionCallback->jackAudioPortDeleted(this);

  153.     }

  154. 

  155.     void initBuffer() noexcept override

  156.     {

  157.         if (fJackPort == nullptr)

  158.             return CarlaEngineAudioPort::initBuffer();

  159. 

  160.         const uint32_t bufferSize(kClient.getEngine().getBufferSize());

  161. 

  162.         try {

  163.             fBuffer = (float*)jackbridge_port_get_buffer(fJackPort, bufferSize);

  164.         }

  165.         catch(...) {

  166.             fBuffer = nullptr;

  167.             return;

  168.         }

  169. 

  170.         if (! kIsInput)

  171.             carla_zeroFloats(fBuffer, bufferSize);

  172.     }

  173. 

  174.     void invalidate() noexcept

  175.     {

  176.         fJackClient = nullptr;

  177.         fJackPort   = nullptr;

  178.     }

  179. 

  180. private:

  181.     jack_client_t* fJackClient;

  182.     jack_port_t*   fJackPort;

  183. 

  184.     JackPortDeletionCallback* const kDeletionCallback;

  185. 

  186.     friend class CarlaEngineJackClient;

  187. 

  188.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaEngineJackAudioPort)

  189. };

  190. 

  191. // -----------------------------------------------------------------------

  192. // Carla Engine JACK-CV port

  193. 

  194. class CarlaEngineJackCVPort : public CarlaEngineCVPort

  195. {

  196. public:

  197.     CarlaEngineJackCVPort(const CarlaEngineClient& client, const bool isInputPort, const uint32_t indexOffset, jack_client_t* const jackClient, jack_port_t* const jackPort, JackPortDeletionCallback* const delCallback) noexcept

  198.         : CarlaEngineCVPort(client, isInputPort, indexOffset),

  199.           fJackClient(jackClient),

  200.           fJackPort(jackPort),

  201.           kDeletionCallback(delCallback)

  202.     {

  203.         carla_debug("CarlaEngineJackCVPort::CarlaEngineJackCVPort(%s, %p, %p)", bool2str(isInputPort), jackClient, jackPort);

  204. 

  205.         switch (kClient.getEngine().getProccessMode())

  206.         {

  207.         case ENGINE_PROCESS_MODE_SINGLE_CLIENT:

  208.         case ENGINE_PROCESS_MODE_MULTIPLE_CLIENTS:

  209.             CARLA_SAFE_ASSERT_RETURN(jackClient != nullptr && jackPort != nullptr,);

  210. #ifndef BUILD_BRIDGE

  211.             if (const jack_uuid_t uuid = jackbridge_port_uuid(jackPort))

  212.                 jackbridge_set_property(jackClient, uuid, JACKEY_SIGNAL_TYPE, "CV", "text/plain");

  213. #endif

  214.             break;

  215. 

  216.         default:

  217.             CARLA_SAFE_ASSERT(jackClient == nullptr && jackPort == nullptr);

  218.             break;

  219.         }

  220.     }

  221. 

  222.     ~CarlaEngineJackCVPort() noexcept override

  223.     {

  224.         carla_debug("CarlaEngineJackCVPort::~CarlaEngineJackCVPort()");

  225. 

  226.         if (fJackClient != nullptr && fJackPort != nullptr)

  227.         {

  228. #ifndef BUILD_BRIDGE

  229.             try {

  230.                 if (const jack_uuid_t uuid = jackbridge_port_uuid(fJackPort))

  231.                     jackbridge_remove_property(fJackClient, uuid, JACKEY_SIGNAL_TYPE);

  232.             } CARLA_SAFE_EXCEPTION("CV port remove meta type");

  233. #endif

  234. 

  235.             try {

  236.                 jackbridge_port_unregister(fJackClient, fJackPort);

  237.             } CARLA_SAFE_EXCEPTION("CV port unregister");

  238. 

  239.             fJackClient = nullptr;

  240.             fJackPort   = nullptr;

  241.         }

  242. 

  243.         if (kDeletionCallback != nullptr)

  244.             kDeletionCallback->jackCVPortDeleted(this);

  245.     }

  246. 

  247.     void initBuffer() noexcept override

  248.     {

  249.         if (fJackPort == nullptr)

  250.             return CarlaEngineCVPort::initBuffer();

  251. 

  252.         const uint32_t bufferSize(kClient.getEngine().getBufferSize());

  253. 

  254.         try {

  255.             fBuffer = (float*)jackbridge_port_get_buffer(fJackPort, bufferSize);

  256.         }

  257.         catch(...) {

  258.             fBuffer = nullptr;

  259.             return;

  260.         }

  261. 

  262.         if (! kIsInput)

  263.             carla_zeroFloats(fBuffer, bufferSize);

  264.     }

  265. 

  266.     void invalidate() noexcept

  267.     {

  268.         fJackClient = nullptr;

  269.         fJackPort   = nullptr;

  270.     }

  271. 

  272. private:

  273.     jack_client_t* fJackClient;

  274.     jack_port_t*   fJackPort;

  275. 

  276.     JackPortDeletionCallback* const kDeletionCallback;

  277. 

  278.     friend class CarlaEngineJackClient;

  279. 

  280.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaEngineJackCVPort)

  281. };

  282. 

  283. // -----------------------------------------------------------------------

  284. // Carla Engine JACK-Event port

  285. 

  286. class CarlaEngineJackEventPort : public CarlaEngineEventPort

  287. {

  288. public:

  289.     CarlaEngineJackEventPort(const CarlaEngineClient& client, const bool isInputPort, const uint32_t indexOffset, jack_client_t* const jackClient, jack_port_t* const jackPort, JackPortDeletionCallback* const delCallback) noexcept

  290.         : CarlaEngineEventPort(client, isInputPort, indexOffset),

  291.           fJackClient(jackClient),

  292.           fJackPort(jackPort),

  293.           fJackBuffer(nullptr),

  294.           fRetEvent(kFallbackJackEngineEvent),

  295.           kDeletionCallback(delCallback)

  296.     {

  297.         carla_debug("CarlaEngineJackEventPort::CarlaEngineJackEventPort(%s, %p, %p)", bool2str(isInputPort), jackClient, jackPort);

  298. 

  299.         switch (kClient.getEngine().getProccessMode())

  300.         {

  301.         case ENGINE_PROCESS_MODE_SINGLE_CLIENT:

  302.         case ENGINE_PROCESS_MODE_MULTIPLE_CLIENTS:

  303.             CARLA_SAFE_ASSERT_RETURN(jackClient != nullptr && jackPort != nullptr,);

  304.             break;

  305.         default:

  306.             CARLA_SAFE_ASSERT(jackClient == nullptr && jackPort == nullptr);

  307.             break;

  308.         }

  309.     }

  310. 

  311.     ~CarlaEngineJackEventPort() noexcept override

  312.     {

  313.         carla_debug("CarlaEngineJackEventPort::~CarlaEngineJackEventPort()");

  314. 

  315.         if (fJackClient != nullptr && fJackPort != nullptr)

  316.         {

  317.             try {

  318.                 jackbridge_port_unregister(fJackClient, fJackPort);

  319.             } CARLA_SAFE_EXCEPTION("Event port unregister");

  320. 

  321.             fJackClient = nullptr;

  322.             fJackPort   = nullptr;

  323.         }

  324. 

  325.         if (kDeletionCallback != nullptr)

  326.             kDeletionCallback->jackEventPortDeleted(this);

  327.     }

  328. 

  329.     void initBuffer() noexcept override

  330.     {

  331.         if (fJackPort == nullptr)

  332.             return CarlaEngineEventPort::initBuffer();

  333. 

  334.         try {

  335.             fJackBuffer = jackbridge_port_get_buffer(fJackPort, kClient.getEngine().getBufferSize());

  336.         }

  337.         catch(...) {

  338.             fJackBuffer = nullptr;

  339.             return;

  340.         }

  341. 

  342.         if (! kIsInput)

  343.             jackbridge_midi_clear_buffer(fJackBuffer);

  344.     }

  345. 

  346.     uint32_t getEventCount() const noexcept override

  347.     {

  348.         if (fJackPort == nullptr)

  349.             return CarlaEngineEventPort::getEventCount();

  350. 

  351.         CARLA_SAFE_ASSERT_RETURN(kIsInput, 0);

  352.         CARLA_SAFE_ASSERT_RETURN(fJackBuffer != nullptr, 0);

  353. 

  354.         try {

  355.             return jackbridge_midi_get_event_count(fJackBuffer);

  356.         } CARLA_SAFE_EXCEPTION_RETURN("jack_midi_get_event_count", 0);

  357.     }

  358. 

  359.     const EngineEvent& getEvent(const uint32_t index) const noexcept override

  360.     {

  361.         if (fJackPort == nullptr)

  362.             return CarlaEngineEventPort::getEvent(index);

  363. 

  364.         CARLA_SAFE_ASSERT_RETURN(kIsInput, kFallbackJackEngineEvent);

  365.         CARLA_SAFE_ASSERT_RETURN(fJackBuffer != nullptr, kFallbackJackEngineEvent);

  366. 

  367.         return getEventUnchecked(index);

  368.     }

  369. 

  370.     const EngineEvent& getEventUnchecked(const uint32_t index) const noexcept override

  371.     {

  372.         jack_midi_event_t jackEvent;

  373. 

  374.         bool test = false;

  375. 

  376.         try {

  377.             test = jackbridge_midi_event_get(&jackEvent, fJackBuffer, index);

  378.         } CARLA_SAFE_EXCEPTION_RETURN("jack_midi_event_get", kFallbackJackEngineEvent);

  379. 

  380.         if (! test)

  381.             return kFallbackJackEngineEvent;

  382. 

  383.         CARLA_SAFE_ASSERT_RETURN(jackEvent.size < 0xFF /* uint8_t max */, kFallbackJackEngineEvent);

  384. 

  385.         uint8_t port;

  386. 

  387.         if (kIndexOffset < 0xFF /* uint8_t max */)

  388.         {

  389.             port = static_cast<uint8_t>(kIndexOffset);

  390.         }

  391.         else

  392.         {

  393.             port = 0;

  394.             carla_safe_assert_uint("kIndexOffset < 0xFF", __FILE__, __LINE__, kIndexOffset);

  395.         }

  396. 

  397.         fRetEvent.time = jackEvent.time;

  398.         fRetEvent.fillFromMidiData(static_cast<uint8_t>(jackEvent.size), jackEvent.buffer, port);

  399. 

  400.         return fRetEvent;

  401.     }

  402. 

  403.     bool writeControlEvent(const uint32_t time, const uint8_t channel, const EngineControlEventType type, const uint16_t param, const float value) noexcept override

  404.     {

  405.         if (fJackPort == nullptr)

  406.             return CarlaEngineEventPort::writeControlEvent(time, channel, type, param, value);

  407. 

  408.         CARLA_SAFE_ASSERT_RETURN(! kIsInput, false);

  409.         CARLA_SAFE_ASSERT_RETURN(fJackBuffer != nullptr, false);

  410.         CARLA_SAFE_ASSERT_RETURN(type != kEngineControlEventTypeNull, false);

  411.         CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS, false);

  412.         CARLA_SAFE_ASSERT_RETURN(param < MAX_MIDI_CONTROL, false);

  413.         CARLA_SAFE_ASSERT(value >= 0.0f && value <= 1.0f);

  414. 

  415.         if (type == kEngineControlEventTypeParameter) {

  416.             CARLA_SAFE_ASSERT(! MIDI_IS_CONTROL_BANK_SELECT(param));

  417.         }

  418. 

  419.         uint8_t data[3] = { 0, 0, 0 };

  420. 

  421.         EngineControlEvent ctrlEvent = { type, param, value };

  422.         const uint8_t size = ctrlEvent.convertToMidiData(channel, data);

  423. 

  424.         if (size == 0)

  425.             return false;

  426. 

  427.         try {

  428.             return jackbridge_midi_event_write(fJackBuffer, time, data, size);

  429.         } CARLA_SAFE_EXCEPTION_RETURN("jack_midi_event_write", false);

  430.     }

  431. 

  432.     bool writeMidiEvent(const uint32_t time, const uint8_t channel, const uint8_t size, const uint8_t* const data) noexcept override

  433.     {

  434.         if (fJackPort == nullptr)

  435.             return CarlaEngineEventPort::writeMidiEvent(time, channel, size, data);

  436. 

  437.         CARLA_SAFE_ASSERT_RETURN(! kIsInput, false);

  438.         CARLA_SAFE_ASSERT_RETURN(fJackBuffer != nullptr, false);

  439.         CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS, false);

  440.         CARLA_SAFE_ASSERT_RETURN(size > 0, false);

  441.         CARLA_SAFE_ASSERT_RETURN(data != nullptr, false);

  442. 

  443.         jack_midi_data_t jdata[size];

  444. 

  445.         jdata[0] = static_cast<jack_midi_data_t>(MIDI_GET_STATUS_FROM_DATA(data) + channel);

  446. 

  447.         for (uint8_t i=1; i < size; ++i)

  448.             jdata[i] = data[i];

  449. 

  450.         try {

  451.             return jackbridge_midi_event_write(fJackBuffer, time, jdata, size);

  452.         } CARLA_SAFE_EXCEPTION_RETURN("jack_midi_event_write", false);

  453.     }

  454. 

  455.     void invalidate() noexcept

  456.     {

  457.         fJackClient = nullptr;

  458.         fJackPort   = nullptr;

  459.     }

  460. 

  461. private:

  462.     jack_client_t* fJackClient;

  463.     jack_port_t*   fJackPort;

  464.     void*          fJackBuffer;

  465. 

  466.     mutable EngineEvent fRetEvent;

  467. 

  468.     JackPortDeletionCallback* const kDeletionCallback;

  469. 

  470.     friend class CarlaEngineJackClient;

  471. 

  472.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaEngineJackEventPort)

  473. };

  474. 

  475. // -----------------------------------------------------------------------

  476. // Jack Engine client

  477. 

  478. class CarlaEngineJackClient : public CarlaEngineClient,

  479.                               private JackPortDeletionCallback

  480. {

  481. public:

  482.     CarlaEngineJackClient(const CarlaEngine& engine, jack_client_t* const jackClient)

  483.         : CarlaEngineClient(engine),

  484.           fJackClient(jackClient),

  485.           fUseClient(engine.getProccessMode() == ENGINE_PROCESS_MODE_SINGLE_CLIENT || engine.getProccessMode() == ENGINE_PROCESS_MODE_MULTIPLE_CLIENTS),

  486.           fAudioPorts(),

  487.           fCVPorts(),

  488.           fEventPorts(),

  489.           fPreRenameMutex(),

  490.           fPreRenameConnections()

  491.     {

  492.         carla_debug("CarlaEngineJackClient::CarlaEngineJackClient(%p)", jackClient);

  493. 

  494.         if (fUseClient)

  495.         {

  496.             CARLA_SAFE_ASSERT(jackClient != nullptr);

  497.         }

  498.         else

  499.         {

  500.             CARLA_SAFE_ASSERT(jackClient == nullptr);

  501.         }

  502.     }

  503. 

  504.     ~CarlaEngineJackClient() noexcept override

  505.     {

  506.         carla_debug("CarlaEngineJackClient::~CarlaEngineJackClient()");

  507. 

  508.         if (getProcessMode() == ENGINE_PROCESS_MODE_MULTIPLE_CLIENTS && fJackClient != nullptr) // FIXME

  509.             jackbridge_client_close(fJackClient);

  510. 

  511.         // ports must have been deleted by now!

  512.         //fAudioPorts.clear();

  513.         //fCVPorts.clear();

  514.         //fEventPorts.clear();

  515.     }

  516. 

  517.     void activate() noexcept override

  518.     {

  519.         carla_debug("CarlaEngineJackClient::activate()");

  520. 

  521.         if (getProcessMode() == ENGINE_PROCESS_MODE_MULTIPLE_CLIENTS)

  522.         {

  523.             CARLA_SAFE_ASSERT_RETURN(fJackClient != nullptr && ! isActive(),);

  524. 

  525.             try {

  526.                 jackbridge_activate(fJackClient);

  527.             } catch(...) {}

  528.         }

  529. 

  530.         CarlaEngineClient::activate();

  531. 

  532.         const CarlaMutexLocker cml(fPreRenameMutex);

  533. 

  534.         if (fJackClient != nullptr)

  535.         {

  536.             // restore pre-rename connections

  537.             const char* portNameA = nullptr;

  538.             const char* portNameB = nullptr;

  539.             bool doConnection = false;

  540. 

  541.             for (CarlaStringList::Itenerator it = fPreRenameConnections.begin2(); it.valid(); it.next())

  542.             {

  543.                 const bool connectNow = doConnection;

  544.                 doConnection = !doConnection;

  545. 

  546.                 if (connectNow)

  547.                     portNameB = it.getValue(nullptr);

  548.                 else

  549.                     portNameA = it.getValue(nullptr);

  550. 

  551.                 if (! connectNow)

  552.                     continue;

  553. 

  554.                 CARLA_SAFE_ASSERT_CONTINUE(portNameA != nullptr && portNameA[0] != '\0');

  555.                 CARLA_SAFE_ASSERT_CONTINUE(portNameB != nullptr && portNameB[0] != '\0');

  556. 

  557.                 jackbridge_connect(fJackClient, portNameA, portNameB);

  558.             }

  559.         }

  560. 

  561.         fPreRenameConnections.clear();

  562.     }

  563. 

  564.     void deactivate() noexcept override

  565.     {

  566.         carla_debug("CarlaEngineJackClient::deactivate()");

  567. 

  568.         if (getProcessMode() == ENGINE_PROCESS_MODE_MULTIPLE_CLIENTS)

  569.         {

  570.             CARLA_SAFE_ASSERT_RETURN(fJackClient != nullptr && isActive(),);

  571. 

  572.             try {

  573.                 jackbridge_deactivate(fJackClient);

  574.             } catch(...) {}

  575.         }

  576. 

  577.         CarlaEngineClient::deactivate();

  578.     }

  579. 

  580.     bool isOk() const noexcept override

  581.     {

  582.         if (fUseClient)

  583.             return (fJackClient != nullptr);

  584. 

  585.         return CarlaEngineClient::isOk();

  586.     }

  587. 

  588.     CarlaEnginePort* addPort(const EnginePortType portType, const char* const name, const bool isInput, const uint32_t indexOffset) override

  589.     {

  590.         carla_debug("CarlaEngineJackClient::addPort(%i:%s, \"%s\", %s)", portType, EnginePortType2Str(portType), name, bool2str(isInput));

  591. 

  592.         jack_port_t* jackPort = nullptr;

  593.         const char* realName = name;

  594. 

  595.         // Create JACK port first, if needed

  596.         if (fUseClient)

  597.         {

  598.             CARLA_SAFE_ASSERT_RETURN(fJackClient != nullptr, nullptr);

  599. 

  600.             realName = _getUniquePortName(name);

  601. 

  602.             switch (portType)

  603.             {

  604.             case kEnginePortTypeNull:

  605.                 break;

  606.             case kEnginePortTypeAudio:

  607.                 jackPort = jackbridge_port_register(fJackClient, realName, JACK_DEFAULT_AUDIO_TYPE, isInput ? JackPortIsInput : JackPortIsOutput, 0);

  608.                 break;

  609.             case kEnginePortTypeCV:

  610.                 jackPort = jackbridge_port_register(fJackClient, realName, JACK_DEFAULT_AUDIO_TYPE, isInput ? JackPortIsInput : JackPortIsOutput, 0);

  611.                 break;

  612.             case kEnginePortTypeEvent:

  613.                 jackPort = jackbridge_port_register(fJackClient, realName, JACK_DEFAULT_MIDI_TYPE, isInput ? JackPortIsInput : JackPortIsOutput, 0);

  614.                 break;

  615.             }

  616. 

  617.             CARLA_SAFE_ASSERT_RETURN(jackPort != nullptr, nullptr);

  618.         }

  619. 

  620.         // Create Engine port

  621.         switch (portType)

  622.         {

  623.         case kEnginePortTypeNull:

  624.             break;

  625.         case kEnginePortTypeAudio: {

  626.             _addAudioPortName(isInput, realName);

  627.             if (realName != name) delete[] realName;

  628.             CarlaEngineJackAudioPort* const enginePort(new CarlaEngineJackAudioPort(*this, isInput, indexOffset, fJackClient, jackPort, this));

  629.             fAudioPorts.append(enginePort);

  630.             return enginePort;

  631.         }

  632.         case kEnginePortTypeCV: {

  633.             _addCVPortName(isInput, realName);

  634.             if (realName != name) delete[] realName;

  635.             CarlaEngineJackCVPort* const enginePort(new CarlaEngineJackCVPort(*this, isInput, indexOffset, fJackClient, jackPort, this));

  636.             fCVPorts.append(enginePort);

  637.             return enginePort;

  638.         }

  639.         case kEnginePortTypeEvent: {

  640.             _addEventPortName(isInput, realName);

  641.             if (realName != name) delete[] realName;

  642.             CarlaEngineJackEventPort* const enginePort(new CarlaEngineJackEventPort(*this, isInput, indexOffset, fJackClient, jackPort, this));

  643.             fEventPorts.append(enginePort);

  644.             return enginePort;

  645.         }

  646.         }

  647. 

  648.         carla_stderr("CarlaEngineJackClient::addPort(%i, \"%s\", %s) - invalid type", portType, name, bool2str(isInput));

  649.         return nullptr;

  650.     }

  651. 

  652.     void invalidate() noexcept

  653.     {

  654.         for (LinkedList<CarlaEngineJackAudioPort*>::Itenerator it = fAudioPorts.begin2(); it.valid(); it.next())

  655.         {

  656.             CarlaEngineJackAudioPort* const port(it.getValue(nullptr));

  657.             CARLA_SAFE_ASSERT_CONTINUE(port != nullptr);

  658. 

  659.             port->invalidate();

  660.         }

  661. 

  662.         for (LinkedList<CarlaEngineJackCVPort*>::Itenerator it = fCVPorts.begin2(); it.valid(); it.next())

  663.         {

  664.             CarlaEngineJackCVPort* const port(it.getValue(nullptr));

  665.             CARLA_SAFE_ASSERT_CONTINUE(port != nullptr);

  666. 

  667.             port->invalidate();

  668.         }

  669. 

  670.         for (LinkedList<CarlaEngineJackEventPort*>::Itenerator it = fEventPorts.begin2(); it.valid(); it.next())

  671.         {

  672.             CarlaEngineJackEventPort* const port(it.getValue(nullptr));

  673.             CARLA_SAFE_ASSERT_CONTINUE(port != nullptr);

  674. 

  675.             port->invalidate();

  676.         }

  677. 

  678.         fJackClient = nullptr;

  679.         CarlaEngineClient::deactivate();

  680.     }

  681. 

  682.     const char* getJackClientName() const noexcept

  683.     {

  684.         CARLA_SAFE_ASSERT_RETURN(fJackClient != nullptr, nullptr);

  685. 

  686.         try {

  687.             return jackbridge_get_client_name(fJackClient);

  688.         } CARLA_SAFE_EXCEPTION_RETURN("jack_get_client_name", nullptr);

  689.     }

  690. 

  691.     void jackAudioPortDeleted(CarlaEngineJackAudioPort* const port) noexcept override

  692.     {

  693.         fAudioPorts.removeAll(port);

  694.     }

  695. 

  696.     void jackCVPortDeleted(CarlaEngineJackCVPort* const port) noexcept override

  697.     {

  698.         fCVPorts.removeAll(port);

  699.     }

  700. 

  701.     void jackEventPortDeleted(CarlaEngineJackEventPort* const port) noexcept override

  702.     {

  703.         fEventPorts.removeAll(port);

  704.     }

  705. 

  706.     bool renameInSingleClient(const CarlaString& newClientName)

  707.     {

  708.         const CarlaString clientNamePrefix(newClientName + ":");

  709. 

  710.         return _renamePorts(fAudioPorts, clientNamePrefix) &&

  711.                _renamePorts(fCVPorts,    clientNamePrefix) &&

  712.                _renamePorts(fEventPorts, clientNamePrefix);

  713.     }

  714. 

  715.     void closeForRename(jack_client_t* const newClient, const CarlaString& newClientName) noexcept

  716.     {

  717.         if (fJackClient != nullptr)

  718.         {

  719.             if (isActive())

  720.             {

  721.                 {

  722.                     const CarlaString clientNamePrefix(newClientName + ":");

  723. 

  724.                     // store current client connections

  725.                     const CarlaMutexLocker cml(fPreRenameMutex);

  726. 

  727.                     fPreRenameConnections.clear();

  728. 

  729.                     _savePortsConnections(fAudioPorts, clientNamePrefix);

  730.                     _savePortsConnections(fCVPorts,    clientNamePrefix);

  731.                     _savePortsConnections(fEventPorts, clientNamePrefix);

  732.                 }

  733. 

  734.                 try {

  735.                     jackbridge_deactivate(fJackClient);

  736.                 } catch(...) {}

  737.             }

  738. 

  739.             try {

  740.                 jackbridge_client_close(fJackClient);

  741.             } catch(...) {}

  742. 

  743.             invalidate();

  744.         }

  745. 

  746.         fAudioPorts.clear();

  747.         fCVPorts.clear();

  748.         fEventPorts.clear();

  749.         _clearPorts();

  750. 

  751.         fJackClient = newClient;

  752.     }

  753. 

  754. private:

  755.     jack_client_t* fJackClient;

  756.     const bool     fUseClient;

  757. 

  758.     LinkedList<CarlaEngineJackAudioPort*> fAudioPorts;

  759.     LinkedList<CarlaEngineJackCVPort*>    fCVPorts;

  760.     LinkedList<CarlaEngineJackEventPort*> fEventPorts;

  761. 

  762.     CarlaMutex      fPreRenameMutex;

  763.     CarlaStringList fPreRenameConnections;

  764. 

  765.     template<typename T>

  766.     bool _renamePorts(const LinkedList<T*>& t, const CarlaString& clientNamePrefix)

  767.     {

  768.         for (typename LinkedList<T*>::Itenerator it = t.begin2(); it.valid(); it.next())

  769.         {

  770.             T* const port(it.getValue(nullptr));

  771.             CARLA_SAFE_ASSERT_CONTINUE(port != nullptr);

  772.             CARLA_SAFE_ASSERT_CONTINUE(port->fJackPort != nullptr);

  773. 

  774.             const char* shortPortName(jackbridge_port_short_name(port->fJackPort));

  775.             CARLA_SAFE_ASSERT_CONTINUE(shortPortName != nullptr && shortPortName[0] != '\0');

  776. 

  777.             const char* const oldClientNameSep(std::strstr(shortPortName, ":"));

  778.             CARLA_SAFE_ASSERT_CONTINUE(oldClientNameSep != nullptr && oldClientNameSep[0] != '\0' && oldClientNameSep[1] != '\0');

  779. 

  780.             shortPortName += oldClientNameSep-shortPortName + 1;

  781. 

  782.             const CarlaString newPortName(clientNamePrefix + shortPortName);

  783. 

  784.             if (! jackbridge_port_rename(fJackClient, port->fJackPort, newPortName))

  785.                 return false;

  786.         }

  787. 

  788.         return true;

  789.     }

  790. 

  791.     template<typename T>

  792.     void _savePortsConnections(const LinkedList<T*>& t, const CarlaString& clientNamePrefix)

  793.     {

  794.         for (typename LinkedList<T*>::Itenerator it = t.begin2(); it.valid(); it.next())

  795.         {

  796.             T* const port(it.getValue(nullptr));

  797.             CARLA_SAFE_ASSERT_CONTINUE(port != nullptr);

  798.             CARLA_SAFE_ASSERT_CONTINUE(port->fJackPort != nullptr);

  799. 

  800.             const char* const shortPortName(jackbridge_port_short_name(port->fJackPort));

  801.             CARLA_SAFE_ASSERT_CONTINUE(shortPortName != nullptr && shortPortName[0] != '\0');

  802. 

  803.             const CarlaString portName(clientNamePrefix + shortPortName);

  804. 

  805.             if (const char** const connections = jackbridge_port_get_all_connections(fJackClient, port->fJackPort))

  806.             {

  807.                 for (int i=0; connections[i] != nullptr; ++i)

  808.                 {

  809.                     if (port->kIsInput)

  810.                     {

  811.                         fPreRenameConnections.append(connections[i]);

  812.                         fPreRenameConnections.append(portName);

  813.                     }

  814.                     else

  815.                     {

  816.                         fPreRenameConnections.append(portName);

  817.                         fPreRenameConnections.append(connections[i]);

  818.                     }

  819.                 }

  820. 

  821.                 jackbridge_free(connections);

  822.             }

  823.         }

  824.     }

  825. 

  826.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaEngineJackClient)

  827. };

  828. 

  829. // -----------------------------------------------------------------------

  830. // Jack Engine

  831. 

  832. class CarlaEngineJack : public CarlaEngine

  833. #ifndef BUILD_BRIDGE

  834.                       , private CarlaThread

  835. #endif

  836. {

  837. public:

  838.     CarlaEngineJack()

  839.         : CarlaEngine(),

  840. #ifndef BUILD_BRIDGE

  841.           CarlaThread("CarlaEngineJackCallbacks"),

  842. #endif

  843.           fClient(nullptr),

  844.           fExternalPatchbayHost(true),

  845.           fExternalPatchbayOsc(true),

  846.           fFreewheel(false),

  847. #ifdef BUILD_BRIDGE

  848.           fIsRunning(false)

  849. #else

  850.           fTimebaseMaster(false),

  851.           fTimebaseRolling(false),

  852.           fTimebaseUsecs(0),

  853.           fUsedGroups(),

  854.           fUsedPorts(),

  855.           fUsedConnections(),

  856.           fPatchbayProcThreadProtectionMutex(),

  857.           fRetConns(),

  858.           fPostPonedEvents(),

  859.           fPostPonedEventsMutex(),

  860.           fIsInternalClient(false)

  861. #endif

  862.     {

  863.         carla_debug("CarlaEngineJack::CarlaEngineJack()");

  864. 

  865. #ifdef BUILD_BRIDGE

  866.         pData->options.processMode = ENGINE_PROCESS_MODE_MULTIPLE_CLIENTS;

  867. #else

  868.         carla_zeroPointers(fRackPorts, kRackPortCount);

  869. #endif

  870.     }

  871. 

  872.     ~CarlaEngineJack() noexcept override

  873.     {

  874.         carla_debug("CarlaEngineJack::~CarlaEngineJack()");

  875.         CARLA_SAFE_ASSERT(fClient == nullptr);

  876. 

  877. #ifndef BUILD_BRIDGE

  878.         fUsedGroups.clear();

  879.         fUsedPorts.clear();

  880.         fUsedConnections.clear();

  881.         CARLA_SAFE_ASSERT(fPostPonedEvents.count() == 0);

  882. #endif

  883.     }

  884. 

  885.     // -------------------------------------------------------------------

  886.     // Maximum values

  887. 

  888.     uint getMaxClientNameSize() const noexcept override

  889.     {

  890. #ifndef BUILD_BRIDGE

  891.         if (pData->options.processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT || pData->options.processMode == ENGINE_PROCESS_MODE_MULTIPLE_CLIENTS)

  892. #endif

  893.         {

  894.             try {

  895.                 return static_cast<uint>(jackbridge_client_name_size()-1);

  896.             } CARLA_SAFE_EXCEPTION_RETURN("jack_client_name_size", 32);

  897.         }

  898. 

  899.         return CarlaEngine::getMaxClientNameSize();

  900.     }

  901. 

  902.     uint getMaxPortNameSize() const noexcept override

  903.     {

  904.         if (pData->options.processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT || pData->options.processMode == ENGINE_PROCESS_MODE_MULTIPLE_CLIENTS)

  905.         {

  906.             try {

  907.                 return static_cast<uint>(jackbridge_port_name_size()-1);

  908.             } CARLA_SAFE_EXCEPTION_RETURN("jack_port_name_size", 255);

  909.         }

  910. 

  911.         return CarlaEngine::getMaxPortNameSize();

  912.     }

  913. 

  914.     // -------------------------------------------------------------------

  915.     // Virtual, per-engine type calls

  916. 

  917.     bool init(const char* const clientName) override

  918.     {

  919.         CARLA_SAFE_ASSERT_RETURN(fClient != nullptr || (clientName != nullptr && clientName[0] != '\0'), false);

  920.         CARLA_SAFE_ASSERT_RETURN(jackbridge_is_ok(), false);

  921.         carla_debug("CarlaEngineJack::init(\"%s\")", clientName);

  922. 

  923.         fFreewheel = false;

  924.         fExternalPatchbayHost = true;

  925.         fExternalPatchbayOsc  = true;

  926. 

  927.         CarlaString truncatedClientName;

  928. 

  929.         if (fClient == nullptr && clientName != nullptr)

  930.         {

  931.             truncatedClientName = clientName;

  932.             truncatedClientName.truncate(getMaxClientNameSize());

  933.         }

  934. 

  935. #ifdef BUILD_BRIDGE

  936.         fIsRunning = true;

  937. 

  938.         if (! pData->init(truncatedClientName))

  939.         {

  940.             close();

  941.             setLastError("Failed to init internal data");

  942.             return false;

  943.         }

  944. 

  945.         if (pData->bufferSize == 0 || carla_isEqual(pData->sampleRate, 0.0))

  946.         {

  947.             // open temp client to get initial buffer-size and sample-rate values

  948.             if (jack_client_t* const tmpClient = jackbridge_client_open(truncatedClientName, JackNoStartServer, nullptr))

  949.             {

  950.                 pData->bufferSize = jackbridge_get_buffer_size(tmpClient);

  951.                 pData->sampleRate = jackbridge_get_sample_rate(tmpClient);

  952. 

  953.                 jackbridge_client_close(tmpClient);

  954.             }

  955.             else

  956.             {

  957.                 close();

  958.                 setLastError("Failed to init temporary jack client");

  959.                 return false;

  960.             }

  961.         }

  962. 

  963.         return true;

  964. #else

  965.         if (fClient == nullptr && clientName != nullptr)

  966.             fClient = jackbridge_client_open(truncatedClientName, JackNullOption, nullptr);

  967. 

  968.         if (fClient == nullptr)

  969.         {

  970.             setLastError("Failed to create new JACK client");

  971.             return false;

  972.         }

  973. 

  974.         const char* const jackClientName = jackbridge_get_client_name(fClient);

  975. 

  976.         if (! pData->init(jackClientName))

  977.         {

  978.             jackbridge_client_close(fClient);

  979.             fClient = nullptr;

  980.             setLastError("Failed to init internal data");

  981.             return false;

  982.         }

  983. 

  984.         const EngineOptions& opts(pData->options);

  985. 

  986.         pData->bufferSize = jackbridge_get_buffer_size(fClient);

  987.         pData->sampleRate = jackbridge_get_sample_rate(fClient);

  988.         pData->initTime(opts.transportExtra);

  989. 

  990.         jackbridge_set_thread_init_callback(fClient, carla_jack_thread_init_callback, nullptr);

  991.         jackbridge_set_buffer_size_callback(fClient, carla_jack_bufsize_callback, this);

  992.         jackbridge_set_sample_rate_callback(fClient, carla_jack_srate_callback, this);

  993.         jackbridge_set_freewheel_callback(fClient, carla_jack_freewheel_callback, this);

  994.         jackbridge_set_latency_callback(fClient, carla_jack_latency_callback, this);

  995.         jackbridge_set_process_callback(fClient, carla_jack_process_callback, this);

  996.         jackbridge_on_shutdown(fClient, carla_jack_shutdown_callback, this);

  997. 

  998.         fTimebaseRolling = false;

  999. 

  1000.         if (opts.transportMode == ENGINE_TRANSPORT_MODE_JACK)

  1001.             fTimebaseMaster = jackbridge_set_timebase_callback(fClient, true, carla_jack_timebase_callback, this);

  1002.         else

  1003.             fTimebaseMaster = false;

  1004. 

  1005.         if (opts.processMode != ENGINE_PROCESS_MODE_PATCHBAY)

  1006.             initJackPatchbay(true, false, jackClientName);

  1007. 

  1008.         jackbridge_set_client_registration_callback(fClient, carla_jack_client_registration_callback, this);

  1009.         jackbridge_set_port_registration_callback(fClient, carla_jack_port_registration_callback, this);

  1010.         jackbridge_set_port_connect_callback(fClient, carla_jack_port_connect_callback, this);

  1011.         jackbridge_set_port_rename_callback(fClient, carla_jack_port_rename_callback, this);

  1012.         jackbridge_set_xrun_callback(fClient, carla_jack_xrun_callback, this);

  1013. 

  1014.         if (opts.processMode == ENGINE_PROCESS_MODE_CONTINUOUS_RACK || opts.processMode == ENGINE_PROCESS_MODE_PATCHBAY)

  1015.         {

  1016.             fRackPorts[kRackPortAudioIn1]  = jackbridge_port_register(fClient, "audio-in1",  JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0);

  1017.             fRackPorts[kRackPortAudioIn2]  = jackbridge_port_register(fClient, "audio-in2",  JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0);

  1018.             fRackPorts[kRackPortAudioOut1] = jackbridge_port_register(fClient, "audio-out1", JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0);

  1019.             fRackPorts[kRackPortAudioOut2] = jackbridge_port_register(fClient, "audio-out2", JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0);

  1020.             fRackPorts[kRackPortEventIn]   = jackbridge_port_register(fClient, "events-in",  JACK_DEFAULT_MIDI_TYPE,  JackPortIsInput, 0);

  1021.             fRackPorts[kRackPortEventOut]  = jackbridge_port_register(fClient, "events-out", JACK_DEFAULT_MIDI_TYPE,  JackPortIsOutput, 0);

  1022. 

  1023.             if (opts.processMode == ENGINE_PROCESS_MODE_CONTINUOUS_RACK)

  1024.             {

  1025.                 // FIXME?

  1026.                 pData->graph.create(0, 0);

  1027.             }

  1028.             else

  1029.             {

  1030.                 pData->graph.create(2, 2);

  1031.                 // pData->graph.setUsingExternalHost(true);

  1032.                 // pData->graph.setUsingExternalOSC(true);

  1033.                 patchbayRefresh(true, false, false);

  1034.             }

  1035.         }

  1036. 

  1037.         if (const char* const uuidchar = jackbridge_client_get_uuid(fClient))

  1038.         {

  1039.             jack_uuid_t uuid;

  1040. 

  1041.             if (buggy_jack2_uuid_parse(uuidchar, &uuid) == 0)

  1042.             {

  1043. #if defined(HAVE_LIBLO) && !defined(BUILD_BRIDGE)

  1044.                 const CarlaString& tcp(pData->osc.getServerPathTCP());

  1045.                 const CarlaString& udp(pData->osc.getServerPathUDP());

  1046. 

  1047.                 if (tcp.isNotEmpty())

  1048.                     jackbridge_set_property(fClient, uuid,

  1049.                                             "https://kx.studio/ns/carla/osc-tcp", tcp.buffer(), "text/plain");

  1050. 

  1051.                 if (tcp.isNotEmpty())

  1052.                     jackbridge_set_property(fClient, uuid,

  1053.                                             "https://kx.studio/ns/carla/osc-udp", udp.buffer(), "text/plain");

  1054. #endif

  1055.             }

  1056.         }

  1057. 

  1058.         if (jackbridge_activate(fClient))

  1059.         {

  1060.             if (opts.processMode == ENGINE_PROCESS_MODE_CONTINUOUS_RACK ||

  1061.                 opts.processMode == ENGINE_PROCESS_MODE_PATCHBAY)

  1062.             {

  1063.                 if (pData->options.audioDevice != nullptr &&

  1064.                     std::strcmp(pData->options.audioDevice, "Auto-Connect ON") == 0 &&

  1065.                     std::getenv("LADISH_APP_NAME") == nullptr &&

  1066.                     std::getenv("NSM_URL") == nullptr)

  1067.                 {

  1068.                     char strBuf[STR_MAX];

  1069. 

  1070.                     if (jackbridge_port_by_name(fClient, "system:capture_1") != nullptr)

  1071.                     {

  1072.                         std::snprintf(strBuf, STR_MAX, "%s:audio-in1", jackClientName);

  1073.                         strBuf[STR_MAX-1] = '\0';

  1074. 

  1075.                         jackbridge_connect(fClient, "system:capture_1", strBuf);

  1076. 

  1077.                         std::snprintf(strBuf, STR_MAX, "%s:audio-in2", jackClientName);

  1078.                         strBuf[STR_MAX-1] = '\0';

  1079. 

  1080.                         if (jackbridge_port_by_name(fClient, "system:capture_2") != nullptr)

  1081.                             jackbridge_connect(fClient, "system:capture_2", strBuf);

  1082.                         else

  1083.                             jackbridge_connect(fClient, "system:capture_1", strBuf);

  1084.                     }

  1085. 

  1086.                     if (jackbridge_port_by_name(fClient, "system:playback_1") != nullptr)

  1087.                     {

  1088.                         std::snprintf(strBuf, STR_MAX, "%s:audio-out1", jackClientName);

  1089.                         strBuf[STR_MAX-1] = '\0';

  1090. 

  1091.                         jackbridge_connect(fClient, strBuf, "system:playback_1");

  1092. 

  1093.                         std::snprintf(strBuf, STR_MAX, "%s:audio-out2", jackClientName);

  1094.                         strBuf[STR_MAX-1] = '\0';

  1095. 

  1096.                         if (jackbridge_port_by_name(fClient, "system:playback_2") != nullptr)

  1097.                             jackbridge_connect(fClient, strBuf, "system:playback_2");

  1098.                         else

  1099.                             jackbridge_connect(fClient, strBuf, "system:playback_1");

  1100.                     }

  1101.                 }

  1102.             }

  1103. 

  1104.             startThread();

  1105.             callback(true, true,

  1106.                      ENGINE_CALLBACK_ENGINE_STARTED, 0,

  1107.                      opts.processMode,

  1108.                      opts.transportMode,

  1109.                      static_cast<int>(pData->bufferSize),

  1110.                      static_cast<float>(pData->sampleRate),

  1111.                      getCurrentDriverName());

  1112.             return true;

  1113.         }

  1114. 

  1115.         if (opts.processMode == ENGINE_PROCESS_MODE_CONTINUOUS_RACK ||

  1116.             opts.processMode == ENGINE_PROCESS_MODE_PATCHBAY)

  1117.         {

  1118.             pData->graph.destroy();

  1119.         }

  1120. 

  1121.         pData->close();

  1122.         jackbridge_client_close(fClient);

  1123.         fClient = nullptr;

  1124. 

  1125.         setLastError("Failed to activate the JACK client");

  1126.         return false;

  1127. #endif

  1128.     }

  1129. 

  1130. #ifndef BUILD_BRIDGE

  1131.     bool initInternal(jack_client_t* const client)

  1132.     {

  1133.         fClient = client;

  1134.         fIsInternalClient = true;

  1135. 

  1136.         return init(nullptr);

  1137.     }

  1138. #endif

  1139. 

  1140.     bool close() override

  1141.     {

  1142.         carla_debug("CarlaEngineJack::close()");

  1143. 

  1144. #ifdef BUILD_BRIDGE

  1145.         fClient    = nullptr;

  1146.         fIsRunning = false;

  1147.         CarlaEngine::close();

  1148.         return true;

  1149. #else

  1150.         stopThread(-1);

  1151.         fPostPonedEvents.clear();

  1152. 

  1153.         CARLA_SAFE_ASSERT_RETURN_ERR(fClient != nullptr, "JACK Client is null");

  1154. 

  1155.         // deactivate and close client

  1156.         jackbridge_deactivate(fClient);

  1157.         jackbridge_client_close(fClient);

  1158. 

  1159.         // clear engine data

  1160.         CarlaEngine::close();

  1161. 

  1162.         fUsedGroups.clear();

  1163.         fUsedPorts.clear();

  1164.         fUsedConnections.clear();

  1165.         fPostPonedEvents.clear();

  1166. 

  1167.         // clear rack/patchbay stuff

  1168.         if (pData->options.processMode == ENGINE_PROCESS_MODE_CONTINUOUS_RACK ||

  1169.             pData->options.processMode == ENGINE_PROCESS_MODE_PATCHBAY)

  1170.         {

  1171.             carla_zeroPointers(fRackPorts, kRackPortCount);

  1172.             pData->graph.destroy();

  1173.         }

  1174. 

  1175.         fClient = nullptr;

  1176.         return true;

  1177. #endif

  1178.     }

  1179. 

  1180.     bool isRunning() const noexcept override

  1181.     {

  1182. #ifdef BUILD_BRIDGE

  1183.         return (fClient != nullptr || fIsRunning);

  1184. #else

  1185.         return (fClient != nullptr);

  1186. #endif

  1187.     }

  1188. 

  1189.     bool isOffline() const noexcept override

  1190.     {

  1191.         return fFreewheel;

  1192.     }

  1193. 

  1194.     EngineType getType() const noexcept override

  1195.     {

  1196.         return kEngineTypeJack;

  1197.     }

  1198. 

  1199.     const char* getCurrentDriverName() const noexcept override

  1200.     {

  1201.         return "JACK";

  1202.     }

  1203. 

  1204. #ifndef BUILD_BRIDGE

  1205.     float getDSPLoad() const noexcept override

  1206.     {

  1207.         CARLA_SAFE_ASSERT_RETURN(fClient != nullptr, 0.0f);

  1208. 

  1209.         return jackbridge_cpu_load(fClient);

  1210.     }

  1211. #endif

  1212. 

  1213.     EngineTimeInfo getTimeInfo() const noexcept override

  1214.     {

  1215.         if (pData->options.transportMode != ENGINE_TRANSPORT_MODE_JACK)

  1216.             return CarlaEngine::getTimeInfo();

  1217.         if (pData->options.processMode != ENGINE_PROCESS_MODE_MULTIPLE_CLIENTS)

  1218.             return CarlaEngine::getTimeInfo();

  1219. 

  1220.         jack_position_t jpos;

  1221. 

  1222.         // invalidate

  1223.         jpos.unique_1 = 1;

  1224.         jpos.unique_2 = 2;

  1225. 

  1226.         EngineTimeInfo timeInfo;

  1227.         const bool playing = jackbridge_transport_query(fClient, &jpos) == JackTransportRolling;

  1228. 

  1229.         if (jpos.unique_1 != jpos.unique_2)

  1230.         {

  1231.             timeInfo.playing = false;

  1232.             timeInfo.frame = 0;

  1233.             timeInfo.usecs = 0;

  1234.             timeInfo.bbt.valid = false;

  1235.             return timeInfo;

  1236.         }

  1237. 

  1238.         timeInfo.playing = playing;

  1239.         timeInfo.frame   = jpos.frame;

  1240.         timeInfo.usecs   = jpos.usecs;

  1241. 

  1242.         if (jpos.valid & JackPositionBBT)

  1243.         {

  1244.             timeInfo.bbt.valid          = true;

  1245.             timeInfo.bbt.bar            = jpos.bar;

  1246.             timeInfo.bbt.beat           = jpos.beat;

  1247.             timeInfo.bbt.tick           = jpos.tick;

  1248.             timeInfo.bbt.barStartTick   = jpos.bar_start_tick;

  1249.             timeInfo.bbt.beatsPerBar    = jpos.beats_per_bar;

  1250.             timeInfo.bbt.beatType       = jpos.beat_type;

  1251.             timeInfo.bbt.ticksPerBeat   = jpos.ticks_per_beat;

  1252.             timeInfo.bbt.beatsPerMinute = jpos.beats_per_minute;

  1253.         }

  1254.         else

  1255.         {

  1256.             timeInfo.bbt.valid = false;

  1257.         }

  1258. 

  1259.         return timeInfo;

  1260.     }

  1261. 

  1262. #ifndef BUILD_BRIDGE

  1263.     void setOption(const EngineOption option, const int value, const char* const valueStr) noexcept override

  1264.     {

  1265.         if (option == ENGINE_OPTION_TRANSPORT_MODE && fClient != nullptr)

  1266.         {

  1267.             CARLA_SAFE_ASSERT_RETURN(value >= ENGINE_TRANSPORT_MODE_DISABLED && value <= ENGINE_TRANSPORT_MODE_JACK,);

  1268. 

  1269.             if (value == ENGINE_TRANSPORT_MODE_JACK)

  1270.             {

  1271.                 fTimebaseMaster = jackbridge_set_timebase_callback(fClient, true, carla_jack_timebase_callback, this);

  1272.             }

  1273.             else

  1274.             {

  1275.                 // jack transport cannot be disabled in multi-client

  1276.                 callback(true, true,

  1277.                          ENGINE_CALLBACK_TRANSPORT_MODE_CHANGED, 0,

  1278.                          ENGINE_TRANSPORT_MODE_JACK,

  1279.                          0, 0, 0.0f,

  1280.                          pData->options.transportExtra);

  1281.                 CARLA_SAFE_ASSERT_RETURN(pData->options.processMode != ENGINE_PROCESS_MODE_MULTIPLE_CLIENTS,);

  1282. 

  1283.                 jackbridge_release_timebase(fClient);

  1284.                 fTimebaseMaster = false;

  1285.             }

  1286.         }

  1287. 

  1288.         CarlaEngine::setOption(option, value, valueStr);

  1289.     }

  1290. #endif

  1291. 

  1292.     CarlaEngineClient* addClient(CarlaPlugin* const plugin) override

  1293.     {

  1294.         jack_client_t* client = nullptr;

  1295. 

  1296. #ifndef BUILD_BRIDGE

  1297.         if (pData->options.processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  1298.         {

  1299.             client = fClient;

  1300.         }

  1301.         else if (pData->options.processMode == ENGINE_PROCESS_MODE_MULTIPLE_CLIENTS)

  1302. #endif

  1303.         {

  1304.             client = jackbridge_client_open(plugin->getName(), JackNullOption, nullptr);

  1305. 

  1306.             CARLA_SAFE_ASSERT_RETURN(client != nullptr, nullptr);

  1307. 

  1308.             jackbridge_set_thread_init_callback(client, carla_jack_thread_init_callback, nullptr);

  1309. 

  1310. #ifndef BUILD_BRIDGE

  1311.             /*

  1312.             jackbridge_set_buffer_size_callback(fClient, carla_jack_bufsize_callback_plugin, plugin);

  1313.             jackbridge_set_sample_rate_callback(fClient, carla_jack_srate_callback_plugin, plugin);

  1314.             */

  1315.             jackbridge_set_latency_callback(client, carla_jack_latency_callback_plugin, plugin);

  1316.             jackbridge_set_process_callback(client, carla_jack_process_callback_plugin, plugin);

  1317.             jackbridge_on_shutdown(client, carla_jack_shutdown_callback_plugin, plugin);

  1318. 

  1319.             if (const char* const uuidchar = jackbridge_client_get_uuid(client))

  1320.             {

  1321.                 jack_uuid_t uuid;

  1322. 

  1323.                 if (buggy_jack2_uuid_parse(uuidchar, &uuid) == 0)

  1324.                 {

  1325.                     char strBufId[24];

  1326.                     std::snprintf(strBufId, 24, "%u", plugin->getId());

  1327.                     strBufId[23] = '\0';

  1328. 

  1329.                     jackbridge_set_property(client, uuid,

  1330.                                             "https://kx.studio/ns/carla/plugin-id",

  1331.                                             strBufId,

  1332.                                             "http://www.w3.org/2001/XMLSchema#integer");

  1333. 

  1334.                     if (const char* const pluginIcon = plugin->getIconName())

  1335.                         jackbridge_set_property(client, uuid,

  1336.                                                 "https://kx.studio/ns/carla/plugin-icon",

  1337.                                                 pluginIcon,

  1338.                                                 "text/plain");

  1339.                 }

  1340.             }

  1341. #else

  1342.             fClient = client;

  1343.             pData->bufferSize = jackbridge_get_buffer_size(client);

  1344.             pData->sampleRate = jackbridge_get_sample_rate(client);

  1345.             pData->initTime(nullptr);

  1346. 

  1347.             jackbridge_set_buffer_size_callback(client, carla_jack_bufsize_callback, this);

  1348.             jackbridge_set_sample_rate_callback(client, carla_jack_srate_callback, this);

  1349.             jackbridge_set_freewheel_callback(client, carla_jack_freewheel_callback, this);

  1350.             jackbridge_set_latency_callback(client, carla_jack_latency_callback, this);

  1351.             jackbridge_set_process_callback(client, carla_jack_process_callback, this);

  1352.             jackbridge_on_shutdown(client, carla_jack_shutdown_callback, this);

  1353. #endif

  1354.         }

  1355. 

  1356.         return new CarlaEngineJackClient(*this, client);

  1357.     }

  1358. 

  1359. #ifndef BUILD_BRIDGE

  1360.     const char* renamePlugin(const uint id, const char* const newName) override

  1361.     {

  1362.         if (pData->options.processMode == ENGINE_PROCESS_MODE_CONTINUOUS_RACK ||

  1363.             pData->options.processMode == ENGINE_PROCESS_MODE_PATCHBAY)

  1364.         {

  1365.             return CarlaEngine::renamePlugin(id, newName);

  1366.         }

  1367. 

  1368.         CARLA_SAFE_ASSERT_RETURN(pData->plugins != nullptr, nullptr);

  1369.         CARLA_SAFE_ASSERT_RETURN(pData->curPluginCount != 0, nullptr);

  1370.         CARLA_SAFE_ASSERT_RETURN(id < pData->curPluginCount, nullptr);

  1371.         CARLA_SAFE_ASSERT_RETURN(newName != nullptr && newName[0] != '\0', nullptr);

  1372. 

  1373.         CarlaPlugin* const plugin(pData->plugins[id].plugin);

  1374.         CARLA_SAFE_ASSERT_RETURN_ERRN(plugin != nullptr, "Could not find plugin to rename");

  1375.         CARLA_SAFE_ASSERT_RETURN_ERRN(plugin->getId() == id, "Invalid engine internal data");

  1376. 

  1377.         // before we stop the engine thread we might need to get the plugin data

  1378.         const bool needsReinit = (pData->options.processMode == ENGINE_PROCESS_MODE_MULTIPLE_CLIENTS);

  1379.         const CarlaStateSave* saveStatePtr = nullptr;

  1380. 

  1381.         if (needsReinit)

  1382.         {

  1383.             const CarlaStateSave& saveState(plugin->getStateSave());

  1384.             saveStatePtr = &saveState;

  1385.         }

  1386. 

  1387.         CarlaString uniqueName;

  1388. 

  1389.         try {

  1390.             const char* const tmpName = getUniquePluginName(newName);

  1391.             uniqueName = tmpName;

  1392.             delete[] tmpName;

  1393.         } CARLA_SAFE_EXCEPTION("JACK renamePlugin getUniquePluginName");

  1394. 

  1395.         if (uniqueName.isEmpty())

  1396.         {

  1397.             setLastError("Failed to request new unique plugin name");

  1398.             return nullptr;

  1399.         }

  1400. 

  1401.         const ScopedThreadStopper sts(this);

  1402. 

  1403.         // rename on client client mode, just rename the ports

  1404.         if (pData->options.processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  1405.         {

  1406.             CarlaEngineJackClient* const client((CarlaEngineJackClient*)plugin->getEngineClient());

  1407. 

  1408.             if (! client->renameInSingleClient(uniqueName))

  1409.             {

  1410.                 setLastError("Failed to rename some JACK ports, does your JACK version support proper port renaming?");

  1411.                 return nullptr;

  1412.             }

  1413.         }

  1414.         // rename in multiple client mode

  1415.         else if (pData->options.processMode == ENGINE_PROCESS_MODE_MULTIPLE_CLIENTS)

  1416.         {

  1417.             CarlaEngineJackClient* const client((CarlaEngineJackClient*)plugin->getEngineClient());

  1418. 

  1419.             // we should not be able to do this, jack really needs to allow client rename

  1420.             if (jack_client_t* const jackClient = jackbridge_client_open(uniqueName, JackNullOption, nullptr))

  1421.             {

  1422.                 // get new client name

  1423.                 uniqueName = jackbridge_get_client_name(jackClient);

  1424. 

  1425.                 // close client

  1426.                 client->closeForRename(jackClient, uniqueName);

  1427. 

  1428.                 // disable plugin

  1429.                 plugin->setEnabled(false);

  1430. 

  1431.                 // set new client data

  1432.                 jackbridge_set_latency_callback(jackClient, carla_jack_latency_callback_plugin, plugin);

  1433.                 jackbridge_set_process_callback(jackClient, carla_jack_process_callback_plugin, plugin);

  1434.                 jackbridge_on_shutdown(jackClient, carla_jack_shutdown_callback_plugin, plugin);

  1435. 

  1436.                 // NOTE: jack1 locks up here

  1437.                 if (jackbridge_get_version_string() != nullptr)

  1438.                     jackbridge_set_thread_init_callback(jackClient, carla_jack_thread_init_callback, nullptr);

  1439. 

  1440.                 /* The following code is because of a tricky situation.

  1441.                    We cannot lock or do jack operations during jack callbacks on jack1. jack2 events are asynchronous.

  1442.                    When we close the client jack will trigger unregister-port callbacks, which we handle on a separate thread ASAP.

  1443.                    But before that happens we already registered a new client with the same ports (the "renamed" one),

  1444.                     and at this point the port we receive during that callback is actually the new one from the new client..

  1445.                    JACK2 seems to be reusing ports to save space, which is understandable.

  1446.                    Anyway, this means we have to remove all our port-related data before the new client ports are created.

  1447.                    (we also stop the separate jack-events thread to avoid any race conditions while modying our port data) */

  1448. 

  1449.                 stopThread(-1);

  1450. 

  1451.                 const uint groupId(fUsedGroups.getGroupId(plugin->getName()));

  1452. 

  1453.                 if (groupId > 0)

  1454.                 {

  1455.                     for (LinkedList<PortNameToId>::Itenerator it = fUsedPorts.list.begin2(); it.valid(); it.next())

  1456.                     {

  1457.                         for (LinkedList<ConnectionToId>::Itenerator it2 = fUsedConnections.list.begin2(); it2.valid(); it2.next())

  1458.                         {

  1459.                             static ConnectionToId connectionFallback = { 0, 0, 0, 0, 0 };

  1460. 

  1461.                             ConnectionToId& connectionToId = it2.getValue(connectionFallback);

  1462.                             CARLA_SAFE_ASSERT_CONTINUE(connectionToId.id != 0);

  1463. 

  1464.                             if (connectionToId.groupA != groupId && connectionToId.groupB != groupId)

  1465.                                 continue;

  1466. 

  1467.                             callback(fExternalPatchbayHost, fExternalPatchbayOsc,

  1468.                                      ENGINE_CALLBACK_PATCHBAY_CONNECTION_REMOVED,

  1469.                                      connectionToId.id,

  1470.                                      0, 0, 0, 0.0f, nullptr);

  1471.                             fUsedConnections.list.remove(it2);

  1472.                         }

  1473. 

  1474.                         static PortNameToId portNameFallback = { 0, 0, { '\0' }, { '\0' } };

  1475. 

  1476.                         PortNameToId& portNameToId(it.getValue(portNameFallback));

  1477.                         CARLA_SAFE_ASSERT_CONTINUE(portNameToId.group != 0);

  1478. 

  1479.                         if (portNameToId.group != groupId)

  1480.                             continue;

  1481. 

  1482.                         callback(fExternalPatchbayHost, fExternalPatchbayOsc,

  1483.                                  ENGINE_CALLBACK_PATCHBAY_PORT_REMOVED,

  1484.                                  portNameToId.group,

  1485.                                  static_cast<int>(portNameToId.port),

  1486.                                  0, 0, 0.0f, nullptr);

  1487.                         fUsedPorts.list.remove(it);

  1488.                     }

  1489.                 }

  1490. 

  1491.                 startThread();

  1492.             }

  1493.             else

  1494.             {

  1495.                 setLastError("Failed to create new JACK client");

  1496.                 return nullptr;

  1497.             }

  1498.         }

  1499. 

  1500.         // Rename

  1501.         plugin->setName(uniqueName);

  1502. 

  1503.         if (needsReinit)

  1504.         {

  1505.             // reload plugin to recreate its ports

  1506.             plugin->reload();

  1507.             plugin->loadStateSave(*saveStatePtr);

  1508.             plugin->setEnabled(true);

  1509.         }

  1510. 

  1511.         return plugin->getName();

  1512.     }

  1513. 

  1514.     // -------------------------------------------------------------------

  1515.     // Patchbay

  1516. 

  1517.     bool patchbayConnect(const bool external,

  1518.                          const uint groupA, const uint portA, const uint groupB, const uint portB) override

  1519.     {

  1520.         CARLA_SAFE_ASSERT_RETURN(fClient != nullptr, false);

  1521. 

  1522.         if (pData->options.processMode == ENGINE_PROCESS_MODE_PATCHBAY && ! external)

  1523.             return CarlaEngine::patchbayConnect(false, groupA, portA, groupB, portB);

  1524. 

  1525.         const char* const fullPortNameA = fUsedPorts.getFullPortName(groupA, portA);

  1526.         CARLA_SAFE_ASSERT_RETURN(fullPortNameA != nullptr && fullPortNameA[0] != '\0', false);

  1527. 

  1528.         const char* const fullPortNameB = fUsedPorts.getFullPortName(groupB, portB);

  1529.         CARLA_SAFE_ASSERT_RETURN(fullPortNameB != nullptr && fullPortNameB[0] != '\0', false);

  1530. 

  1531.         if (! jackbridge_connect(fClient, fullPortNameA, fullPortNameB))

  1532.         {

  1533.             setLastError("JACK operation failed");

  1534.             return false;

  1535.         }

  1536. 

  1537.         return true;

  1538.     }

  1539. 

  1540.     bool patchbayDisconnect(const bool external, const uint connectionId) override

  1541.     {

  1542.         CARLA_SAFE_ASSERT_RETURN(fClient != nullptr, false);

  1543. 

  1544.         if (pData->options.processMode == ENGINE_PROCESS_MODE_PATCHBAY && ! external)

  1545.             return CarlaEngine::patchbayDisconnect(false, connectionId);

  1546. 

  1547.         ConnectionToId connectionToId = { 0, 0, 0, 0, 0 };

  1548. 

  1549.         {

  1550.             const CarlaMutexLocker cml(fUsedConnections.mutex);

  1551. 

  1552.             for (LinkedList<ConnectionToId>::Itenerator it = fUsedConnections.list.begin2(); it.valid(); it.next())

  1553.             {

  1554.                 connectionToId = it.getValue(connectionToId);

  1555.                 CARLA_SAFE_ASSERT_CONTINUE(connectionToId.id != 0);

  1556. 

  1557.                 if (connectionToId.id == connectionId)

  1558.                     break;

  1559.             }

  1560.         }

  1561. 

  1562.         if (connectionToId.id == 0 || connectionToId.id != connectionId)

  1563.         {

  1564.             setLastError("Failed to find the requested connection");

  1565.             return false;

  1566.         }

  1567. 

  1568.         const char* const fullPortNameA = fUsedPorts.getFullPortName(connectionToId.groupA, connectionToId.portA);

  1569.         CARLA_SAFE_ASSERT_RETURN(fullPortNameA != nullptr && fullPortNameA[0] != '\0', false);

  1570. 

  1571.         const char* const fullPortNameB = fUsedPorts.getFullPortName(connectionToId.groupB, connectionToId.portB);

  1572.         CARLA_SAFE_ASSERT_RETURN(fullPortNameB != nullptr && fullPortNameB[0] != '\0', false);

  1573. 

  1574.         if (! jackbridge_disconnect(fClient, fullPortNameA, fullPortNameB))

  1575.         {

  1576.             setLastError("JACK operation failed");

  1577.             return false;

  1578.         }

  1579. 

  1580.         return true;

  1581.     }

  1582. 

  1583.     bool patchbayRefresh(const bool sendHost, const bool sendOSC, const bool external) override

  1584.     {

  1585.         CARLA_SAFE_ASSERT_RETURN(fClient != nullptr, false);

  1586.         carla_debug("patchbayRefresh(%s, %s, %s)", bool2str(sendHost), bool2str(sendOSC), bool2str(external));

  1587. 

  1588.         if (pData->options.processMode == ENGINE_PROCESS_MODE_PATCHBAY)

  1589.         {

  1590.             if (sendHost)

  1591.             {

  1592.                 fExternalPatchbayHost = external;

  1593.                 pData->graph.setUsingExternalHost(external);

  1594.             }

  1595.             if (sendOSC)

  1596.             {

  1597.                 fExternalPatchbayOsc = external;

  1598.                 pData->graph.setUsingExternalOSC(external);

  1599.             }

  1600. 

  1601.             if (! external)

  1602.                 return CarlaEngine::patchbayRefresh(sendHost, sendOSC, false);

  1603.         }

  1604. 

  1605.         fUsedGroups.clear();

  1606.         fUsedPorts.clear();

  1607.         fUsedConnections.clear();

  1608. 

  1609.         initJackPatchbay(sendHost, sendOSC, jackbridge_get_client_name(fClient));

  1610.         return true;

  1611.     }

  1612. 

  1613.     // -------------------------------------------------------------------

  1614.     // Transport

  1615. 

  1616.     void transportPlay() noexcept override

  1617.     {

  1618.         if (pData->options.transportMode != ENGINE_TRANSPORT_MODE_JACK)

  1619.             return CarlaEngine::transportPlay();

  1620. 

  1621.         if (fClient != nullptr)

  1622.         {

  1623.             if (! pData->timeInfo.bbt.valid)

  1624.             {

  1625.                 // old timebase master no longer active, make ourselves master again

  1626.                 pData->time.setNeedsReset();

  1627.                 fTimebaseMaster = jackbridge_set_timebase_callback(fClient, true, carla_jack_timebase_callback, this);

  1628.             }

  1629. 

  1630.             try {

  1631.                 jackbridge_transport_start(fClient);

  1632.             } catch(...) {}

  1633.         }

  1634.     }

  1635. 

  1636.     void transportPause() noexcept override

  1637.     {

  1638.         if (pData->options.transportMode != ENGINE_TRANSPORT_MODE_JACK)

  1639.             return CarlaEngine::transportPause();

  1640. 

  1641.         if (fClient != nullptr)

  1642.         {

  1643.             try {

  1644.                 jackbridge_transport_stop(fClient);

  1645.             } catch(...) {}

  1646.         }

  1647.     }

  1648. 

  1649.     void transportBPM(const double bpm) noexcept override

  1650.     {

  1651.         if (pData->options.transportMode != ENGINE_TRANSPORT_MODE_JACK || fTimebaseMaster)

  1652.             return CarlaEngine::transportBPM(bpm);

  1653. 

  1654.         if (fClient == nullptr)

  1655.             return;

  1656. 

  1657.         jack_position_t jpos;

  1658. 

  1659.         // invalidate

  1660.         jpos.unique_1 = 1;

  1661.         jpos.unique_2 = 2;

  1662.         jackbridge_transport_query(fClient, &jpos);

  1663. 

  1664.         if (jpos.unique_1 == jpos.unique_2 && (jpos.valid & JackPositionBBT) != 0)

  1665.         {

  1666.             carla_stdout("NOTE: Changing BPM without being JACK timebase master");

  1667.             jpos.beats_per_minute = bpm;

  1668. 

  1669.             try {

  1670.                 jackbridge_transport_reposition(fClient, &jpos);

  1671.             } catch(...) {}

  1672.         }

  1673.     }

  1674. 

  1675.     void transportRelocate(const uint64_t frame) noexcept override

  1676.     {

  1677.         if (pData->options.transportMode != ENGINE_TRANSPORT_MODE_JACK)

  1678.             return CarlaEngine::transportRelocate(frame);

  1679. 

  1680.         if (fClient != nullptr)

  1681.         {

  1682.             try {

  1683.                 jackbridge_transport_locate(fClient, static_cast<jack_nframes_t>(frame));

  1684.             } catch(...) {}

  1685.         }

  1686.     }

  1687. 

  1688.     // -------------------------------------------------------------------

  1689.     // Patchbay stuff

  1690. 

  1691.     const char* const* getPatchbayConnections(const bool external) const override

  1692.     {

  1693.         CARLA_SAFE_ASSERT_RETURN(fClient != nullptr, nullptr);

  1694.         carla_debug("CarlaEngineJack::getPatchbayConnections(%s)", bool2str(external));

  1695. 

  1696.         if (pData->options.processMode == ENGINE_PROCESS_MODE_PATCHBAY && ! external)

  1697.             return CarlaEngine::getPatchbayConnections(external);

  1698. 

  1699.         CarlaStringList connList;

  1700. 

  1701.         if (const char** const ports = jackbridge_get_ports(fClient, nullptr, nullptr, JackPortIsOutput))

  1702.         {

  1703.             for (int i=0; ports[i] != nullptr; ++i)

  1704.             {

  1705.                 const jack_port_t* const jackPort(jackbridge_port_by_name(fClient, ports[i]));

  1706.                 const char* const fullPortName(ports[i]);

  1707. 

  1708.                 CARLA_SAFE_ASSERT_CONTINUE(jackPort != nullptr);

  1709. 

  1710.                 if (const char** const connections = jackbridge_port_get_all_connections(fClient, jackPort))

  1711.                 {

  1712.                     for (int j=0; connections[j] != nullptr; ++j)

  1713.                     {

  1714.                         connList.append(fullPortName);

  1715.                         connList.append(connections[j]);

  1716.                     }

  1717. 

  1718.                     jackbridge_free(connections);

  1719.                 }

  1720.             }

  1721. 

  1722.             jackbridge_free(ports);

  1723.         }

  1724. 

  1725.         if (connList.count() == 0)

  1726.             return nullptr;

  1727. 

  1728.         fRetConns = connList.toCharStringListPtr();

  1729. 

  1730.         return fRetConns;

  1731.     }

  1732. 

  1733.     void restorePatchbayConnection(const bool external, const char* const connSource, const char* const connTarget) override

  1734.     {

  1735.         CARLA_SAFE_ASSERT_RETURN(fClient != nullptr,);

  1736.         CARLA_SAFE_ASSERT_RETURN(connSource != nullptr && connSource[0] != '\0',);

  1737.         CARLA_SAFE_ASSERT_RETURN(connTarget != nullptr && connTarget[0] != '\0',);

  1738.         carla_debug("CarlaEngineJack::restorePatchbayConnection(%s, \"%s\", \"%s\")",

  1739.                     bool2str(external), connSource, connTarget);

  1740. 

  1741.         if (pData->options.processMode == ENGINE_PROCESS_MODE_PATCHBAY && ! external)

  1742.             return CarlaEngine::restorePatchbayConnection(external, connSource, connTarget);

  1743. 

  1744.         if (const jack_port_t* const port = jackbridge_port_by_name(fClient, connSource))

  1745.         {

  1746.             if (jackbridge_port_by_name(fClient, connTarget) == nullptr)

  1747.                 return;

  1748. 

  1749.             if (! jackbridge_port_connected_to(port, connTarget))

  1750.                 jackbridge_connect(fClient, connSource, connTarget);

  1751.         }

  1752.     }

  1753. #endif

  1754. 

  1755.     // -------------------------------------------------------------------

  1756. 

  1757. protected:

  1758.     void handleJackBufferSizeCallback(const uint32_t newBufferSize)

  1759.     {

  1760.         if (pData->bufferSize == newBufferSize)

  1761.             return;

  1762. 

  1763. #ifndef BUILD_BRIDGE

  1764.         const CarlaMutexLocker cml(fPatchbayProcThreadProtectionMutex);

  1765. #endif

  1766. 

  1767.         pData->bufferSize = newBufferSize;

  1768.         bufferSizeChanged(newBufferSize);

  1769.     }

  1770. 

  1771.     void handleJackSampleRateCallback(const double newSampleRate)

  1772.     {

  1773.         if (carla_isEqual(pData->sampleRate, newSampleRate))

  1774.             return;

  1775. 

  1776. #ifndef BUILD_BRIDGE

  1777.         const CarlaMutexLocker cml(fPatchbayProcThreadProtectionMutex);

  1778. #endif

  1779. 

  1780.         pData->sampleRate = newSampleRate;

  1781.         sampleRateChanged(newSampleRate);

  1782.     }

  1783. 

  1784.     void handleJackFreewheelCallback(const bool isFreewheel)

  1785.     {

  1786.         if (fFreewheel == isFreewheel)

  1787.             return;

  1788. 

  1789. #ifndef BUILD_BRIDGE

  1790.         const CarlaMutexLocker cml(fPatchbayProcThreadProtectionMutex);

  1791. #endif

  1792. 

  1793.         fFreewheel = isFreewheel;

  1794.         offlineModeChanged(isFreewheel);

  1795.     }

  1796. 

  1797.     void handleJackProcessCallback(const uint32_t nframes)

  1798.     {

  1799.         const PendingRtEventsRunner prt(this, nframes);

  1800. 

  1801.         CARLA_SAFE_ASSERT_INT2_RETURN(nframes == pData->bufferSize, nframes, pData->bufferSize,);

  1802. 

  1803. #ifdef BUILD_BRIDGE

  1804.         CarlaPlugin* const plugin(pData->plugins[0].plugin);

  1805. 

  1806.         if (plugin != nullptr && plugin->isEnabled() && plugin->tryLock(fFreewheel))

  1807.         {

  1808.             plugin->initBuffers();

  1809.             processPlugin(plugin, nframes);

  1810.             plugin->unlock();

  1811.         }

  1812. #else

  1813.         if (pData->options.transportMode == ENGINE_TRANSPORT_MODE_JACK && !fTimebaseMaster)

  1814.         {

  1815.             jack_position_t jpos;

  1816. 

  1817.             // invalidate

  1818.             jpos.unique_1 = 1;

  1819.             jpos.unique_2 = 2;

  1820. 

  1821.             EngineTimeInfo timeInfo;

  1822.             const bool playing = jackbridge_transport_query(fClient, &jpos) == JackTransportRolling;

  1823. 

  1824.             if (jpos.unique_1 != jpos.unique_2)

  1825.             {

  1826.                 timeInfo.playing = false;

  1827.                 timeInfo.frame = 0;

  1828.                 timeInfo.usecs = 0;

  1829.                 timeInfo.bbt.valid = false;

  1830.             }

  1831.             else

  1832.             {

  1833.                 timeInfo.playing = playing;

  1834.                 timeInfo.frame   = jpos.frame;

  1835.                 timeInfo.usecs   = jpos.usecs;

  1836. 

  1837.                 if (jpos.valid & JackPositionBBT)

  1838.                 {

  1839.                     timeInfo.bbt.valid          = true;

  1840.                     timeInfo.bbt.bar            = jpos.bar;

  1841.                     timeInfo.bbt.beat           = jpos.beat;

  1842.                     timeInfo.bbt.tick           = jpos.tick;

  1843.                     timeInfo.bbt.barStartTick   = jpos.bar_start_tick;

  1844.                     timeInfo.bbt.beatsPerBar    = jpos.beats_per_bar;

  1845.                     timeInfo.bbt.beatType       = jpos.beat_type;

  1846.                     timeInfo.bbt.ticksPerBeat   = jpos.ticks_per_beat;

  1847.                     timeInfo.bbt.beatsPerMinute = jpos.beats_per_minute;

  1848.                 }

  1849.                 else

  1850.                 {

  1851.                     timeInfo.bbt.valid = false;

  1852.                 }

  1853.             }

  1854. 

  1855.             pData->timeInfo = timeInfo;

  1856.         }

  1857. 

  1858.         if (pData->options.processMode == ENGINE_PROCESS_MODE_CONTINUOUS_RACK)

  1859.         {

  1860.             if (pData->aboutToClose)

  1861.             {

  1862.                 if (float* const audioOut1 = (float*)jackbridge_port_get_buffer(fRackPorts[kRackPortAudioOut1], nframes))

  1863.                     carla_zeroFloats(audioOut1, nframes);

  1864. 

  1865.                 if (float* const audioOut2 = (float*)jackbridge_port_get_buffer(fRackPorts[kRackPortAudioOut2], nframes))

  1866.                     carla_zeroFloats(audioOut2, nframes);

  1867.             }

  1868.             else if (pData->curPluginCount == 0)

  1869.             {

  1870.                 float* const audioIn1  = (float*)jackbridge_port_get_buffer(fRackPorts[kRackPortAudioIn1], nframes);

  1871.                 float* const audioIn2  = (float*)jackbridge_port_get_buffer(fRackPorts[kRackPortAudioIn2], nframes);

  1872.                 float* const audioOut1 = (float*)jackbridge_port_get_buffer(fRackPorts[kRackPortAudioOut1], nframes);

  1873.                 float* const audioOut2 = (float*)jackbridge_port_get_buffer(fRackPorts[kRackPortAudioOut2], nframes);

  1874. 

  1875.                 // assert buffers

  1876.                 CARLA_SAFE_ASSERT_RETURN(audioIn1 != nullptr,);

  1877.                 CARLA_SAFE_ASSERT_RETURN(audioIn2 != nullptr,);

  1878.                 CARLA_SAFE_ASSERT_RETURN(audioOut1 != nullptr,);

  1879.                 CARLA_SAFE_ASSERT_RETURN(audioOut2 != nullptr,);

  1880. 

  1881.                 // pass-through

  1882.                 carla_copyFloats(audioOut1, audioIn1, nframes);

  1883.                 carla_copyFloats(audioOut2, audioIn2, nframes);

  1884. 

  1885.                 // TODO pass-through MIDI as well

  1886.                 if (void* const eventOut = jackbridge_port_get_buffer(fRackPorts[kRackPortEventOut], nframes))

  1887.                     jackbridge_midi_clear_buffer(eventOut);

  1888. 

  1889.                 return;

  1890.             }

  1891.         }

  1892. 

  1893.         if (pData->options.processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  1894.         {

  1895.             for (uint i=0; i < pData->curPluginCount; ++i)

  1896.             {

  1897.                 CarlaPlugin* const plugin(pData->plugins[i].plugin);

  1898. 

  1899.                 if (plugin != nullptr && plugin->isEnabled() && plugin->tryLock(fFreewheel))

  1900.                 {

  1901.                     plugin->initBuffers();

  1902.                     processPlugin(plugin, nframes);

  1903.                     plugin->unlock();

  1904.                 }

  1905.             }

  1906.         }

  1907.         else if (pData->options.processMode == ENGINE_PROCESS_MODE_CONTINUOUS_RACK ||

  1908.                  pData->options.processMode == ENGINE_PROCESS_MODE_PATCHBAY)

  1909.         {

  1910.             CARLA_SAFE_ASSERT_RETURN(pData->events.in  != nullptr,);

  1911.             CARLA_SAFE_ASSERT_RETURN(pData->events.out != nullptr,);

  1912. 

  1913.             // get buffers from jack

  1914.             float* const audioIn1  = (float*)jackbridge_port_get_buffer(fRackPorts[kRackPortAudioIn1], nframes);

  1915.             float* const audioIn2  = (float*)jackbridge_port_get_buffer(fRackPorts[kRackPortAudioIn2], nframes);

  1916.             float* const audioOut1 = (float*)jackbridge_port_get_buffer(fRackPorts[kRackPortAudioOut1], nframes);

  1917.             float* const audioOut2 = (float*)jackbridge_port_get_buffer(fRackPorts[kRackPortAudioOut2], nframes);

  1918.             void* const  eventIn   = jackbridge_port_get_buffer(fRackPorts[kRackPortEventIn],  nframes);

  1919.             void* const  eventOut  = jackbridge_port_get_buffer(fRackPorts[kRackPortEventOut], nframes);

  1920. 

  1921.             // assert buffers

  1922.             CARLA_SAFE_ASSERT_RETURN(audioIn1 != nullptr,);

  1923.             CARLA_SAFE_ASSERT_RETURN(audioIn2 != nullptr,);

  1924.             CARLA_SAFE_ASSERT_RETURN(audioOut1 != nullptr,);

  1925.             CARLA_SAFE_ASSERT_RETURN(audioOut2 != nullptr,);

  1926. 

  1927.             // create audio buffers

  1928.             const float* inBuf[2]  = { audioIn1, audioIn2 };

  1929.             /**/  float* outBuf[2] = { audioOut1, audioOut2 };

  1930. 

  1931.             // initialize events

  1932.             carla_zeroStructs(pData->events.in,  kMaxEngineEventInternalCount);

  1933.             carla_zeroStructs(pData->events.out, kMaxEngineEventInternalCount);

  1934. 

  1935.             if (eventIn != nullptr)

  1936.             {

  1937.                 ushort engineEventIndex = 0;

  1938. 

  1939.                 jack_midi_event_t jackEvent;

  1940.                 const uint32_t jackEventCount(jackbridge_midi_get_event_count(eventIn));

  1941. 

  1942.                 for (uint32_t jackEventIndex=0; jackEventIndex < jackEventCount; ++jackEventIndex)

  1943.                 {

  1944.                     if (! jackbridge_midi_event_get(&jackEvent, eventIn, jackEventIndex))

  1945.                         continue;

  1946. 

  1947.                     CARLA_SAFE_ASSERT_CONTINUE(jackEvent.size < 0xFF /* uint8_t max */);

  1948. 

  1949.                     EngineEvent& engineEvent(pData->events.in[engineEventIndex++]);

  1950. 

  1951.                     engineEvent.time = jackEvent.time;

  1952.                     engineEvent.fillFromMidiData(static_cast<uint8_t>(jackEvent.size), jackEvent.buffer, 0);

  1953. 

  1954.                     if (engineEventIndex >= kMaxEngineEventInternalCount)

  1955.                         break;

  1956.                 }

  1957.             }

  1958. 

  1959.             if (pData->options.processMode == ENGINE_PROCESS_MODE_CONTINUOUS_RACK)

  1960.             {

  1961.                 pData->graph.processRack(pData, inBuf, outBuf, nframes);

  1962.             }

  1963.             else

  1964.             {

  1965.                 const CarlaMutexLocker cml(fPatchbayProcThreadProtectionMutex);

  1966.                 pData->graph.process(pData, inBuf, outBuf, nframes);

  1967.             }

  1968. 

  1969.             // output control

  1970.             if (eventOut != nullptr)

  1971.             {

  1972.                 jackbridge_midi_clear_buffer(eventOut);

  1973. 

  1974.                 uint8_t  size     = 0;

  1975.                 uint8_t  mdata[3] = { 0, 0, 0 };

  1976.                 uint8_t  mdataTmp[EngineMidiEvent::kDataSize];

  1977.                 const uint8_t* mdataPtr;

  1978. 

  1979.                 for (ushort i=0; i < kMaxEngineEventInternalCount; ++i)

  1980.                 {

  1981.                     const EngineEvent& engineEvent(pData->events.out[i]);

  1982. 

  1983.                     /**/ if (engineEvent.type == kEngineEventTypeNull)

  1984.                     {

  1985.                         break;

  1986.                     }

  1987.                     else if (engineEvent.type == kEngineEventTypeControl)

  1988.                     {

  1989.                         const EngineControlEvent& ctrlEvent(engineEvent.ctrl);

  1990. 

  1991.                         size = ctrlEvent.convertToMidiData(engineEvent.channel, mdata);

  1992.                         mdataPtr = mdata;

  1993.                     }

  1994.                     else if (engineEvent.type == kEngineEventTypeMidi)

  1995.                     {

  1996.                         const EngineMidiEvent& midiEvent(engineEvent.midi);

  1997. 

  1998.                         size = midiEvent.size;

  1999.                         CARLA_SAFE_ASSERT_CONTINUE(size > 0);

  2000. 

  2001.                         if (size > EngineMidiEvent::kDataSize)

  2002.                         {

  2003.                             CARLA_SAFE_ASSERT_CONTINUE(midiEvent.dataExt != nullptr);

  2004.                             mdataPtr = midiEvent.dataExt;

  2005.                         }

  2006.                         else

  2007.                         {

  2008.                             // set first byte

  2009.                             mdataTmp[0] = static_cast<uint8_t>(midiEvent.data[0] | (engineEvent.channel & MIDI_CHANNEL_BIT));

  2010. 

  2011.                             // copy rest

  2012.                             carla_copy<uint8_t>(mdataTmp+1, midiEvent.data+1, size-1U);

  2013. 

  2014.                             // done

  2015.                             mdataPtr = mdataTmp;

  2016.                         }

  2017.                     }

  2018.                     else

  2019.                     {

  2020.                         continue;

  2021.                     }

  2022. 

  2023.                     if (size > 0)

  2024.                         jackbridge_midi_event_write(eventOut, engineEvent.time, mdataPtr, size);

  2025.                 }

  2026.             }

  2027.         }

  2028. 

  2029.         if (pData->options.transportMode == ENGINE_TRANSPORT_MODE_JACK)

  2030.         {

  2031.             if (fTimebaseMaster)

  2032.             {

  2033.                 const bool playing = jackbridge_transport_query(fClient, nullptr) == JackTransportRolling;

  2034. 

  2035.                 if (fTimebaseRolling != playing)

  2036.                 {

  2037.                     fTimebaseRolling = playing;

  2038.                     pData->timeInfo.playing = playing;

  2039.                 }

  2040. 

  2041.                 // Check if we are no longer timebase master

  2042.                 if (playing && fTimebaseUsecs != 0 && fTimebaseUsecs == pData->timeInfo.usecs)

  2043.                 {

  2044.                     carla_debug("No longer timerbase master");

  2045.                     fTimebaseMaster = false;

  2046.                 }

  2047.             }

  2048. 

  2049.             fTimebaseUsecs = pData->timeInfo.usecs;

  2050.         }

  2051. #endif // ! BUILD_BRIDGE

  2052.     }

  2053. 

  2054.     void handleJackLatencyCallback(const jack_latency_callback_mode_t /*mode*/)

  2055.     {

  2056.         // TODO

  2057.     }

  2058. 

  2059. #ifndef BUILD_BRIDGE

  2060.     void handleJackTimebaseCallback(jack_nframes_t nframes, jack_position_t* const pos, const int new_pos)

  2061.     {

  2062.         if (new_pos)

  2063.             pData->time.setNeedsReset();

  2064. 

  2065.         pData->timeInfo.playing = fTimebaseRolling;

  2066.         pData->timeInfo.frame = pos->frame;

  2067.         pData->timeInfo.usecs = pos->usecs;

  2068.         pData->time.fillJackTimeInfo(pos, nframes);

  2069.     }

  2070. 

  2071.     void handleJackClientRegistrationCallback(const char* const name, const bool reg)

  2072.     {

  2073.         CARLA_SAFE_ASSERT_RETURN(name != nullptr && name[0] != '\0',);

  2074. 

  2075.         // ignore this if on internal patchbay mode

  2076. #if defined(HAVE_LIBLO) && !defined(BUILD_BRIDGE)

  2077.         if (! (fExternalPatchbayHost || (fExternalPatchbayOsc && pData->osc.isControlRegisteredForTCP()))) return;

  2078. #else

  2079.         if (! fExternalPatchbayHost) return;

  2080. #endif

  2081. 

  2082.         // do nothing on client registration, wait for first port

  2083.         if (reg) return;

  2084. 

  2085.         const uint groupId(fUsedGroups.getGroupId(name));

  2086. 

  2087.         // clients might have been registered without ports

  2088.         if (groupId == 0) return;

  2089. 

  2090.         GroupNameToId groupNameToId;

  2091.         groupNameToId.setData(groupId, name);

  2092. 

  2093.         callback(fExternalPatchbayHost, fExternalPatchbayOsc,

  2094.                  ENGINE_CALLBACK_PATCHBAY_CLIENT_REMOVED, groupNameToId.group, 0, 0, 0, 0.0f, nullptr);

  2095. 

  2096.         fUsedGroups.list.removeOne(groupNameToId);

  2097.     }

  2098. 

  2099.     void handleJackPortRegistrationCallback(const jack_port_id_t port, const bool reg)

  2100.     {

  2101.         // ignore this if on internal patchbay mode

  2102. #if defined(HAVE_LIBLO) && !defined(BUILD_BRIDGE)

  2103.         if (! (fExternalPatchbayHost || (fExternalPatchbayOsc && pData->osc.isControlRegisteredForTCP()))) return;

  2104. #else

  2105.         if (! fExternalPatchbayHost) return;

  2106. #endif

  2107. 

  2108.         const jack_port_t* const jackPort(jackbridge_port_by_id(fClient, port));

  2109.         CARLA_SAFE_ASSERT_RETURN(jackPort != nullptr,);

  2110. 

  2111.         const char* const fullPortName(jackbridge_port_name(jackPort));

  2112.         CARLA_SAFE_ASSERT_RETURN(fullPortName != nullptr && fullPortName[0] != '\0',);

  2113. 

  2114.         if (reg)

  2115.         {

  2116.             const char* const shortPortName(jackbridge_port_short_name(jackPort));

  2117.             CARLA_SAFE_ASSERT_RETURN(shortPortName != nullptr && shortPortName[0] != '\0',);

  2118. 

  2119.             bool found;

  2120.             CarlaString groupName(fullPortName);

  2121.             groupName.truncate(groupName.rfind(shortPortName, &found)-1);

  2122. 

  2123.             CARLA_SAFE_ASSERT_RETURN(found,);

  2124. 

  2125.             const int jackPortFlags(jackbridge_port_flags(jackPort));

  2126. 

  2127.             uint groupId(fUsedGroups.getGroupId(groupName));

  2128. 

  2129.             if (groupId == 0)

  2130.             {

  2131.                 groupId = ++fUsedGroups.lastId;

  2132. 

  2133.                 GroupNameToId groupNameToId;

  2134.                 groupNameToId.setData(groupId, groupName);

  2135. 

  2136.                 int pluginId = -1;

  2137.                 PatchbayIcon icon = (jackPortFlags & JackPortIsPhysical) ? PATCHBAY_ICON_HARDWARE : PATCHBAY_ICON_APPLICATION;

  2138. 

  2139.                 findPluginIdAndIcon(groupName, pluginId, icon);

  2140. 

  2141.                 callback(fExternalPatchbayHost, fExternalPatchbayOsc,

  2142.                          ENGINE_CALLBACK_PATCHBAY_CLIENT_ADDED,

  2143.                          groupNameToId.group,

  2144.                          icon,

  2145.                          pluginId,

  2146.                          0, 0.0f,

  2147.                          groupNameToId.name);

  2148. 

  2149.                 fUsedGroups.list.append(groupNameToId);

  2150.             }

  2151. 

  2152.             addPatchbayJackPort(fExternalPatchbayHost, fExternalPatchbayOsc,

  2153.                                 groupId, jackPort, shortPortName, fullPortName, jackPortFlags);

  2154.         }

  2155.         else

  2156.         {

  2157.             const PortNameToId& portNameToId(fUsedPorts.getPortNameToId(fullPortName));

  2158. 

  2159.             /* NOTE: Due to JACK2 async behaviour the port we get here might be the same of a previous rename-plugin request.

  2160.                      See the comment on CarlaEngineJack::renamePlugin() for more information. */

  2161.             if (portNameToId.group <= 0 || portNameToId.port <= 0) return;

  2162. 

  2163.             callback(fExternalPatchbayHost, fExternalPatchbayOsc,

  2164.                      ENGINE_CALLBACK_PATCHBAY_PORT_REMOVED,

  2165.                      portNameToId.group,

  2166.                      static_cast<int>(portNameToId.port),

  2167.                      0, 0, 0.0f, nullptr);

  2168.             fUsedPorts.list.removeOne(portNameToId);

  2169.         }

  2170.     }

  2171. 

  2172.     void handleJackPortConnectCallback(const jack_port_id_t a, const jack_port_id_t b, const bool connect)

  2173.     {

  2174.         // ignore this if on internal patchbay mode

  2175. #if defined(HAVE_LIBLO) && !defined(BUILD_BRIDGE)

  2176.         if (! (fExternalPatchbayHost || (fExternalPatchbayOsc && pData->osc.isControlRegisteredForTCP()))) return;

  2177. #else

  2178.         if (! fExternalPatchbayHost) return;

  2179. #endif

  2180. 

  2181.         const jack_port_t* const jackPortA(jackbridge_port_by_id(fClient, a));

  2182.         CARLA_SAFE_ASSERT_RETURN(jackPortA != nullptr,);

  2183. 

  2184.         const jack_port_t* const jackPortB(jackbridge_port_by_id(fClient, b));

  2185.         CARLA_SAFE_ASSERT_RETURN(jackPortB != nullptr,);

  2186. 

  2187.         const char* const fullPortNameA(jackbridge_port_name(jackPortA));

  2188.         CARLA_SAFE_ASSERT_RETURN(fullPortNameA != nullptr && fullPortNameA[0] != '\0',);

  2189. 

  2190.         const char* const fullPortNameB(jackbridge_port_name(jackPortB));

  2191.         CARLA_SAFE_ASSERT_RETURN(fullPortNameB != nullptr && fullPortNameB[0] != '\0',);

  2192. 

  2193.         const PortNameToId& portNameToIdA(fUsedPorts.getPortNameToId(fullPortNameA));

  2194.         const PortNameToId& portNameToIdB(fUsedPorts.getPortNameToId(fullPortNameB));

  2195. 

  2196.         /* NOTE: Due to JACK2 async behaviour the port we get here might be the same of a previous rename-plugin request.

  2197.                  See the comment on CarlaEngineJack::renamePlugin() for more information. */

  2198.         if (portNameToIdA.group <= 0 || portNameToIdA.port <= 0) return;

  2199.         if (portNameToIdB.group <= 0 || portNameToIdB.port <= 0) return;

  2200. 

  2201.         if (connect)

  2202.         {

  2203.             char strBuf[STR_MAX+1];

  2204.             std::snprintf(strBuf, STR_MAX, "%i:%i:%i:%i", portNameToIdA.group, portNameToIdA.port, portNameToIdB.group, portNameToIdB.port);

  2205.             strBuf[STR_MAX] = '\0';

  2206. 

  2207.             ConnectionToId connectionToId;

  2208.             connectionToId.setData(++fUsedConnections.lastId, portNameToIdA.group, portNameToIdA.port, portNameToIdB.group, portNameToIdB.port);

  2209. 

  2210.             callback(fExternalPatchbayHost, fExternalPatchbayOsc,

  2211.                      ENGINE_CALLBACK_PATCHBAY_CONNECTION_ADDED,

  2212.                      connectionToId.id,

  2213.                      0, 0, 0, 0.0f,

  2214.                      strBuf);

  2215.             fUsedConnections.list.append(connectionToId);

  2216.         }

  2217.         else

  2218.         {

  2219.             ConnectionToId connectionToId = { 0, 0, 0, 0, 0 };

  2220.             bool found = false;

  2221. 

  2222.             {

  2223.                 const CarlaMutexLocker cml(fUsedConnections.mutex);

  2224. 

  2225.                 for (LinkedList<ConnectionToId>::Itenerator it = fUsedConnections.list.begin2(); it.valid(); it.next())

  2226.                 {

  2227.                     connectionToId = it.getValue(connectionToId);

  2228.                     CARLA_SAFE_ASSERT_CONTINUE(connectionToId.id != 0);

  2229. 

  2230.                     if (connectionToId.groupA == portNameToIdA.group && connectionToId.portA == portNameToIdA.port &&

  2231.                         connectionToId.groupB == portNameToIdB.group && connectionToId.portB == portNameToIdB.port)

  2232.                     {

  2233.                         found = true;

  2234.                         fUsedConnections.list.remove(it);

  2235.                         break;

  2236.                     }

  2237.                 }

  2238.             }

  2239. 

  2240.             if (found) {

  2241.                 callback(fExternalPatchbayHost, fExternalPatchbayOsc,

  2242.                          ENGINE_CALLBACK_PATCHBAY_CONNECTION_REMOVED,

  2243.                          connectionToId.id,

  2244.                          0, 0, 0, 0.0f, nullptr);

  2245.             }

  2246.         }

  2247.     }

  2248. 

  2249.     void handleJackPortRenameCallback(const jack_port_id_t port, const char* const oldFullName, const char* const newFullName)

  2250.     {

  2251.         // ignore this if on internal patchbay mode

  2252. #if defined(HAVE_LIBLO) && !defined(BUILD_BRIDGE)

  2253.         if (! (fExternalPatchbayHost || (fExternalPatchbayOsc && pData->osc.isControlRegisteredForTCP()))) return;

  2254. #else

  2255.         if (! fExternalPatchbayHost) return;

  2256. #endif

  2257. 

  2258.         CARLA_SAFE_ASSERT_RETURN(oldFullName != nullptr && oldFullName[0] != '\0',);

  2259.         CARLA_SAFE_ASSERT_RETURN(newFullName != nullptr && newFullName[0] != '\0',);

  2260. 

  2261.         const jack_port_t* const jackPort(jackbridge_port_by_id(fClient, port));

  2262.         CARLA_SAFE_ASSERT_RETURN(jackPort != nullptr,);

  2263. 

  2264.         const char* const shortPortName(jackbridge_port_short_name(jackPort));

  2265.         CARLA_SAFE_ASSERT_RETURN(shortPortName != nullptr && shortPortName[0] != '\0',);

  2266. 

  2267.         bool found;

  2268.         CarlaString groupName(newFullName);

  2269.         groupName.truncate(groupName.rfind(shortPortName, &found)-1);

  2270. 

  2271.         CARLA_SAFE_ASSERT_RETURN(found,);

  2272. 

  2273.         const uint groupId(fUsedGroups.getGroupId(groupName));

  2274.         CARLA_SAFE_ASSERT_RETURN(groupId > 0,);

  2275. 

  2276.         for (LinkedList<PortNameToId>::Itenerator it = fUsedPorts.list.begin2(); it.valid(); it.next())

  2277.         {

  2278.             static PortNameToId portNameFallback = { 0, 0, { '\0' }, { '\0' } };

  2279. 

  2280.             PortNameToId& portNameToId(it.getValue(portNameFallback));

  2281.             CARLA_SAFE_ASSERT_CONTINUE(portNameToId.group != 0);

  2282. 

  2283.             if (std::strncmp(portNameToId.fullName, oldFullName, STR_MAX) == 0)

  2284.             {

  2285.                 CARLA_SAFE_ASSERT_CONTINUE(portNameToId.group == groupId);

  2286. 

  2287.                 portNameToId.rename(shortPortName, newFullName);

  2288.                 callback(fExternalPatchbayHost, fExternalPatchbayOsc,

  2289.                          ENGINE_CALLBACK_PATCHBAY_PORT_RENAMED,

  2290.                          portNameToId.group,

  2291.                          static_cast<int>(portNameToId.port),

  2292.                          0, 0, 0.0f,

  2293.                          portNameToId.name);

  2294.                 break;

  2295.             }

  2296.         }

  2297.     }

  2298. #endif

  2299. 

  2300.     void handleJackShutdownCallback()

  2301.     {

  2302. #ifndef BUILD_BRIDGE

  2303.         signalThreadShouldExit();

  2304. #endif

  2305. 

  2306.         const PendingRtEventsRunner prt(this, pData->bufferSize);

  2307. 

  2308.         for (uint i=0; i < pData->curPluginCount; ++i)

  2309.         {

  2310.             if (CarlaPlugin* const plugin = pData->plugins[i].plugin)

  2311.             {

  2312.                 plugin->tryLock(true);

  2313. 

  2314.                 if (CarlaEngineJackClient* const client = (CarlaEngineJackClient*)plugin->getEngineClient())

  2315.                     client->invalidate();

  2316. 

  2317.                 plugin->unlock();

  2318.             }

  2319.         }

  2320. 

  2321.         fClient = nullptr;

  2322. #ifndef BUILD_BRIDGE

  2323.         carla_zeroPointers(fRackPorts, kRackPortCount);

  2324. #endif

  2325. 

  2326.         callback(true, true, ENGINE_CALLBACK_QUIT, 0, 0, 0, 0, 0.0f, nullptr);

  2327.     }

  2328. 

  2329.     // -------------------------------------------------------------------

  2330. 

  2331.     void handlePluginJackShutdownCallback(CarlaPlugin* const plugin)

  2332.     {

  2333.         CarlaEngineJackClient* const engineClient((CarlaEngineJackClient*)plugin->getEngineClient());

  2334.         CARLA_SAFE_ASSERT_RETURN(engineClient != nullptr,);

  2335. 

  2336.         plugin->tryLock(true);

  2337.         engineClient->invalidate();

  2338.         plugin->unlock();

  2339. 

  2340.         //if (pData->nextAction.pluginId == plugin->getId())

  2341.         //    pData->nextAction.clearAndReset();

  2342. 

  2343.         callback(true, true, ENGINE_CALLBACK_PLUGIN_UNAVAILABLE, plugin->getId(), 0, 0, 0, 0.0f, "Killed by JACK");

  2344.     }

  2345. 

  2346.     // -------------------------------------------------------------------

  2347. 

  2348. private:

  2349.     jack_client_t* fClient;

  2350.     bool fExternalPatchbayHost;

  2351.     bool fExternalPatchbayOsc;

  2352.     bool fFreewheel;

  2353. 

  2354.     // -------------------------------------------------------------------

  2355. 

  2356. #ifdef BUILD_BRIDGE

  2357.     bool fIsRunning;

  2358. #else

  2359.     enum RackPorts {

  2360.         kRackPortAudioIn1  = 0,

  2361.         kRackPortAudioIn2  = 1,

  2362.         kRackPortAudioOut1 = 2,

  2363.         kRackPortAudioOut2 = 3,

  2364.         kRackPortEventIn   = 4,

  2365.         kRackPortEventOut  = 5,

  2366.         kRackPortCount     = 6

  2367.     };

  2368. 

  2369.     jack_port_t* fRackPorts[kRackPortCount];

  2370. 

  2371.     bool fTimebaseMaster;

  2372.     bool fTimebaseRolling;

  2373.     uint64_t fTimebaseUsecs;

  2374. 

  2375.     PatchbayGroupList      fUsedGroups;

  2376.     PatchbayPortList       fUsedPorts;

  2377.     PatchbayConnectionList fUsedConnections;

  2378.     CarlaMutex             fPatchbayProcThreadProtectionMutex;

  2379. 

  2380.     mutable CharStringListPtr fRetConns;

  2381. 

  2382.     void findPluginIdAndIcon(const char* const clientName, int& pluginId, PatchbayIcon& icon) const noexcept

  2383.     {

  2384.         carla_debug("CarlaEngineJack::findPluginIdAndIcon(\"%s\", ...)", clientName);

  2385. 

  2386.         // TODO - this currently only works in multi-client mode

  2387.         if (pData->options.processMode != ENGINE_PROCESS_MODE_MULTIPLE_CLIENTS)

  2388.             return;

  2389. 

  2390.         const char* const uuidstr = jackbridge_get_uuid_for_client_name(fClient, clientName);

  2391.         CARLA_SAFE_ASSERT_RETURN(uuidstr != nullptr && uuidstr[0] != '\0',);

  2392. 

  2393.         jack_uuid_t uuid;

  2394.         CARLA_SAFE_ASSERT_RETURN(buggy_jack2_uuid_parse(uuidstr, &uuid) == 0,);

  2395. 

  2396.         {

  2397.             char* value = nullptr;

  2398.             char* type = nullptr;

  2399. 

  2400.             if (! jackbridge_get_property(uuid, "https://kx.studio/ns/carla/plugin-id", &value, &type))

  2401.                 return;

  2402. 

  2403.             CARLA_SAFE_ASSERT_RETURN(type != nullptr && type[0] != '\0',);

  2404.             CARLA_SAFE_ASSERT_RETURN(value != nullptr && value[0] != '\0',);

  2405.             CARLA_SAFE_ASSERT_RETURN(std::strcmp(type, "http://www.w3.org/2001/XMLSchema#integer") == 0,);

  2406. 

  2407.             pluginId = std::atoi(value);

  2408.             icon     = PATCHBAY_ICON_PLUGIN;

  2409.         }

  2410. 

  2411.         {

  2412.             char* value = nullptr;

  2413.             char* type = nullptr;

  2414. 

  2415.             if (! jackbridge_get_property(uuid, "https://kx.studio/ns/carla/plugin-icon", &value, &type))

  2416.                 return;

  2417. 

  2418.             CARLA_SAFE_ASSERT_RETURN(type != nullptr && type[0] != '\0',);

  2419.             CARLA_SAFE_ASSERT_RETURN(value != nullptr && value[0] != '\0',);

  2420.             CARLA_SAFE_ASSERT_RETURN(std::strcmp(type, "text/plain") == 0,);

  2421. 

  2422.             /**/ if (std::strcmp(value, "app") == 0)

  2423.                 icon = PATCHBAY_ICON_APPLICATION;

  2424.             else if (std::strcmp(value, "application") == 0)

  2425.                 icon = PATCHBAY_ICON_APPLICATION;

  2426.             else if (std::strcmp(value, "plugin") == 0)

  2427.                 icon = PATCHBAY_ICON_PLUGIN;

  2428.             else if (std::strcmp(value, "hardware") == 0)

  2429.                 icon = PATCHBAY_ICON_HARDWARE;

  2430.             else if (std::strcmp(value, "carla") == 0)

  2431.                 icon = PATCHBAY_ICON_CARLA;

  2432.             else if (std::strcmp(value, "distrho") == 0)

  2433.                 icon = PATCHBAY_ICON_DISTRHO;

  2434.             else if (std::strcmp(value, "file") == 0)

  2435.                 icon = PATCHBAY_ICON_FILE;

  2436.         }

  2437.     }

  2438. 

  2439.     void initJackPatchbay(const bool sendHost, const bool sendOSC, const char* const ourName)

  2440.     {

  2441.         CARLA_SAFE_ASSERT_RETURN(pData->options.processMode != ENGINE_PROCESS_MODE_PATCHBAY ||

  2442.                                  (fExternalPatchbayHost && sendHost) || (fExternalPatchbayOsc && sendOSC),);

  2443.         CARLA_SAFE_ASSERT_RETURN(ourName != nullptr && ourName[0] != '\0',);

  2444. 

  2445.         CarlaStringList parsedGroups;

  2446. 

  2447.         // add our client first

  2448.         {

  2449.             parsedGroups.append(ourName);

  2450. 

  2451.             GroupNameToId groupNameToId;

  2452.             groupNameToId.setData(++fUsedGroups.lastId, ourName);

  2453. 

  2454.             callback(sendHost, sendOSC,

  2455.                      ENGINE_CALLBACK_PATCHBAY_CLIENT_ADDED,

  2456.                      groupNameToId.group,

  2457.                      PATCHBAY_ICON_CARLA,

  2458.                      MAIN_CARLA_PLUGIN_ID,

  2459.                      0, 0.0f,

  2460.                      groupNameToId.name);

  2461.             fUsedGroups.list.append(groupNameToId);

  2462.         }

  2463. 

  2464.         // query all jack ports

  2465.         {

  2466.             const char** const ports = jackbridge_get_ports(fClient, nullptr, nullptr, 0);

  2467.             CARLA_SAFE_ASSERT_RETURN(ports != nullptr,);

  2468. 

  2469.             for (int i=0; ports[i] != nullptr; ++i)

  2470.             {

  2471.                 const char* const fullPortName(ports[i]);

  2472.                 CARLA_SAFE_ASSERT_CONTINUE(fullPortName != nullptr && fullPortName[0] != '\0');

  2473. 

  2474.                 const jack_port_t* const jackPort(jackbridge_port_by_name(fClient, fullPortName));

  2475.                 CARLA_SAFE_ASSERT_CONTINUE(jackPort != nullptr);

  2476. 

  2477.                 const char* const shortPortName(jackbridge_port_short_name(jackPort));

  2478.                 CARLA_SAFE_ASSERT_CONTINUE(shortPortName != nullptr && shortPortName[0] != '\0');

  2479. 

  2480.                 const int jackPortFlags(jackbridge_port_flags(jackPort));

  2481. 

  2482.                 uint groupId = 0;

  2483. 

  2484.                 bool found;

  2485.                 CarlaString groupName(fullPortName);

  2486.                 groupName.truncate(groupName.rfind(shortPortName, &found)-1);

  2487. 

  2488.                 CARLA_SAFE_ASSERT_CONTINUE(found);

  2489. 

  2490.                 if (parsedGroups.contains(groupName))

  2491.                 {

  2492.                     groupId = fUsedGroups.getGroupId(groupName);

  2493.                     CARLA_SAFE_ASSERT_CONTINUE(groupId > 0);

  2494.                 }

  2495.                 else

  2496.                 {

  2497.                     groupId = ++fUsedGroups.lastId;

  2498.                     parsedGroups.append(groupName);

  2499. 

  2500.                     GroupNameToId groupNameToId;

  2501.                     groupNameToId.setData(groupId, groupName);

  2502. 

  2503.                     int pluginId = -1;

  2504.                     PatchbayIcon icon = (jackPortFlags & JackPortIsPhysical) ? PATCHBAY_ICON_HARDWARE : PATCHBAY_ICON_APPLICATION;

  2505. 

  2506.                     findPluginIdAndIcon(groupName, pluginId, icon);

  2507. 

  2508.                     callback(sendHost, sendOSC,

  2509.                              ENGINE_CALLBACK_PATCHBAY_CLIENT_ADDED,

  2510.                              groupNameToId.group,

  2511.                              icon,

  2512.                              pluginId,

  2513.                              0, 0.0f,

  2514.                              groupNameToId.name);

  2515.                     fUsedGroups.list.append(groupNameToId);

  2516.                 }

  2517. 

  2518.                 addPatchbayJackPort(sendHost, sendOSC, groupId, jackPort, shortPortName, fullPortName, jackPortFlags);

  2519.             }

  2520. 

  2521.             jackbridge_free(ports);

  2522.         }

  2523. 

  2524.         // query connections, after all ports are in place

  2525.         if (const char** const ports = jackbridge_get_ports(fClient, nullptr, nullptr, JackPortIsOutput))

  2526.         {

  2527.             char strBuf[STR_MAX+1];

  2528. 

  2529.             for (int i=0; ports[i] != nullptr; ++i)

  2530.             {

  2531.                 const char* const fullPortName(ports[i]);

  2532.                 CARLA_SAFE_ASSERT_CONTINUE(fullPortName != nullptr && fullPortName[0] != '\0');

  2533. 

  2534.                 const jack_port_t* const jackPort(jackbridge_port_by_name(fClient, fullPortName));

  2535.                 CARLA_SAFE_ASSERT_CONTINUE(jackPort != nullptr);

  2536. 

  2537.                 const PortNameToId& thisPort(fUsedPorts.getPortNameToId(fullPortName));

  2538. 

  2539.                 CARLA_SAFE_ASSERT_CONTINUE(thisPort.group > 0);

  2540.                 CARLA_SAFE_ASSERT_CONTINUE(thisPort.port > 0);

  2541. 

  2542.                 if (const char** const connections = jackbridge_port_get_all_connections(fClient, jackPort))

  2543.                 {

  2544.                     for (int j=0; connections[j] != nullptr; ++j)

  2545.                     {

  2546.                         const char* const connection(connections[j]);

  2547.                         CARLA_SAFE_ASSERT_CONTINUE(connection != nullptr && connection[0] != '\0');

  2548. 

  2549.                         const PortNameToId& targetPort(fUsedPorts.getPortNameToId(connection));

  2550. 

  2551.                         CARLA_SAFE_ASSERT_CONTINUE(targetPort.group > 0);

  2552.                         CARLA_SAFE_ASSERT_CONTINUE(targetPort.port > 0);

  2553. 

  2554.                         std::snprintf(strBuf, STR_MAX, "%i:%i:%i:%i", thisPort.group, thisPort.port, targetPort.group, targetPort.port);

  2555.                         strBuf[STR_MAX] = '\0';

  2556. 

  2557.                         ConnectionToId connectionToId;

  2558.                         connectionToId.setData(++fUsedConnections.lastId, thisPort.group, thisPort.port, targetPort.group, targetPort.port);

  2559. 

  2560.                         callback(sendHost, sendOSC,

  2561.                                  ENGINE_CALLBACK_PATCHBAY_CONNECTION_ADDED,

  2562.                                  connectionToId.id,

  2563.                                  0, 0, 0, 0.0f,

  2564.                                  strBuf);

  2565.                         fUsedConnections.list.append(connectionToId);

  2566.                     }

  2567. 

  2568.                     jackbridge_free(connections);

  2569.                 }

  2570.             }

  2571. 

  2572.             jackbridge_free(ports);

  2573.         }

  2574.     }

  2575. 

  2576.     void addPatchbayJackPort(const bool sendHost, const bool sendOSC,

  2577.                              const uint groupId, const jack_port_t* const jackPort,

  2578.                              const char* const shortPortName, const char* const fullPortName, const int jackPortFlags)

  2579.     {

  2580.         bool portIsInput = (jackPortFlags & JackPortIsInput);

  2581.         bool portIsAudio = (std::strcmp(jackbridge_port_type(jackPort), JACK_DEFAULT_AUDIO_TYPE) == 0);

  2582.         bool portIsMIDI  = (std::strcmp(jackbridge_port_type(jackPort), JACK_DEFAULT_MIDI_TYPE) == 0);

  2583.         bool portIsCV    = false;

  2584.         bool portIsOSC   = false;

  2585. 

  2586.         if (const jack_uuid_t uuid = jackbridge_port_uuid(jackPort))

  2587.         {

  2588.             char* value = nullptr;

  2589.             char* type  = nullptr;

  2590. 

  2591.             if (jackbridge_get_property(uuid, JACKEY_SIGNAL_TYPE, &value, &type)

  2592.                 && value != nullptr

  2593.                 && type != nullptr

  2594.                 && std::strcmp(type, "text/plain") == 0)

  2595.             {

  2596.                 portIsCV  = (std::strcmp(value, "CV") == 0);

  2597.                 portIsOSC = (std::strcmp(value, "OSC") == 0);

  2598.             }

  2599.         }

  2600. 

  2601.         uint canvasPortFlags = 0x0;

  2602.         canvasPortFlags |= portIsInput ? PATCHBAY_PORT_IS_INPUT : 0x0;

  2603. 

  2604.         /**/ if (portIsCV)

  2605.             canvasPortFlags |= PATCHBAY_PORT_TYPE_CV;

  2606.         else if (portIsOSC)

  2607.             canvasPortFlags |= PATCHBAY_PORT_TYPE_OSC;

  2608.         else if (portIsAudio)

  2609.             canvasPortFlags |= PATCHBAY_PORT_TYPE_AUDIO;

  2610.         else if (portIsMIDI)

  2611.             canvasPortFlags |= PATCHBAY_PORT_TYPE_MIDI;

  2612. 

  2613.         PortNameToId portNameToId;

  2614.         portNameToId.setData(groupId, ++fUsedPorts.lastId, shortPortName, fullPortName);

  2615. 

  2616.         callback(sendHost, sendOSC,

  2617.                  ENGINE_CALLBACK_PATCHBAY_PORT_ADDED,

  2618.                  portNameToId.group,

  2619.                  static_cast<int>(portNameToId.port),

  2620.                  static_cast<int>(canvasPortFlags),

  2621.                  0, 0.0f,

  2622.                  portNameToId.name);

  2623.         fUsedPorts.list.append(portNameToId);

  2624.     }

  2625. #endif

  2626. 

  2627.     // -------------------------------------------------------------------

  2628. 

  2629.     void processPlugin(CarlaPlugin* const plugin, const uint32_t nframes)

  2630.     {

  2631.         const uint32_t audioInCount(plugin->getAudioInCount());

  2632.         const uint32_t audioOutCount(plugin->getAudioOutCount());

  2633.         const uint32_t cvInCount(plugin->getCVInCount());

  2634.         const uint32_t cvOutCount(plugin->getCVOutCount());

  2635. 

  2636.         const float* audioIn[audioInCount];

  2637.         /* */ float* audioOut[audioOutCount];

  2638.         const float* cvIn[cvInCount];

  2639.         /* */ float* cvOut[cvOutCount];

  2640. 

  2641.         for (uint32_t i=0; i < audioInCount; ++i)

  2642.         {

  2643.             CarlaEngineAudioPort* const port(plugin->getAudioInPort(i));

  2644.             audioIn[i] = port->getBuffer();

  2645.         }

  2646. 

  2647.         for (uint32_t i=0; i < audioOutCount; ++i)

  2648.         {

  2649.             CarlaEngineAudioPort* const port(plugin->getAudioOutPort(i));

  2650.             audioOut[i] = port->getBuffer();

  2651.         }

  2652. 

  2653.         for (uint32_t i=0; i < cvInCount; ++i)

  2654.         {

  2655.             CarlaEngineCVPort* const port(plugin->getCVInPort(i));

  2656.             cvIn[i] = port->getBuffer();

  2657.         }

  2658. 

  2659.         for (uint32_t i=0; i < cvOutCount; ++i)

  2660.         {

  2661.             CarlaEngineCVPort* const port(plugin->getCVOutPort(i));

  2662.             cvOut[i] = port->getBuffer();

  2663.         }

  2664. 

  2665.         float inPeaks[2] = { 0.0f };

  2666.         float outPeaks[2] = { 0.0f };

  2667. 

  2668.         for (uint32_t i=0; i < audioInCount && i < 2; ++i)

  2669.         {

  2670.             for (uint32_t j=0; j < nframes; ++j)

  2671.             {

  2672.                 const float absV(std::abs(audioIn[i][j]));

  2673. 

  2674.                 if (absV > inPeaks[i])

  2675.                     inPeaks[i] = absV;

  2676.             }

  2677.         }

  2678. 

  2679.         plugin->process(audioIn, audioOut, cvIn, cvOut, nframes);

  2680. 

  2681.         for (uint32_t i=0; i < audioOutCount && i < 2; ++i)

  2682.         {

  2683.             for (uint32_t j=0; j < nframes; ++j)

  2684.             {

  2685.                 const float absV(std::abs(audioOut[i][j]));

  2686. 

  2687.                 if (absV > outPeaks[i])

  2688.                     outPeaks[i] = absV;

  2689.             }

  2690.         }

  2691. 

  2692.         setPluginPeaksRT(plugin->getId(), inPeaks, outPeaks);

  2693.     }

  2694. 

  2695. #ifndef BUILD_BRIDGE

  2696.     // -------------------------------------------------------------------

  2697. 

  2698.     struct PostPonedJackEvent {

  2699.         enum Type {

  2700.             kTypeNull = 0,

  2701.             kTypeClientRegister,

  2702.             kTypePortRegister,

  2703.             kTypePortConnect,

  2704.             kTypePortRename

  2705.         };

  2706. 

  2707.         Type type;

  2708.         bool action; // register or connect

  2709.         jack_port_id_t port1;

  2710.         jack_port_id_t port2;

  2711.         char name1[STR_MAX+1];

  2712.         char name2[STR_MAX+1];

  2713.     };

  2714. 

  2715.     LinkedList<PostPonedJackEvent> fPostPonedEvents;

  2716.     CarlaMutex fPostPonedEventsMutex;

  2717. 

  2718.     bool fIsInternalClient;

  2719. 

  2720.     void postPoneJackCallback(const PostPonedJackEvent& ev)

  2721.     {

  2722.         const CarlaMutexLocker cml(fPostPonedEventsMutex);

  2723.         fPostPonedEvents.append(ev);

  2724.     }

  2725. 

  2726.     void run() override

  2727.     {

  2728.         LinkedList<PostPonedJackEvent> events;

  2729. 

  2730.         PostPonedJackEvent nullEvent;

  2731.         carla_zeroStruct(nullEvent);

  2732. 

  2733.         for (; ! shouldThreadExit();)

  2734.         {

  2735.             if (fIsInternalClient)

  2736.                 idle();

  2737. 

  2738.             {

  2739.                 const CarlaMutexLocker cml(fPostPonedEventsMutex);

  2740. 

  2741.                 if (fPostPonedEvents.count() > 0)

  2742.                     fPostPonedEvents.moveTo(events);

  2743.             }

  2744. 

  2745.             if (fClient == nullptr)

  2746.                 break;

  2747. 

  2748.             if (events.count() == 0)

  2749.             {

  2750.                 carla_msleep(fIsInternalClient ? 50 : 200);

  2751.                 continue;

  2752.             }

  2753. 

  2754.             for (LinkedList<PostPonedJackEvent>::Itenerator it = events.begin2(); it.valid(); it.next())

  2755.             {

  2756.                 const PostPonedJackEvent& ev(it.getValue(nullEvent));

  2757.                 CARLA_SAFE_ASSERT_CONTINUE(ev.type != PostPonedJackEvent::kTypeNull);

  2758. 

  2759.                 switch (ev.type)

  2760.                 {

  2761.                 case PostPonedJackEvent::kTypeNull:

  2762.                     break;

  2763.                 case PostPonedJackEvent::kTypeClientRegister:

  2764.                     handleJackClientRegistrationCallback(ev.name1, ev.action);

  2765.                     break;

  2766.                 case PostPonedJackEvent::kTypePortRegister:

  2767.                     handleJackPortRegistrationCallback(ev.port1, ev.action);

  2768.                     break;

  2769.                 case PostPonedJackEvent::kTypePortConnect:

  2770.                     handleJackPortConnectCallback(ev.port1, ev.port2, ev.action);

  2771.                     break;

  2772.                 case PostPonedJackEvent::kTypePortRename:

  2773.                     handleJackPortRenameCallback(ev.port1, ev.name1, ev.name2);

  2774.                     break;

  2775.                 }

  2776.             }

  2777. 

  2778.             events.clear();

  2779.         }

  2780. 

  2781.         events.clear();

  2782.     }

  2783. #endif //  BUILD_BRIDGE

  2784. 

  2785.     // -------------------------------------------------------------------

  2786. 

  2787. // disable -Wattributes warnings

  2788. #if defined(__clang__)

  2789. # pragma clang diagnostic push

  2790. # pragma clang diagnostic ignored "-Wattributes"

  2791. #elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))

  2792. # pragma GCC diagnostic push

  2793. # pragma GCC diagnostic ignored "-Wattributes"

  2794. #endif

  2795. 

  2796.     #define handlePtr ((CarlaEngineJack*)arg)

  2797. 

  2798.     static void JACKBRIDGE_API carla_jack_thread_init_callback(void*)

  2799.     {

  2800. #ifdef __SSE2_MATH__

  2801.         // Set FTZ and DAZ flags

  2802.         _mm_setcsr(_mm_getcsr() | 0x8040);

  2803. #endif

  2804.     }

  2805. 

  2806.     static int JACKBRIDGE_API carla_jack_bufsize_callback(jack_nframes_t newBufferSize, void* arg)

  2807.     {

  2808.         handlePtr->handleJackBufferSizeCallback(newBufferSize);

  2809.         return 0;

  2810.     }

  2811. 

  2812.     static int JACKBRIDGE_API carla_jack_srate_callback(jack_nframes_t newSampleRate, void* arg)

  2813.     {

  2814.         handlePtr->handleJackSampleRateCallback(newSampleRate);

  2815.         return 0;

  2816.     }

  2817. 

  2818.     static void JACKBRIDGE_API carla_jack_freewheel_callback(int starting, void* arg)

  2819.     {

  2820.         handlePtr->handleJackFreewheelCallback(bool(starting));

  2821.     }

  2822. 

  2823.     static void JACKBRIDGE_API carla_jack_latency_callback(jack_latency_callback_mode_t mode, void* arg)

  2824.     {

  2825.         handlePtr->handleJackLatencyCallback(mode);

  2826.     }

  2827. 

  2828.     static int JACKBRIDGE_API carla_jack_process_callback(jack_nframes_t nframes, void* arg) __attribute__((annotate("realtime")))

  2829.     {

  2830.         handlePtr->handleJackProcessCallback(nframes);

  2831.         return 0;

  2832.     }

  2833. 

  2834. #ifndef BUILD_BRIDGE

  2835.     static void JACKBRIDGE_API carla_jack_timebase_callback(jack_transport_state_t, jack_nframes_t nframes, jack_position_t* pos, int new_pos, void* arg) __attribute__((annotate("realtime")))

  2836.     {

  2837.         handlePtr->handleJackTimebaseCallback(nframes, pos, new_pos);

  2838.     }

  2839. 

  2840.     static void JACKBRIDGE_API carla_jack_client_registration_callback(const char* name, int reg, void* arg)

  2841.     {

  2842.         PostPonedJackEvent ev;

  2843.         carla_zeroStruct(ev);

  2844.         ev.type   = PostPonedJackEvent::kTypeClientRegister;

  2845.         ev.action = (reg != 0);

  2846.         std::strncpy(ev.name1, name, STR_MAX);

  2847.         handlePtr->postPoneJackCallback(ev);

  2848.     }

  2849. 

  2850.     static void JACKBRIDGE_API carla_jack_port_registration_callback(jack_port_id_t port, int reg, void* arg)

  2851.     {

  2852.         PostPonedJackEvent ev;

  2853.         carla_zeroStruct(ev);

  2854.         ev.type   = PostPonedJackEvent::kTypePortRegister;

  2855.         ev.action = (reg != 0);

  2856.         ev.port1  = port;

  2857.         handlePtr->postPoneJackCallback(ev);

  2858.     }

  2859. 

  2860.     static void JACKBRIDGE_API carla_jack_port_connect_callback(jack_port_id_t a, jack_port_id_t b, int connect, void* arg)

  2861.     {

  2862.         PostPonedJackEvent ev;

  2863.         carla_zeroStruct(ev);

  2864.         ev.type   = PostPonedJackEvent::kTypePortConnect;

  2865.         ev.action = (connect != 0);

  2866.         ev.port1  = a;

  2867.         ev.port2  = b;

  2868.         handlePtr->postPoneJackCallback(ev);

  2869.     }

  2870. 

  2871.     static void JACKBRIDGE_API carla_jack_port_rename_callback(jack_port_id_t port, const char* oldName, const char* newName, void* arg)

  2872.     {

  2873.         PostPonedJackEvent ev;

  2874.         carla_zeroStruct(ev);

  2875.         ev.type  = PostPonedJackEvent::kTypePortRename;

  2876.         ev.port1 = port;

  2877.         std::strncpy(ev.name1, oldName, STR_MAX);

  2878.         std::strncpy(ev.name2, newName, STR_MAX);

  2879.         handlePtr->postPoneJackCallback(ev);

  2880.     }

  2881. 

  2882.     static int JACKBRIDGE_API carla_jack_xrun_callback(void* arg)

  2883.     {

  2884.         ++(handlePtr->pData->xruns);

  2885.         return 0;

  2886.     }

  2887. #endif

  2888. 

  2889.     static void JACKBRIDGE_API carla_jack_shutdown_callback(void* arg)

  2890.     {

  2891.         handlePtr->handleJackShutdownCallback();

  2892.     }

  2893. 

  2894.     #undef handlePtr

  2895. 

  2896.     // -------------------------------------------------------------------

  2897. 

  2898. #ifndef BUILD_BRIDGE

  2899.     static int JACKBRIDGE_API carla_jack_process_callback_plugin(jack_nframes_t nframes, void* arg) __attribute__((annotate("realtime")))

  2900.     {

  2901.         CarlaPlugin* const plugin((CarlaPlugin*)arg);

  2902.         CARLA_SAFE_ASSERT_RETURN(plugin != nullptr && plugin->isEnabled(), 0);

  2903. 

  2904.         CarlaEngineJack* const engine((CarlaEngineJack*)plugin->getEngine());

  2905.         CARLA_SAFE_ASSERT_RETURN(engine != nullptr, 0);

  2906. 

  2907.         if (plugin->tryLock(engine->fFreewheel))

  2908.         {

  2909.             plugin->initBuffers();

  2910.             engine->processPlugin(plugin, nframes);

  2911.             plugin->unlock();

  2912.         }

  2913. 

  2914.         return 0;

  2915.     }

  2916. 

  2917.     /*

  2918.     static int JACKBRIDGE_API carla_jack_bufsize_callback_plugin(jack_nframes_t nframes, void* arg)

  2919.     {

  2920.         CarlaPlugin* const plugin((CarlaPlugin*)arg);

  2921.         CARLA_SAFE_ASSERT_RETURN(plugin != nullptr && plugin->isEnabled(), 0);

  2922. 

  2923.         plugin->bufferSizeChanged(nframes);

  2924.         return 1;

  2925.     }

  2926. 

  2927.     static int JACKBRIDGE_API carla_jack_srate_callback_plugin(jack_nframes_t nframes, void* arg)

  2928.     {

  2929.         CarlaPlugin* const plugin((CarlaPlugin*)arg);

  2930.         CARLA_SAFE_ASSERT_RETURN(plugin != nullptr && plugin->isEnabled(), 0);

  2931. 

  2932.         plugin->sampleRateChanged(nframes);

  2933.         return 1;

  2934.     }

  2935.     */

  2936. 

  2937.     static void JACKBRIDGE_API carla_jack_latency_callback_plugin(jack_latency_callback_mode_t /*mode*/, void* /*arg*/)

  2938.     {

  2939.         // TODO

  2940.     }

  2941. 

  2942.     static void JACKBRIDGE_API carla_jack_shutdown_callback_plugin(void* arg)

  2943.     {

  2944.         CarlaPlugin* const plugin((CarlaPlugin*)arg);

  2945.         CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  2946. 

  2947.         CarlaEngineJack* const engine((CarlaEngineJack*)plugin->getEngine());

  2948.         CARLA_SAFE_ASSERT_RETURN(engine != nullptr,);

  2949. 

  2950.         engine->handlePluginJackShutdownCallback(plugin);

  2951.     }

  2952. #endif

  2953. 

  2954. // enable -Wattributes again

  2955. #if defined(__clang__)

  2956. # pragma clang diagnostic pop

  2957. #elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))

  2958. # pragma GCC diagnostic pop

  2959. #endif

  2960. 

  2961.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaEngineJack)

  2962. };

  2963. 

  2964. // -----------------------------------------------------------------------

  2965. 

  2966. CarlaEngine* CarlaEngine::newJack()

  2967. {

  2968.     carla_debug("CarlaEngine::newJack()");

  2969.     return new CarlaEngineJack();

  2970. }

  2971. 

  2972. // -----------------------------------------------------------------------

  2973. 

  2974. CARLA_BACKEND_END_NAMESPACE

  2975. 

  2976. #ifndef BUILD_BRIDGE

  2977. // -----------------------------------------------------------------------

  2978. // internal jack client

  2979. 

  2980. CARLA_EXPORT

  2981. int jack_initialize (jack_client_t *client, const char *load_init);

  2982. 

  2983. CARLA_EXPORT

  2984. void jack_finish(void *arg);

  2985. 

  2986. #ifdef CARLA_OS_UNIX

  2987. # include "ThreadSafeFFTW.hpp"

  2988. static ThreadSafeFFTW sThreadSafeFFTW;

  2989. #endif

  2990. 

  2991. // -----------------------------------------------------------------------

  2992. 

  2993. CARLA_EXPORT

  2994. int jack_initialize(jack_client_t* const client, const char* const load_init)

  2995. {

  2996.     CARLA_BACKEND_USE_NAMESPACE

  2997. 

  2998.     EngineProcessMode mode;

  2999.     if (load_init != nullptr && std::strcmp(load_init, "rack") == 0)

  3000.         mode = ENGINE_PROCESS_MODE_CONTINUOUS_RACK;

  3001.     else

  3002.         mode = ENGINE_PROCESS_MODE_MULTIPLE_CLIENTS;

  3003. 

  3004. #ifdef USING_JUCE

  3005.     juce::initialiseJuce_GUI();

  3006. #endif

  3007. 

  3008.     CarlaEngineJack* const engine = new CarlaEngineJack();

  3009. 

  3010.     engine->setOption(ENGINE_OPTION_FORCE_STEREO, 1, nullptr);

  3011.     engine->setOption(ENGINE_OPTION_AUDIO_DEVICE, 0, "Auto-Connect ON");

  3012.     engine->setOption(ENGINE_OPTION_OSC_ENABLED,  1, nullptr);

  3013.     engine->setOption(ENGINE_OPTION_OSC_PORT_TCP, 22752, nullptr);

  3014.     engine->setOption(ENGINE_OPTION_OSC_PORT_UDP, 22752, nullptr);

  3015. 

  3016.     engine->setOption(ENGINE_OPTION_PROCESS_MODE, mode, nullptr);

  3017.     engine->setOption(ENGINE_OPTION_TRANSPORT_MODE, ENGINE_TRANSPORT_MODE_JACK, nullptr);

  3018. 

  3019.     // FIXME

  3020.     engine->setOption(ENGINE_OPTION_PATH_BINARIES, 0, "");

  3021.     engine->setOption(ENGINE_OPTION_PATH_RESOURCES, 0, "");

  3022. 

  3023.     if (engine->initInternal(client))

  3024.     {

  3025. #ifdef CARLA_OS_UNIX

  3026.         sThreadSafeFFTW.init();

  3027. #endif

  3028.         return 0;

  3029.     }

  3030.     else

  3031.     {

  3032.         delete engine;

  3033. #ifdef USING_JUCE

  3034.         juce::shutdownJuce_GUI();

  3035. #endif

  3036.         return 1;

  3037.     }

  3038. }

  3039. 

  3040. CARLA_EXPORT

  3041. void jack_finish(void *arg)

  3042. {

  3043.     CARLA_BACKEND_USE_NAMESPACE

  3044. 

  3045.     CarlaEngineJack* const engine = (CarlaEngineJack*)arg;;

  3046.     CARLA_SAFE_ASSERT_RETURN(engine != nullptr,);

  3047. 

  3048. #ifdef CARLA_OS_UNIX

  3049.     const ThreadSafeFFTW::Deinitializer tsfftwde(sThreadSafeFFTW);

  3050. #endif

  3051. 

  3052.     engine->setAboutToClose();

  3053.     engine->removeAllPlugins();

  3054.     engine->close();

  3055.     delete engine;

  3056. 

  3057. #ifdef USING_JUCE

  3058.     juce::shutdownJuce_GUI();

  3059. #endif

  3060. }

  3061. 

  3062. // -----------------------------------------------------------------------

  3063. #endif