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

2242 lines
74KB
Raw Blame History 

  1. /*

  2.  * Carla JACK Engine

  3.  * Copyright (C) 2012-2013 Filipe Coelho <falktx@falktx.com>

  4.  *

  5.  * This program is free software; you can redistribute it and/or

  6.  * modify it under the terms of the GNU General Public License as

  7.  * published by the Free Software Foundation; either version 2 of

  8.  * the License, or any later version.

  9.  *

  10.  * This program is distributed in the hope that it will be useful,

  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

  13.  * GNU General Public License for more details.

  14.  *

  15.  * For a full copy of the GNU General Public License see the GPL.txt file

  16.  */

  17. 

  18. #include "CarlaEngineInternal.hpp"

  19. #include "CarlaBackendUtils.hpp"

  20. #include "CarlaMIDI.h"

  21. 

  22. #ifdef JACKBRIDGE_EXPORT

  23. # include "jackbridge/JackBridge.hpp"

  24. #else

  25. # include "jackbridge/JackBridge1.cpp"

  26. # include "jackbridge/JackBridge2.cpp"

  27. #endif

  28. 

  29. #include <cmath>

  30. #include <QtCore/QStringList>

  31. 

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

  33. 

  34. CARLA_BACKEND_START_NAMESPACE

  35. 

  36. #if 0

  37. } // Fix editor indentation

  38. #endif

  39. 

  40. // -------------------------------------------------------------------------------------------------------------------

  41. // Fallback data

  42. 

  43. static const EngineEvent kFallbackJackEngineEvent;

  44. 

  45. // -------------------------------------------------------------------------------------------------------------------

  46. // Plugin Helpers, defined in CarlaPlugin.cpp

  47. 

  48. extern CarlaEngine*          CarlaPluginGetEngine(CarlaPlugin* const plugin);

  49. extern CarlaEngineClient*    CarlaPluginGetEngineClient(CarlaPlugin* const plugin);

  50. extern CarlaEngineAudioPort* CarlaPluginGetAudioInPort(CarlaPlugin* const plugin, uint32_t index);

  51. extern CarlaEngineAudioPort* CarlaPluginGetAudioOutPort(CarlaPlugin* const plugin, uint32_t index);

  52. 

  53. // -------------------------------------------------------------------------------------------------------------------

  54. // Carla Engine JACK-Audio port

  55. 

  56. class CarlaEngineJackAudioPort : public CarlaEngineAudioPort

  57. {

  58. public:

  59.     CarlaEngineJackAudioPort(const bool isInput, const ProcessMode processMode, jack_client_t* const client, jack_port_t* const port)

  60.         : CarlaEngineAudioPort(isInput, processMode),

  61.           kClient(client),

  62.           kPort(port)

  63.     {

  64.         carla_debug("CarlaEngineJackAudioPort::CarlaEngineJackAudioPort(%s, %s, %p, %p)", bool2str(isInput), ProcessMode2Str(processMode), client, port);

  65. 

  66.         if (processMode == PROCESS_MODE_SINGLE_CLIENT || processMode == PROCESS_MODE_MULTIPLE_CLIENTS)

  67.         {

  68.             CARLA_ASSERT(client != nullptr && port != nullptr);

  69.         }

  70.         else

  71.         {

  72.             CARLA_ASSERT(client == nullptr && port == nullptr);

  73.         }

  74.     }

  75. 

  76.     ~CarlaEngineJackAudioPort() override

  77.     {

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

  79. 

  80.         if (kClient != nullptr && kPort != nullptr)

  81.             jackbridge_port_unregister(kClient, kPort);

  82.     }

  83. 

  84.     void initBuffer(CarlaEngine* const engine) override

  85.     {

  86.         CARLA_ASSERT(engine != nullptr);

  87. 

  88.         if (engine == nullptr)

  89.             return;

  90. 

  91.         if (kPort == nullptr)

  92.             return CarlaEngineAudioPort::initBuffer(engine);

  93. 

  94.         const uint32_t bufferSize(engine->getBufferSize());

  95. 

  96.         fBuffer = (float*)jackbridge_port_get_buffer(kPort, bufferSize);

  97. 

  98.         if (! kIsInput)

  99.            carla_zeroFloat(fBuffer, bufferSize);

  100.     }

  101. 

  102. private:

  103.     jack_client_t* const kClient;

  104.     jack_port_t*   const kPort;

  105. 

  106.     friend class CarlaEngineJack;

  107. 

  108.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaEngineJackAudioPort)

  109. };

  110. 

  111. // -------------------------------------------------------------------------------------------------------------------

  112. // Carla Engine JACK-CV port

  113. 

  114. class CarlaEngineJackCVPort : public CarlaEngineCVPort

  115. {

  116. public:

  117.     CarlaEngineJackCVPort(const bool isInput, const ProcessMode processMode, const uint32_t bufferSize, jack_client_t* const client, jack_port_t* const port)

  118.         : CarlaEngineCVPort(isInput, processMode, bufferSize),

  119.           kClient(client),

  120.           kPort(port)

  121.     {

  122.         carla_debug("CarlaEngineJackCVPort::CarlaEngineJackCVPort(%s, %s, %p, %p)", bool2str(isInput), ProcessMode2Str(processMode), client, port);

  123. 

  124.         if (processMode == PROCESS_MODE_SINGLE_CLIENT || processMode == PROCESS_MODE_MULTIPLE_CLIENTS)

  125.         {

  126.             CARLA_ASSERT(client != nullptr && port != nullptr);

  127.         }

  128.         else

  129.         {

  130.             CARLA_ASSERT(client == nullptr && port == nullptr);

  131.         }

  132.     }

  133. 

  134.     ~CarlaEngineJackCVPort() override

  135.     {

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

  137. 

  138.         if (kClient != nullptr && kPort != nullptr)

  139.             jackbridge_port_unregister(kClient, kPort);

  140.     }

  141. 

  142.     void initBuffer(CarlaEngine* const engine) override

  143.     {

  144.         CARLA_ASSERT(engine != nullptr);

  145. 

  146.         if (engine == nullptr)

  147.             return;

  148. 

  149.         if (kPort == nullptr)

  150.             return CarlaEngineCVPort::initBuffer(engine);

  151. 

  152.         CARLA_ASSERT(engine->getBufferSize() == fBufferSize);

  153. 

  154.         if (kIsInput)

  155.         {

  156.             float* const jackBuffer = (float*)jackbridge_port_get_buffer(kPort, fBufferSize);

  157.             carla_copyFloat(fBuffer, jackBuffer, fBufferSize);

  158.         }

  159.         else

  160.         {

  161.             carla_zeroFloat(fBuffer, fBufferSize);

  162.         }

  163.     }

  164. 

  165.     void writeBuffer(CarlaEngine* const engine) override

  166.     {

  167.         CARLA_ASSERT(! kIsInput);

  168.         CARLA_ASSERT(engine != nullptr);

  169. 

  170.         if (kIsInput)

  171.             return;

  172.         if (engine == nullptr)

  173.             return;

  174. 

  175.         CARLA_ASSERT(engine->getBufferSize() == fBufferSize);

  176. 

  177.         float* const jackBuffer = (float*)jackbridge_port_get_buffer(kPort, fBufferSize);

  178.         carla_copyFloat(jackBuffer, fBuffer, fBufferSize);

  179.     }

  180. 

  181. private:

  182.     jack_client_t* const kClient;

  183.     jack_port_t*   const kPort;

  184. 

  185.     friend class CarlaEngineJack;

  186. 

  187.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaEngineJackCVPort)

  188. };

  189. 

  190. // -------------------------------------------------------------------------------------------------------------------

  191. // Carla Engine JACK-Event port

  192. 

  193. class CarlaEngineJackEventPort : public CarlaEngineEventPort

  194. {

  195. public:

  196.     CarlaEngineJackEventPort(const bool isInput, const ProcessMode processMode, jack_client_t* const client, jack_port_t* const port)

  197.         : CarlaEngineEventPort(isInput, processMode),

  198.           kClient(client),

  199.           kPort(port),

  200.           fJackBuffer(nullptr)

  201.     {

  202.         carla_debug("CarlaEngineJackEventPort::CarlaEngineJackEventPort(%s, %s, %p, %p)", bool2str(isInput), ProcessMode2Str(processMode), client, port);

  203. 

  204.         if (processMode == PROCESS_MODE_SINGLE_CLIENT || processMode == PROCESS_MODE_MULTIPLE_CLIENTS)

  205.         {

  206.             CARLA_ASSERT(client != nullptr && port != nullptr);

  207.         }

  208.         else

  209.         {

  210.             CARLA_ASSERT(client == nullptr && port == nullptr);

  211.         }

  212.     }

  213. 

  214.     ~CarlaEngineJackEventPort() override

  215.     {

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

  217. 

  218.         if (kClient != nullptr && kPort != nullptr)

  219.             jackbridge_port_unregister(kClient, kPort);

  220.     }

  221. 

  222.     void initBuffer(CarlaEngine* const engine) override

  223.     {

  224.         CARLA_ASSERT(engine != nullptr);

  225. 

  226.         if (engine == nullptr)

  227.             return;

  228. 

  229.         if (kPort == nullptr)

  230.             return CarlaEngineEventPort::initBuffer(engine);

  231. 

  232.         fJackBuffer = jackbridge_port_get_buffer(kPort, engine->getBufferSize());

  233. 

  234.         if (! kIsInput)

  235.             jackbridge_midi_clear_buffer(fJackBuffer);

  236.     }

  237. 

  238.     uint32_t getEventCount() const override

  239.     {

  240.         if (kPort == nullptr)

  241.             return CarlaEngineEventPort::getEventCount();

  242. 

  243.         CARLA_ASSERT(kIsInput);

  244.         CARLA_ASSERT(fJackBuffer != nullptr);

  245. 

  246.         if (! kIsInput)

  247.             return 0;

  248.         if (fJackBuffer == nullptr)

  249.             return 0;

  250. 

  251.         return jackbridge_midi_get_event_count(fJackBuffer);

  252.     }

  253. 

  254.     const EngineEvent& getEvent(const uint32_t index) override

  255.     {

  256.         if (kPort == nullptr)

  257.             return CarlaEngineEventPort::getEvent(index);

  258. 

  259.         CARLA_ASSERT(kIsInput);

  260.         CARLA_ASSERT(fJackBuffer != nullptr);

  261. 

  262.         if (! kIsInput)

  263.             return kFallbackJackEngineEvent;

  264.         if (fJackBuffer == nullptr)

  265.             return kFallbackJackEngineEvent;

  266. 

  267.         jack_midi_event_t jackEvent;

  268.         carla_zeroStruct<jack_midi_event_t>(jackEvent);

  269. 

  270.         if (! jackbridge_midi_event_get(&jackEvent, fJackBuffer, index))

  271.             return kFallbackJackEngineEvent;

  272.         if (jackEvent.size == 0 || jackEvent.size > 4)

  273.             return kFallbackJackEngineEvent;

  274. 

  275.         fRetEvent.clear();

  276. 

  277.         const uint8_t midiStatus  = MIDI_GET_STATUS_FROM_DATA(jackEvent.buffer);

  278.         const uint8_t midiChannel = MIDI_GET_CHANNEL_FROM_DATA(jackEvent.buffer);

  279. 

  280.         fRetEvent.time    = jackEvent.time;

  281.         fRetEvent.channel = midiChannel;

  282. 

  283.         if (MIDI_IS_STATUS_CONTROL_CHANGE(midiStatus))

  284.         {

  285.             CARLA_ASSERT(jackEvent.size == 2 || jackEvent.size == 3);

  286. 

  287.             const uint8_t midiControl = jackEvent.buffer[1];

  288.             fRetEvent.type            = kEngineEventTypeControl;

  289. 

  290.             if (MIDI_IS_CONTROL_BANK_SELECT(midiControl))

  291.             {

  292.                 const uint8_t midiBank = jackEvent.buffer[2];

  293. 

  294.                 fRetEvent.ctrl.type  = kEngineControlEventTypeMidiBank;

  295.                 fRetEvent.ctrl.param = midiBank;

  296.                 fRetEvent.ctrl.value = 0.0f;

  297.             }

  298.             else if (midiControl == MIDI_CONTROL_ALL_SOUND_OFF)

  299.             {

  300.                 fRetEvent.ctrl.type  = kEngineControlEventTypeAllSoundOff;

  301.                 fRetEvent.ctrl.param = 0;

  302.                 fRetEvent.ctrl.value = 0.0f;

  303.             }

  304.             else if (midiControl == MIDI_CONTROL_ALL_NOTES_OFF)

  305.             {

  306.                 fRetEvent.ctrl.type  = kEngineControlEventTypeAllNotesOff;

  307.                 fRetEvent.ctrl.param = 0;

  308.                 fRetEvent.ctrl.value = 0.0f;

  309.             }

  310.             else

  311.             {

  312.                 CARLA_ASSERT(jackEvent.size == 3);

  313. 

  314.                 const uint8_t midiValue = jackEvent.buffer[2];

  315. 

  316.                 fRetEvent.ctrl.type  = kEngineControlEventTypeParameter;

  317.                 fRetEvent.ctrl.param = midiControl;

  318.                 fRetEvent.ctrl.value = float(midiValue)/127.0f;

  319.             }

  320.         }

  321.         else if (MIDI_IS_STATUS_PROGRAM_CHANGE(midiStatus))

  322.         {

  323.             CARLA_ASSERT(jackEvent.size == 2);

  324. 

  325.             const uint8_t midiProgram = jackEvent.buffer[1];

  326.             fRetEvent.type            = kEngineEventTypeControl;

  327. 

  328.             fRetEvent.ctrl.type  = kEngineControlEventTypeMidiProgram;

  329.             fRetEvent.ctrl.param = midiProgram;

  330.             fRetEvent.ctrl.value = 0.0f;

  331.         }

  332.         else

  333.         {

  334.             fRetEvent.type = kEngineEventTypeMidi;

  335.             fRetEvent.midi.data[0] = midiStatus;

  336.             fRetEvent.midi.size    = static_cast<uint8_t>(jackEvent.size);

  337. 

  338.             if (jackEvent.size > 1)

  339.                 carla_copy<uint8_t>(fRetEvent.midi.data+1, jackEvent.buffer+1, jackEvent.size-1);

  340.         }

  341. 

  342.         return fRetEvent;

  343.     }

  344. 

  345.     void writeControlEvent(const uint32_t time, const uint8_t channel, const EngineControlEventType type, const uint16_t param, const float value) override

  346.     {

  347.         if (kPort == nullptr)

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

  349. 

  350.         CARLA_ASSERT(! kIsInput);

  351.         CARLA_ASSERT(fJackBuffer != nullptr);

  352.         CARLA_ASSERT(type != kEngineControlEventTypeNull);

  353.         CARLA_ASSERT(channel < MAX_MIDI_CHANNELS);

  354.         CARLA_ASSERT(param < MAX_MIDI_VALUE);

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

  356. 

  357.         if (kIsInput)

  358.             return;

  359.         if (fJackBuffer == nullptr)

  360.             return;

  361.         if (type == kEngineControlEventTypeNull)

  362.             return;

  363.         if (channel >= MAX_MIDI_CHANNELS)

  364.             return;

  365.         if (param >= MAX_MIDI_VALUE)

  366.             return;

  367.         if (type == kEngineControlEventTypeParameter)

  368.         {

  369.             CARLA_ASSERT(! MIDI_IS_CONTROL_BANK_SELECT(param));

  370.         }

  371. 

  372.         const float fixedValue(carla_fixValue<float>(0.0f, 1.0f, value));

  373. 

  374.         size_t size = 0;

  375.         jack_midi_data_t data[4] = { 0 };

  376. 

  377.         switch (type)

  378.         {

  379.         case kEngineControlEventTypeNull:

  380.             break;

  381.         case kEngineControlEventTypeParameter:

  382.             data[0] = MIDI_STATUS_CONTROL_CHANGE + channel;

  383.             data[1] = param;

  384.             data[2] = fixedValue * 127.0f;

  385.             size    = 3;

  386.             break;

  387.         case kEngineControlEventTypeMidiBank:

  388.             data[0] = MIDI_STATUS_CONTROL_CHANGE + channel;

  389.             data[1] = MIDI_CONTROL_BANK_SELECT;

  390.             data[2] = param;

  391.             size    = 3;

  392.             break;

  393.         case kEngineControlEventTypeMidiProgram:

  394.             data[0] = MIDI_STATUS_PROGRAM_CHANGE + channel;

  395.             data[1] = param;

  396.             size    = 2;

  397.             break;

  398.         case kEngineControlEventTypeAllSoundOff:

  399.             data[0] = MIDI_STATUS_CONTROL_CHANGE + channel;

  400.             data[1] = MIDI_CONTROL_ALL_SOUND_OFF;

  401.             data[2] = 0;

  402.             size    = 3;

  403.             break;

  404.         case kEngineControlEventTypeAllNotesOff:

  405.             data[0] = MIDI_STATUS_CONTROL_CHANGE + channel;

  406.             data[1] = MIDI_CONTROL_ALL_NOTES_OFF;

  407.             data[2] = 0;

  408.             size    = 3;

  409.             break;

  410.         }

  411. 

  412.         if (size > 0)

  413.             jackbridge_midi_event_write(fJackBuffer, time, data, size);

  414.     }

  415. 

  416.     void writeMidiEvent(const uint32_t time, const uint8_t channel, const uint8_t port, const uint8_t* const data, const uint8_t size) override

  417.     {

  418.         if (kPort == nullptr)

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

  420. 

  421.         CARLA_ASSERT(! kIsInput);

  422.         CARLA_ASSERT(fJackBuffer != nullptr);

  423.         CARLA_ASSERT(channel < MAX_MIDI_CHANNELS);

  424.         CARLA_ASSERT(data != nullptr);

  425.         CARLA_ASSERT(size != 0);

  426. 

  427.         if (kIsInput)

  428.             return;

  429.         if (fJackBuffer == nullptr)

  430.             return;

  431.         if (channel >= MAX_MIDI_CHANNELS)

  432.             return;

  433.         if (data == nullptr)

  434.             return;

  435.         if (size == 0)

  436.             return;

  437. 

  438.         uint8_t jdata[size];

  439.         carla_copy<uint8_t>(jdata, data, size);

  440. 

  441.         jdata[0] = MIDI_GET_STATUS_FROM_DATA(data) + channel;

  442. 

  443.         jackbridge_midi_event_write(fJackBuffer, time, jdata, size);

  444.     }

  445. 

  446. private:

  447.     jack_client_t* const kClient;

  448.     jack_port_t*   const kPort;

  449. 

  450.     void*       fJackBuffer;

  451.     EngineEvent fRetEvent;

  452. 

  453.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaEngineJackEventPort)

  454. };

  455. 

  456. // -------------------------------------------------------------------------------------------------------------------

  457. // Jack Engine client

  458. 

  459. class CarlaEngineJackClient : public CarlaEngineClient

  460. {

  461. public:

  462.     CarlaEngineJackClient(const CarlaEngine& engine, jack_client_t* const client)

  463.         : CarlaEngineClient(engine),

  464.           kClient(client),

  465.           kUseClient(engine.getProccessMode() == PROCESS_MODE_SINGLE_CLIENT || engine.getProccessMode() == PROCESS_MODE_MULTIPLE_CLIENTS)

  466.     {

  467.         carla_debug("CarlaEngineJackClient::CarlaEngineJackClient(name:\"%s\", %p)", engine.getName(), client);

  468. 

  469.         if (kUseClient)

  470.         {

  471.             CARLA_ASSERT(kClient != nullptr);

  472.         }

  473.         else

  474.         {

  475.             CARLA_ASSERT(kClient == nullptr);

  476.         }

  477.     }

  478. 

  479.     ~CarlaEngineJackClient() override

  480.     {

  481.         carla_debug("CarlaEngineClient::~CarlaEngineClient()");

  482. 

  483.         if (kEngine.getProccessMode() == PROCESS_MODE_MULTIPLE_CLIENTS && kClient != nullptr)

  484.             jackbridge_client_close(kClient);

  485.     }

  486. 

  487.     void activate() override

  488.     {

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

  490. 

  491.         if (kEngine.getProccessMode() == PROCESS_MODE_MULTIPLE_CLIENTS)

  492.         {

  493.             CARLA_ASSERT(kClient != nullptr && ! fActive);

  494. 

  495.             if (kClient != nullptr && ! fActive)

  496.                 jackbridge_activate(kClient);

  497.         }

  498. 

  499.         CarlaEngineClient::activate();

  500.     }

  501. 

  502.     void deactivate() override

  503.     {

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

  505. 

  506.         if (kEngine.getProccessMode() == PROCESS_MODE_MULTIPLE_CLIENTS)

  507.         {

  508.             CARLA_ASSERT(kClient != nullptr && fActive);

  509. 

  510.             if (kClient != nullptr && fActive)

  511.                 jackbridge_deactivate(kClient);

  512.         }

  513. 

  514.         CarlaEngineClient::deactivate();

  515.     }

  516. 

  517.     bool isOk() const override

  518.     {

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

  520. 

  521.         if (kUseClient)

  522.             return (kClient != nullptr);

  523. 

  524.         return CarlaEngineClient::isOk();

  525.     }

  526. 

  527. #if 0

  528.     void setLatency(const uint32_t samples) override

  529.     {

  530.         CarlaEngineClient::setLatency(samples);

  531. 

  532.         if (kUseClient)

  533.             jackbridge_recompute_total_latencies(kClient);

  534.     }

  535. #endif

  536. 

  537.     CarlaEnginePort* addPort(const EnginePortType portType, const char* const name, const bool isInput) override

  538.     {

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

  540. 

  541.         jack_port_t* port = nullptr;

  542. 

  543.         // Create JACK port first, if needed

  544.         if (kUseClient)

  545.         {

  546.             switch (portType)

  547.             {

  548.             case kEnginePortTypeNull:

  549.                 break;

  550.             case kEnginePortTypeAudio:

  551.                 port = jackbridge_port_register(kClient, name, JACK_DEFAULT_AUDIO_TYPE, isInput ? JackPortIsInput : JackPortIsOutput, 0);

  552.                 break;

  553.             case kEnginePortTypeCV:

  554.                 port = jackbridge_port_register(kClient, name, JACK_DEFAULT_AUDIO_TYPE, JackPortIsControlVoltage | (isInput ? JackPortIsInput : JackPortIsOutput), 0);

  555.                 break;

  556.             case kEnginePortTypeEvent:

  557.                 port = jackbridge_port_register(kClient, name, JACK_DEFAULT_MIDI_TYPE, isInput ? JackPortIsInput : JackPortIsOutput, 0);

  558.                 break;

  559.             }

  560.         }

  561. 

  562.         // Create Engine port

  563.         switch (portType)

  564.         {

  565.         case kEnginePortTypeNull:

  566.             break;

  567.         case kEnginePortTypeAudio:

  568.             return new CarlaEngineJackAudioPort(isInput, kEngine.getProccessMode(), kClient, port);

  569.         case kEnginePortTypeCV:

  570.             return new CarlaEngineJackCVPort(isInput, kEngine.getProccessMode(), kEngine.getBufferSize(), kClient, port);

  571.         case kEnginePortTypeEvent:

  572.             return new CarlaEngineJackEventPort(isInput, kEngine.getProccessMode(), kClient, port);

  573.         }

  574. 

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

  576.         return nullptr;

  577.     }

  578. 

  579. private:

  580.     jack_client_t* const kClient;

  581.     const bool           kUseClient;

  582. 

  583.     friend class CarlaEngineJack;

  584.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaEngineJackClient)

  585. };

  586. 

  587. // -------------------------------------------------------------------------------------------------------------------

  588. // Jack Engine

  589. 

  590. class CarlaEngineJack : public CarlaEngine

  591. {

  592. public:

  593.     CarlaEngineJack()

  594.         : CarlaEngine(),

  595.           fClient(nullptr),

  596.           fTransportState(JackTransportStopped),

  597.           fFreewheel(false),

  598. #ifdef BUILD_BRIDGE

  599.           fHasQuit(false)

  600. #else

  601. # ifdef CARLA_PROPER_CPP11_SUPPORT

  602.           fRackPorts{nullptr},

  603. # endif

  604.           fLastGroupId(0),

  605.           fLastPortId(0),

  606.           fLastConnectionId(0)

  607. #endif

  608.     {

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

  610. 

  611. #ifdef BUILD_BRIDGE

  612.         fOptions.processMode = PROCESS_MODE_MULTIPLE_CLIENTS;

  613. #else

  614. # ifndef CARLA_PROPER_CPP11_SUPPORT

  615.         carla_fill<jack_port_t*>(fRackPorts, kRackPortCount, nullptr);

  616. # endif

  617. #endif

  618. 

  619.         // FIXME: Always enable JACK transport for now

  620.         fOptions.transportMode = TRANSPORT_MODE_JACK;

  621. 

  622.         carla_zeroStruct<jack_position_t>(fTransportPos);

  623.     }

  624. 

  625.     ~CarlaEngineJack() override

  626.     {

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

  628.         CARLA_ASSERT(fClient == nullptr);

  629. 

  630. #ifndef BUILD_BRIDGE

  631.         fUsedGroupNames.clear();

  632.         fUsedPortNames.clear();

  633.         fUsedConnections.clear();

  634.         fGroupIconsChanged.clear();

  635. #endif

  636.     }

  637. 

  638.     // -------------------------------------------------------------------

  639.     // Maximum values

  640. 

  641.     unsigned int maxClientNameSize() const override

  642.     {

  643.         if (fOptions.processMode == PROCESS_MODE_SINGLE_CLIENT || fOptions.processMode == PROCESS_MODE_MULTIPLE_CLIENTS)

  644.             return static_cast<unsigned int>(jackbridge_client_name_size());

  645. 

  646.         return CarlaEngine::maxClientNameSize();

  647.     }

  648. 

  649.     unsigned int maxPortNameSize() const override

  650.     {

  651.         if (fOptions.processMode == PROCESS_MODE_SINGLE_CLIENT || fOptions.processMode == PROCESS_MODE_MULTIPLE_CLIENTS)

  652.             return static_cast<unsigned int>(jackbridge_port_name_size());

  653. 

  654.         return CarlaEngine::maxPortNameSize();

  655.     }

  656. 

  657.     // -------------------------------------------------------------------

  658.     // Virtual, per-engine type calls

  659. 

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

  661.     {

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

  663. 

  664.         fFreewheel      = false;

  665.         fTransportState = JackTransportStopped;

  666. 

  667.         carla_zeroStruct<jack_position_t>(fTransportPos);

  668. 

  669. #ifndef BUILD_BRIDGE

  670.         fLastGroupId = 0;

  671.         fLastPortId  = 0;

  672.         fLastConnectionId = 0;

  673. 

  674.         fUsedGroupNames.clear();

  675.         fUsedPortNames.clear();

  676.         fUsedConnections.clear();

  677.         fGroupIconsChanged.clear();

  678. 

  679.         fClient = jackbridge_client_open(clientName, JackNullOption, nullptr);

  680. 

  681.         if (fClient != nullptr)

  682.         {

  683.             fBufferSize = jackbridge_get_buffer_size(fClient);

  684.             fSampleRate = jackbridge_get_sample_rate(fClient);

  685. 

  686.             jackbridge_custom_publish_data(fClient, URI_CANVAS_ICON, "carla", 6);

  687.             jackbridge_custom_set_data_appearance_callback(fClient, carla_jack_custom_appearance_callback, this);

  688. 

  689.             jackbridge_set_buffer_size_callback(fClient, carla_jack_bufsize_callback, this);

  690.             jackbridge_set_sample_rate_callback(fClient, carla_jack_srate_callback, this);

  691.             jackbridge_set_freewheel_callback(fClient, carla_jack_freewheel_callback, this);

  692.             jackbridge_set_latency_callback(fClient, carla_jack_latency_callback, this);

  693.             jackbridge_set_process_callback(fClient, carla_jack_process_callback, this);

  694.             jackbridge_on_shutdown(fClient, carla_jack_shutdown_callback, this);

  695. 

  696.             const char* const jackClientName(jackbridge_get_client_name(fClient));

  697. 

  698.             initJackPatchbay(jackClientName);

  699. 

  700.             jackbridge_set_client_registration_callback(fClient, carla_jack_client_registration_callback, this);

  701.             jackbridge_set_port_registration_callback(fClient, carla_jack_port_registration_callback, this);

  702.             jackbridge_set_port_connect_callback(fClient, carla_jack_port_connect_callback, this);

  703.             jackbridge_set_port_rename_callback(fClient, carla_jack_port_rename_callback, this);

  704. 

  705.             if (fOptions.processMode == PROCESS_MODE_CONTINUOUS_RACK)

  706.             {

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

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

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

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

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

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

  713.             }

  714. 

  715.             if (jackbridge_activate(fClient))

  716.             {

  717.                 CarlaEngine::init(jackClientName);

  718.                 return true;

  719.             }

  720.             else

  721.             {

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

  723.                 jackbridge_client_close(fClient);

  724.                 fClient = nullptr;

  725.             }

  726.         }

  727.         else

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

  729. 

  730.         return false;

  731. #else

  732.         if (fBufferSize == 0 || fSampleRate == 0.0)

  733.         {

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

  735.             if (jack_client_t* tmpClient = jackbridge_client_open(clientName, JackNullOption, nullptr))

  736.             {

  737.                 fBufferSize = jackbridge_get_buffer_size(tmpClient);

  738.                 fSampleRate = jackbridge_get_sample_rate(tmpClient);

  739. 

  740.                 jackbridge_client_close(tmpClient);

  741.             }

  742.         }

  743. 

  744.         return CarlaEngine::init(clientName);

  745. #endif

  746.     }

  747. 

  748.     bool close() override

  749.     {

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

  751.         CarlaEngine::close();

  752. 

  753. #ifdef BUILD_BRIDGE

  754.         fClient  = nullptr;

  755.         fHasQuit = true;

  756.         return true;

  757. #else

  758.         if (jackbridge_deactivate(fClient))

  759.         {

  760.             if (fOptions.processMode == PROCESS_MODE_CONTINUOUS_RACK)

  761.             {

  762.                 jackbridge_port_unregister(fClient, fRackPorts[kRackPortAudioIn1]);

  763.                 jackbridge_port_unregister(fClient, fRackPorts[kRackPortAudioIn2]);

  764.                 jackbridge_port_unregister(fClient, fRackPorts[kRackPortAudioOut1]);

  765.                 jackbridge_port_unregister(fClient, fRackPorts[kRackPortAudioOut2]);

  766.                 jackbridge_port_unregister(fClient, fRackPorts[kRackPortEventIn]);

  767.                 jackbridge_port_unregister(fClient, fRackPorts[kRackPortEventOut]);

  768.             }

  769. 

  770.             if (jackbridge_client_close(fClient))

  771.             {

  772.                 fClient = nullptr;

  773.                 return true;

  774.             }

  775.             else

  776.                 setLastError("Failed to close the JACK client");

  777.         }

  778.         else

  779.             setLastError("Failed to deactivate the JACK client");

  780. 

  781.         fClient = nullptr;

  782. 

  783.         fUsedGroupNames.clear();

  784.         fUsedPortNames.clear();

  785.         fUsedConnections.clear();

  786.         fGroupIconsChanged.clear();

  787. #endif

  788.         return false;

  789.     }

  790. 

  791. #ifndef BUILD_BRIDGE

  792.     void idle() override

  793.     {

  794.         CarlaEngine::idle();

  795. 

  796.         if (fGroupIconsChanged.count() == 0)

  797.             return;

  798. 

  799.         static bool checkIcons = false;

  800. 

  801.         if (! checkIcons)

  802.         {

  803.             checkIcons = true; // check them next time

  804.             return;

  805.         }

  806. 

  807.         checkIcons = false;

  808. 

  809.         void*  data;

  810.         size_t dataSize;

  811. 

  812.         QList<int> groupIconsCopy(fGroupIconsChanged);

  813.         fGroupIconsChanged.clear();

  814. 

  815.         foreach (const int& groupId, groupIconsCopy)

  816.         {

  817.             const char* const groupName(getGroupName(groupId));

  818. 

  819.             data = nullptr;

  820.             dataSize = 0;

  821. 

  822.             if (jackbridge_custom_get_data(fClient, groupName, URI_CANVAS_ICON, &data, &dataSize) && data != nullptr && dataSize != 0)

  823.             {

  824.                 const char* const icon((const char*)data);

  825.                 CARLA_ASSERT(std::strlen(icon)+1 == dataSize);

  826. 

  827.                 PatchbayIconType groupIcon;

  828. 

  829.                 if (std::strcmp(icon, "app") == 0 || std::strcmp(icon, "application") == 0)

  830.                     groupIcon = PATCHBAY_ICON_APPLICATION;

  831.                 else if (std::strcmp(icon, "hardware") == 0)

  832.                     groupIcon = PATCHBAY_ICON_HARDWARE;

  833.                 else if (std::strcmp(icon, "carla") == 0)

  834.                     groupIcon = PATCHBAY_ICON_CARLA;

  835.                 else if (std::strcmp(icon, "distrho") == 0)

  836.                     groupIcon = PATCHBAY_ICON_DISTRHO;

  837.                 else if (std::strcmp(icon, "file") == 0)

  838.                     groupIcon = PATCHBAY_ICON_FILE;

  839.                 else if (std::strcmp(icon, "plugin") == 0)

  840.                     groupIcon = PATCHBAY_ICON_PLUGIN;

  841.                 else

  842.                     groupIcon = PATCHBAY_ICON_APPLICATION;

  843. 

  844.                 callback(CALLBACK_PATCHBAY_ICON_CHANGED, 0, groupId, groupIcon, 0.0f, nullptr);

  845.             }

  846.         }

  847.     }

  848. #endif

  849. 

  850.     bool isRunning() const override

  851.     {

  852. #ifdef BUILD_BRIDGE

  853.         return (fClient != nullptr || ! fHasQuit);

  854. #else

  855.         return (fClient != nullptr);

  856. #endif

  857.     }

  858. 

  859.     bool isOffline() const override

  860.     {

  861.         return fFreewheel;

  862.     }

  863. 

  864.     EngineType type() const override

  865.     {

  866.         return kEngineTypeJack;

  867.     }

  868. 

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

  870.     {

  871.         const char* const iconName(plugin->iconName());

  872.         jack_client_t* client = nullptr;

  873. 

  874. #ifdef BUILD_BRIDGE

  875.         client = fClient = jackbridge_client_open(plugin->name(), JackNullOption, nullptr);

  876. 

  877.         fBufferSize = jackbridge_get_buffer_size(client);

  878.         fSampleRate = jackbridge_get_sample_rate(client);

  879. 

  880.         jackbridge_custom_publish_data(client, URI_CANVAS_ICON, iconName, std::strlen(iconName)+1);

  881. 

  882.         jackbridge_set_buffer_size_callback(client, carla_jack_bufsize_callback, this);

  883.         jackbridge_set_sample_rate_callback(client, carla_jack_srate_callback, this);

  884.         jackbridge_set_freewheel_callback(client, carla_jack_freewheel_callback, this);

  885.         jackbridge_set_latency_callback(client, carla_jack_latency_callback, this);

  886.         jackbridge_set_process_callback(client, carla_jack_process_callback, this);

  887.         jackbridge_on_shutdown(client, carla_jack_shutdown_callback, this);

  888. #else

  889.         if (fOptions.processMode == PROCESS_MODE_SINGLE_CLIENT)

  890.         {

  891.             client = fClient;

  892.         }

  893.         else if (fOptions.processMode == PROCESS_MODE_MULTIPLE_CLIENTS)

  894.         {

  895.             client = jackbridge_client_open(plugin->name(), JackNullOption, nullptr);

  896. 

  897.             CARLA_ASSERT(client != nullptr);

  898. 

  899.             if (client == nullptr)

  900.                 return nullptr;

  901. 

  902.             jackbridge_custom_publish_data(client, URI_CANVAS_ICON, iconName, std::strlen(iconName)+1);

  903. 

  904.             jackbridge_set_latency_callback(client, carla_jack_latency_callback_plugin, plugin);

  905.             jackbridge_set_process_callback(client, carla_jack_process_callback_plugin, plugin);

  906.         }

  907. #endif

  908. 

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

  910.     }

  911. 

  912. #ifndef BUILD_BRIDGE

  913.     const char* renamePlugin(const unsigned int id, const char* const newName) override

  914.     {

  915.         CARLA_ASSERT(kData->curPluginCount > 0);

  916.         CARLA_ASSERT(id < kData->curPluginCount);

  917.         CARLA_ASSERT(kData->plugins != nullptr);

  918.         CARLA_ASSERT(newName != nullptr);

  919. 

  920.         if (kData->plugins == nullptr)

  921.         {

  922.             setLastError("Critical error: no plugins are currently loaded!");

  923.             return nullptr;

  924.         }

  925. 

  926.         CarlaPlugin* const plugin(kData->plugins[id].plugin);

  927. 

  928.         if (plugin == nullptr)

  929.         {

  930.             carla_stderr("CarlaEngine::clonePlugin(%i) - could not find plugin", id);

  931.             return nullptr;

  932.         }

  933. 

  934.         CARLA_ASSERT(plugin->id() == id);

  935. 

  936.         bool needsReinit = (fOptions.processMode == PROCESS_MODE_SINGLE_CLIENT);

  937.         const char* name = getUniquePluginName(newName);

  938. 

  939.         // TODO - use rename port if single-client

  940. 

  941.         // JACK client rename

  942.         if (fOptions.processMode == PROCESS_MODE_MULTIPLE_CLIENTS)

  943.         {

  944.             CarlaEngineJackClient* const client((CarlaEngineJackClient*)CarlaPluginGetEngineClient(plugin));

  945. 

  946.             if (bridge.client_rename_ptr != nullptr)

  947.             {

  948.                 name = bridge.client_rename_ptr(client->kClient, name);

  949.             }

  950.             else

  951.             {

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

  953.                 needsReinit = true;

  954. 

  955.                 if (jack_client_t* jclient = jackbridge_client_open(name, JackNullOption, nullptr))

  956.                 {

  957.                     const char* const iconName(plugin->iconName());

  958.                     jackbridge_custom_publish_data(jclient, URI_CANVAS_ICON, iconName, std::strlen(iconName)+1);

  959. 

  960.                     // close old client

  961.                     plugin->setEnabled(false);

  962. 

  963.                     if (client->isActive())

  964.                         client->deactivate();

  965. 

  966.                     plugin->clearBuffers();

  967. 

  968.                     jackbridge_client_close(client->kClient);

  969. 

  970.                     // set new client data

  971.                     name = jackbridge_get_client_name(jclient);

  972. 

  973.                     jackbridge_set_process_callback(jclient, carla_jack_process_callback_plugin, plugin);

  974.                     jackbridge_set_latency_callback(jclient, carla_jack_latency_callback_plugin, plugin);

  975. 

  976.                     // this is supposed to be constant...

  977.                     std::memcpy((jack_client_t**)&client->kClient, &jclient, sizeof(jack_client_t**));

  978.                 }

  979.             }

  980.         }

  981. 

  982.         if (name == nullptr)

  983.             return nullptr;

  984. 

  985.         // Rename

  986.         plugin->setName(name);

  987. 

  988.         if (needsReinit)

  989.         {

  990.             // reload plugin to recreate its ports

  991.             const SaveState& saveState(plugin->getSaveState());

  992.             plugin->reload();

  993.             plugin->loadSaveState(saveState);

  994.         }

  995. 

  996.         return name;

  997.     }

  998. 

  999.     // -------------------------------------------------------------------

  1000.     // Patchbay

  1001. 

  1002.     bool patchbayConnect(int portA, int portB) override

  1003.     {

  1004.         CARLA_ASSERT(fClient != nullptr);

  1005. 

  1006.         if (fClient == nullptr)

  1007.         {

  1008.             setLastError("Invalid JACK client");

  1009.             return false;

  1010.         }

  1011. 

  1012.         char portNameA[STR_MAX+1];

  1013.         char portNameB[STR_MAX+1];

  1014.         getFullPortName(portA, portNameA);

  1015.         getFullPortName(portB, portNameB);

  1016. 

  1017.         if (! jackbridge_connect(fClient, portNameA, portNameB))

  1018.         {

  1019.             setLastError("JACK operation failed");

  1020.             return false;

  1021.         }

  1022. 

  1023.         return true;

  1024.     }

  1025. 

  1026.     bool patchbayDisconnect(int connectionId) override

  1027.     {

  1028.         CARLA_ASSERT(fClient != nullptr);

  1029. 

  1030.         if (fClient == nullptr)

  1031.         {

  1032.             setLastError("Invalid JACK client");

  1033.             return false;

  1034.         }

  1035. 

  1036.         foreach (const ConnectionToId& connectionToId, fUsedConnections)

  1037.         {

  1038.             if (connectionToId.id == connectionId)

  1039.             {

  1040.                 char portNameOut[STR_MAX+1];

  1041.                 char portNameIn[STR_MAX+1];

  1042. 

  1043.                 getFullPortName(connectionToId.portOut, portNameOut);

  1044.                 getFullPortName(connectionToId.portIn, portNameIn);

  1045. 

  1046.                 if (! jackbridge_disconnect(fClient, portNameOut, portNameIn))

  1047.                 {

  1048.                     setLastError("JACK operation failed");

  1049.                     return false;

  1050.                 }

  1051. 

  1052.                 return true;

  1053.             }

  1054.         }

  1055. 

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

  1057.         return false;

  1058.     }

  1059. 

  1060.     void patchbayRefresh() override

  1061.     {

  1062.         CARLA_ASSERT(fClient != nullptr);

  1063. 

  1064.         if (fClient == nullptr)

  1065.             return;

  1066. 

  1067.         fLastGroupId = 0;

  1068.         fLastPortId  = 0;

  1069.         fLastConnectionId = 0;

  1070. 

  1071.         fUsedGroupNames.clear();

  1072.         fUsedPortNames.clear();

  1073.         fUsedConnections.clear();

  1074.         fGroupIconsChanged.clear();

  1075. 

  1076.         initJackPatchbay(jackbridge_get_client_name(fClient));

  1077.     }

  1078. #endif

  1079. 

  1080.     // -------------------------------------------------------------------

  1081.     // Transport

  1082. 

  1083.     void transportPlay() override

  1084.     {

  1085.         if (fOptions.transportMode == TRANSPORT_MODE_INTERNAL)

  1086.             CarlaEngine::transportPlay();

  1087.         else if (fClient != nullptr)

  1088.             jackbridge_transport_start(fClient);

  1089.     }

  1090. 

  1091.     void transportPause() override

  1092.     {

  1093.         if (fOptions.transportMode == TRANSPORT_MODE_INTERNAL)

  1094.             CarlaEngine::transportPause();

  1095.         else if (fClient != nullptr)

  1096.             jackbridge_transport_stop(fClient);

  1097.     }

  1098. 

  1099.     void transportRelocate(const uint32_t frame) override

  1100.     {

  1101.         if (fOptions.transportMode == TRANSPORT_MODE_INTERNAL)

  1102.             CarlaEngine::transportRelocate(frame);

  1103.         else if (fClient != nullptr)

  1104.             jackbridge_transport_locate(fClient, frame);

  1105.     }

  1106. 

  1107.     // -------------------------------------

  1108. 

  1109. protected:

  1110.     void handleJackBufferSizeCallback(const uint32_t newBufferSize)

  1111.     {

  1112.         if (fBufferSize == newBufferSize)

  1113.             return;

  1114. 

  1115.         fBufferSize = newBufferSize;

  1116.         bufferSizeChanged(newBufferSize);

  1117.     }

  1118. 

  1119.     void handleJackSampleRateCallback(const double newSampleRate)

  1120.     {

  1121.         if (fSampleRate == newSampleRate)

  1122.             return;

  1123. 

  1124.         fSampleRate = newSampleRate;

  1125.         sampleRateChanged(newSampleRate);

  1126.     }

  1127. 

  1128.     void handleJackFreewheelCallback(const bool isFreewheel)

  1129.     {

  1130.         if (fFreewheel == isFreewheel)

  1131.             return;

  1132. 

  1133.         fFreewheel = isFreewheel;

  1134.         offlineModeChanged(isFreewheel);

  1135.     }

  1136. 

  1137.     void saveTransportInfo()

  1138.     {

  1139.         if (fOptions.transportMode != TRANSPORT_MODE_JACK)

  1140.             return;

  1141. 

  1142.         fTransportPos.unique_1 = fTransportPos.unique_2 + 1; // invalidate

  1143. 

  1144.         fTransportState = jackbridge_transport_query(fClient, &fTransportPos);

  1145. 

  1146.         fTimeInfo.playing = (fTransportState == JackTransportRolling);

  1147. 

  1148.         if (fTransportPos.unique_1 == fTransportPos.unique_2)

  1149.         {

  1150.             fTimeInfo.frame = fTransportPos.frame;

  1151.             fTimeInfo.usecs = fTransportPos.usecs;

  1152. 

  1153.             if (fTransportPos.valid & JackPositionBBT)

  1154.             {

  1155.                 fTimeInfo.valid              = EngineTimeInfo::ValidBBT;

  1156.                 fTimeInfo.bbt.bar            = fTransportPos.bar;

  1157.                 fTimeInfo.bbt.beat           = fTransportPos.beat;

  1158.                 fTimeInfo.bbt.tick           = fTransportPos.tick;

  1159.                 fTimeInfo.bbt.barStartTick   = fTransportPos.bar_start_tick;

  1160.                 fTimeInfo.bbt.beatsPerBar    = fTransportPos.beats_per_bar;

  1161.                 fTimeInfo.bbt.beatType       = fTransportPos.beat_type;

  1162.                 fTimeInfo.bbt.ticksPerBeat   = fTransportPos.ticks_per_beat;

  1163.                 fTimeInfo.bbt.beatsPerMinute = fTransportPos.beats_per_minute;

  1164.             }

  1165.             else

  1166.                 fTimeInfo.valid = 0x0;

  1167.         }

  1168.         else

  1169.         {

  1170.             fTimeInfo.frame = 0;

  1171.             fTimeInfo.valid = 0x0;

  1172.         }

  1173.     }

  1174. 

  1175.     void handleJackProcessCallback(const uint32_t nframes)

  1176.     {

  1177.         saveTransportInfo();

  1178. 

  1179.         if (kData->curPluginCount == 0)

  1180.         {

  1181. #ifndef BUILD_BRIDGE

  1182.             // pass-through

  1183.             if (fOptions.processMode == PROCESS_MODE_CONTINUOUS_RACK)

  1184.             {

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

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

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

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

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

  1190. 

  1191.                 CARLA_ASSERT(audioIn1 != nullptr);

  1192.                 CARLA_ASSERT(audioIn2 != nullptr);

  1193.                 CARLA_ASSERT(audioOut1 != nullptr);

  1194.                 CARLA_ASSERT(audioOut2 != nullptr);

  1195.                 CARLA_ASSERT(eventOut != nullptr);

  1196. 

  1197.                 carla_copyFloat(audioOut1, audioIn1, nframes);

  1198.                 carla_copyFloat(audioOut2, audioIn2, nframes);

  1199.                 jackbridge_midi_clear_buffer(eventOut);

  1200.             }

  1201. #endif

  1202. 

  1203.             return proccessPendingEvents();

  1204.         }

  1205. 

  1206. #ifdef BUILD_BRIDGE

  1207.         CarlaPlugin* const plugin(kData->plugins[0].plugin);

  1208. 

  1209.         if (plugin != nullptr && plugin->enabled() && plugin->tryLock())

  1210.         {

  1211.             plugin->initBuffers();

  1212.             processPlugin(plugin, nframes);

  1213.             plugin->unlock();

  1214.         }

  1215. #else

  1216.         if (fOptions.processMode == PROCESS_MODE_SINGLE_CLIENT)

  1217.         {

  1218.             for (unsigned int i=0; i < kData->curPluginCount; ++i)

  1219.             {

  1220.                 CarlaPlugin* const plugin(kData->plugins[i].plugin);

  1221. 

  1222.                 if (plugin != nullptr && plugin->enabled() && plugin->tryLock())

  1223.                 {

  1224.                     plugin->initBuffers();

  1225.                     processPlugin(plugin, nframes);

  1226.                     plugin->unlock();

  1227.                 }

  1228.             }

  1229.         }

  1230.         else if (fOptions.processMode == PROCESS_MODE_CONTINUOUS_RACK)

  1231.         {

  1232.             // get buffers from jack

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

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

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

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

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

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

  1239. 

  1240.             // assert buffers

  1241.             CARLA_ASSERT(audioIn1 != nullptr);

  1242.             CARLA_ASSERT(audioIn2 != nullptr);

  1243.             CARLA_ASSERT(audioOut1 != nullptr);

  1244.             CARLA_ASSERT(audioOut2 != nullptr);

  1245.             CARLA_ASSERT(eventIn != nullptr);

  1246.             CARLA_ASSERT(eventOut != nullptr);

  1247. 

  1248.             // create audio buffers

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

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

  1251. 

  1252.             // initialize input events

  1253.             carla_zeroStruct<EngineEvent>(kData->bufEvents.in, INTERNAL_EVENT_COUNT);

  1254.             {

  1255.                 uint32_t engineEventIndex = 0;

  1256. 

  1257.                 jack_midi_event_t jackEvent;

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

  1259. 

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

  1261.                 {

  1262.                     if (jackbridge_midi_event_get(&jackEvent, eventIn, jackEventIndex) != 0)

  1263.                         continue;

  1264. 

  1265.                     EngineEvent* const engineEvent(&kData->bufEvents.in[engineEventIndex++]);

  1266.                     engineEvent->clear();

  1267. 

  1268.                     const uint8_t midiStatus  = MIDI_GET_STATUS_FROM_DATA(jackEvent.buffer);

  1269.                     const uint8_t midiChannel = MIDI_GET_CHANNEL_FROM_DATA(jackEvent.buffer);

  1270. 

  1271.                     engineEvent->time    = jackEvent.time;

  1272.                     engineEvent->channel = midiChannel;

  1273. 

  1274.                     if (MIDI_IS_STATUS_CONTROL_CHANGE(midiStatus))

  1275.                     {

  1276.                         const uint8_t midiControl = jackEvent.buffer[1];

  1277.                         engineEvent->type         = kEngineEventTypeControl;

  1278. 

  1279.                         if (MIDI_IS_CONTROL_BANK_SELECT(midiControl))

  1280.                         {

  1281.                             const uint8_t midiBank  = jackEvent.buffer[2];

  1282. 

  1283.                             engineEvent->ctrl.type  = kEngineControlEventTypeMidiBank;

  1284.                             engineEvent->ctrl.param = midiBank;

  1285.                             engineEvent->ctrl.value = 0.0f;

  1286.                         }

  1287.                         else if (midiControl == MIDI_CONTROL_ALL_SOUND_OFF)

  1288.                         {

  1289.                             engineEvent->ctrl.type  = kEngineControlEventTypeAllSoundOff;

  1290.                             engineEvent->ctrl.param = 0;

  1291.                             engineEvent->ctrl.value = 0.0f;

  1292.                         }

  1293.                         else if (midiControl == MIDI_CONTROL_ALL_NOTES_OFF)

  1294.                         {

  1295.                             engineEvent->ctrl.type  = kEngineControlEventTypeAllNotesOff;

  1296.                             engineEvent->ctrl.param = 0;

  1297.                             engineEvent->ctrl.value = 0.0f;

  1298.                         }

  1299.                         else

  1300.                         {

  1301.                             const uint8_t midiValue = jackEvent.buffer[2];

  1302. 

  1303.                             engineEvent->ctrl.type  = kEngineControlEventTypeParameter;

  1304.                             engineEvent->ctrl.param = midiControl;

  1305.                             engineEvent->ctrl.value = float(midiValue)/127.0f;

  1306.                         }

  1307.                     }

  1308.                     else if (MIDI_IS_STATUS_PROGRAM_CHANGE(midiStatus))

  1309.                     {

  1310.                         const uint8_t midiProgram = jackEvent.buffer[1];

  1311.                         engineEvent->type         = kEngineEventTypeControl;

  1312. 

  1313.                         engineEvent->ctrl.type  = kEngineControlEventTypeMidiProgram;

  1314.                         engineEvent->ctrl.param = midiProgram;

  1315.                         engineEvent->ctrl.value = 0.0f;

  1316.                     }

  1317.                     else if (jackEvent.size <= 4)

  1318.                     {

  1319.                         engineEvent->type = kEngineEventTypeMidi;

  1320. 

  1321.                         carla_copy<uint8_t>(engineEvent->midi.data, jackEvent.buffer, jackEvent.size);

  1322. 

  1323.                         engineEvent->midi.data[0] = midiStatus;

  1324.                         engineEvent->midi.size    = static_cast<uint8_t>(jackEvent.size);

  1325.                     }

  1326. 

  1327.                     if (engineEventIndex >= INTERNAL_EVENT_COUNT)

  1328.                         break;

  1329.                 }

  1330.             }

  1331. 

  1332.             // process rack

  1333.             processRack(inBuf, outBuf, nframes);

  1334. 

  1335.             // output control

  1336.             {

  1337.                 jackbridge_midi_clear_buffer(eventOut);

  1338. 

  1339.                 for (unsigned short i=0; i < INTERNAL_EVENT_COUNT; ++i)

  1340.                 {

  1341.                     EngineEvent* const engineEvent = &kData->bufEvents.out[i];

  1342. 

  1343.                     uint8_t data[3] = { 0 };

  1344.                     uint8_t size    = 0;

  1345. 

  1346.                     switch (engineEvent->type)

  1347.                     {

  1348.                     case kEngineEventTypeNull:

  1349.                         break;

  1350. 

  1351.                     case kEngineEventTypeControl:

  1352.                     {

  1353.                         EngineControlEvent* const ctrlEvent = &engineEvent->ctrl;

  1354. 

  1355.                         if (ctrlEvent->type == kEngineControlEventTypeParameter && MIDI_IS_CONTROL_BANK_SELECT(ctrlEvent->param))

  1356.                         {

  1357.                             // FIXME?

  1358.                             ctrlEvent->type  = kEngineControlEventTypeMidiBank;

  1359.                             ctrlEvent->param = ctrlEvent->value;

  1360.                             ctrlEvent->value = 0.0f;

  1361.                         }

  1362. 

  1363.                         switch (ctrlEvent->type)

  1364.                         {

  1365.                         case kEngineControlEventTypeNull:

  1366.                             break;

  1367.                         case kEngineControlEventTypeParameter:

  1368.                             data[0] = MIDI_STATUS_CONTROL_CHANGE + engineEvent->channel;

  1369.                             data[1] = static_cast<uint8_t>(ctrlEvent->param);

  1370.                             data[2] = uint8_t(ctrlEvent->value * 127.0f);

  1371.                             size    = 3;

  1372.                             break;

  1373.                         case kEngineControlEventTypeMidiBank:

  1374.                             data[0] = MIDI_STATUS_CONTROL_CHANGE + engineEvent->channel;

  1375.                             data[1] = MIDI_CONTROL_BANK_SELECT;

  1376.                             data[2] = static_cast<uint8_t>(ctrlEvent->param);

  1377.                             size    = 3;

  1378.                             break;

  1379.                         case kEngineControlEventTypeMidiProgram:

  1380.                             data[0] = MIDI_STATUS_PROGRAM_CHANGE + engineEvent->channel;

  1381.                             data[1] = static_cast<uint8_t>(ctrlEvent->param);

  1382.                             size    = 2;

  1383.                             break;

  1384.                         case kEngineControlEventTypeAllSoundOff:

  1385.                             data[0] = MIDI_STATUS_CONTROL_CHANGE + engineEvent->channel;

  1386.                             data[1] = MIDI_CONTROL_ALL_SOUND_OFF;

  1387.                             size    = 2;

  1388.                             break;

  1389.                         case kEngineControlEventTypeAllNotesOff:

  1390.                             data[0] = MIDI_STATUS_CONTROL_CHANGE + engineEvent->channel;

  1391.                             data[1] = MIDI_CONTROL_ALL_NOTES_OFF;

  1392.                             size    = 2;

  1393.                             break;

  1394.                         }

  1395.                         break;

  1396.                     }

  1397. 

  1398.                     case kEngineEventTypeMidi:

  1399.                     {

  1400.                         EngineMidiEvent* const midiEvent = &engineEvent->midi;

  1401. 

  1402.                         data[0] = midiEvent->data[0];

  1403.                         data[1] = midiEvent->data[1];

  1404.                         data[2] = midiEvent->data[2];

  1405.                         size    = midiEvent->size;

  1406.                         break;

  1407.                     }

  1408.                     }

  1409. 

  1410.                     if (size > 0)

  1411.                         jackbridge_midi_event_write(eventOut, engineEvent->time, data, size);

  1412.                 }

  1413.             }

  1414.         }

  1415. #endif // ! BUILD_BRIDGE

  1416. 

  1417.         proccessPendingEvents();

  1418.     }

  1419. 

  1420.     void handleJackLatencyCallback(const jack_latency_callback_mode_t mode)

  1421.     {

  1422.         if (fOptions.processMode != PROCESS_MODE_SINGLE_CLIENT)

  1423.             return;

  1424. 

  1425.         for (unsigned int i=0; i < kData->curPluginCount; ++i)

  1426.         {

  1427.             CarlaPlugin* const plugin(kData->plugins[i].plugin);

  1428. 

  1429.             if (plugin != nullptr && plugin->enabled())

  1430.                 latencyPlugin(plugin, mode);

  1431.         }

  1432.     }

  1433. 

  1434. #ifndef BUILD_BRIDGE

  1435.     void handleCustomAppearanceCallback(const char* client_name, const char* key, jack_custom_change_t change)

  1436.     {

  1437.         if ((change == JackCustomAdded || change == JackCustomReplaced) && std::strcmp(key, URI_CANVAS_ICON) == 0)

  1438.         {

  1439.             const int groupId (getGroupId(client_name));

  1440. 

  1441.             if (groupId == -1)

  1442.                 return;

  1443. 

  1444.             fGroupIconsChanged.append(groupId);

  1445.         }

  1446.     }

  1447. 

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

  1449.     {

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

  1451.         if (reg) return;

  1452. 

  1453.         const int id(getGroupId(name)); // also checks name nullness

  1454. 

  1455.         if (id == -1)

  1456.             return;

  1457. 

  1458.         GroupNameToId groupNameId(id, name);

  1459.         fUsedGroupNames.removeAll(groupNameId);

  1460. 

  1461.         callback(CALLBACK_PATCHBAY_CLIENT_REMOVED, 0, id, 0, 0.0f, nullptr);

  1462.     }

  1463. 

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

  1465.     {

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

  1467.         const char*  const portName(jackbridge_port_short_name(jackPort));

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

  1469. 

  1470.         CARLA_ASSERT(jackPort != nullptr);

  1471.         CARLA_ASSERT(portName != nullptr);

  1472.         CARLA_ASSERT(fullPortName != nullptr);

  1473. 

  1474.         if (jackPort == nullptr)

  1475.             return;

  1476.         if (portName == nullptr)

  1477.             return;

  1478.         if (fullPortName == nullptr)

  1479.             return;

  1480. 

  1481.         const size_t groupNameSize(std::strstr(fullPortName, portName) - fullPortName - 1);

  1482.         char         groupName[groupNameSize+1];

  1483. 

  1484.         carla_copy<char>(groupName, fullPortName, groupNameSize);

  1485.         groupName[groupNameSize] = '\0';

  1486. 

  1487.         int groupId = getGroupId(groupName);

  1488. 

  1489.         if (reg)

  1490.         {

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

  1492. 

  1493.             if (groupId == -1)

  1494.             {

  1495.                 groupId = fLastGroupId++;

  1496. 

  1497.                 GroupNameToId groupNameToId(groupId, groupName);

  1498.                 fUsedGroupNames.append(groupNameToId);

  1499. 

  1500.                 if (jackPortFlags & JackPortIsPhysical)

  1501.                 {

  1502.                     callback(CALLBACK_PATCHBAY_CLIENT_ADDED, 0, groupId, PATCHBAY_ICON_HARDWARE, 0.0f, groupName);

  1503.                 }

  1504.                 else

  1505.                 {

  1506.                     callback(CALLBACK_PATCHBAY_CLIENT_ADDED, 0, groupId, PATCHBAY_ICON_APPLICATION, 0.0f, groupName);

  1507.                     fGroupIconsChanged.append(groupId);

  1508.                 }

  1509.             }

  1510. 

  1511.             bool portIsInput = (jackPortFlags & JackPortIsInput);

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

  1513.             bool portIsCV    = (jackPortFlags & JackPortIsControlVoltage);

  1514. 

  1515.             unsigned int canvasPortFlags = 0x0;

  1516.             canvasPortFlags |= portIsInput ? PATCHBAY_PORT_IS_INPUT : PATCHBAY_PORT_IS_OUTPUT;

  1517.             canvasPortFlags |= portIsAudio ? PATCHBAY_PORT_IS_AUDIO : PATCHBAY_PORT_IS_MIDI;

  1518. 

  1519.             if (portIsAudio && portIsCV)

  1520.                 canvasPortFlags |= PATCHBAY_PORT_IS_CV;

  1521. 

  1522.             PortNameToId portNameToId(groupId, fLastPortId++, portName, fullPortName);

  1523.             fUsedPortNames.append(portNameToId);

  1524. 

  1525.             callback(CALLBACK_PATCHBAY_PORT_ADDED, 0, groupId, portNameToId.portId, canvasPortFlags, portName);

  1526.         }

  1527.         else

  1528.         {

  1529.             const int portId(getPortId(fullPortName));

  1530. 

  1531.             CARLA_ASSERT(groupId != -1);

  1532.             CARLA_ASSERT(portId != -1);

  1533. 

  1534.             if (groupId == -1 || portId == -1)

  1535.                 return;

  1536. 

  1537.             PortNameToId portNameId(groupId, portId, portName, fullPortName);

  1538.             fUsedPortNames.removeOne(portNameId);

  1539. 

  1540.             callback(CALLBACK_PATCHBAY_PORT_REMOVED, 0, portId, 0, 0.0f, nullptr);

  1541.         }

  1542.     }

  1543. 

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

  1545.     {

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

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

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

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

  1550. 

  1551.         CARLA_ASSERT(jackPortA != nullptr);

  1552.         CARLA_ASSERT(jackPortB != nullptr);

  1553.         CARLA_ASSERT(fullPortNameA != nullptr);

  1554.         CARLA_ASSERT(fullPortNameB != nullptr);

  1555. 

  1556.         if (jackPortA == nullptr)

  1557.             return;

  1558.         if (jackPortB == nullptr)

  1559.             return;

  1560.         if (fullPortNameA == nullptr)

  1561.             return;

  1562.         if (fullPortNameB == nullptr)

  1563.             return;

  1564. 

  1565.         const int portIdA(getPortId(fullPortNameA));

  1566.         const int portIdB(getPortId(fullPortNameB));

  1567. 

  1568.         if (portIdA == -1 || portIdB == -1)

  1569.             return;

  1570. 

  1571.         if (connect)

  1572.         {

  1573.             ConnectionToId connectionToId(fLastConnectionId++, portIdA, portIdB);

  1574.             fUsedConnections.append(connectionToId);

  1575. 

  1576.             callback(CALLBACK_PATCHBAY_CONNECTION_ADDED, 0, connectionToId.id, portIdA, portIdB, nullptr);

  1577.         }

  1578.         else

  1579.         {

  1580.             for (int i=0, count=fUsedConnections.count(); i < count; ++i)

  1581.             {

  1582.                 const ConnectionToId& connectionToId(fUsedConnections[i]);

  1583. 

  1584.                 if (connectionToId.portOut == portIdA && connectionToId.portIn == portIdB)

  1585.                 {

  1586.                     callback(CALLBACK_PATCHBAY_CONNECTION_REMOVED, 0, connectionToId.id, 0, 0.0f, nullptr);

  1587.                     fUsedConnections.takeAt(i);

  1588.                     break;

  1589.                 }

  1590.             }

  1591.         }

  1592.     }

  1593. 

  1594.     void handleJackClientRenameCallback(const char* const oldName, const char* const newName)

  1595.     {

  1596.         for (int i=0, count=fUsedGroupNames.count(); i < count; ++i)

  1597.         {

  1598.             GroupNameToId& groupNameToId(fUsedGroupNames[i]);

  1599. 

  1600.             if (std::strcmp(groupNameToId.name, oldName) == 0)

  1601.             {

  1602.                 groupNameToId.rename(newName);

  1603.                 callback(CALLBACK_PATCHBAY_CLIENT_RENAMED, 0, groupNameToId.id, 0, 0.0f, newName);

  1604.                 break;

  1605.             }

  1606.         }

  1607.     }

  1608. 

  1609.     void handleJackPortRenameCallback(const jack_port_id_t port, const char* const oldName, const char* const newName)

  1610.     {

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

  1612.         const char*  const portName(jackbridge_port_short_name(jackPort));

  1613. 

  1614.         CARLA_ASSERT(jackPort != nullptr);

  1615.         CARLA_ASSERT(portName != nullptr);

  1616. 

  1617.         if (jackPort == nullptr)

  1618.             return;

  1619.         if (portName == nullptr)

  1620.             return;

  1621. 

  1622.         const size_t groupNameSize(std::strstr(newName, portName) - newName - 1);

  1623.         char         groupName[groupNameSize+1];

  1624. 

  1625.         carla_copy<char>(groupName, newName, groupNameSize);

  1626.         groupName[groupNameSize] = '\0';

  1627. 

  1628.         const int groupId(getGroupId(groupName));

  1629. 

  1630.         CARLA_ASSERT(groupId != -1);

  1631. 

  1632.         if (groupId == -1)

  1633.             return;

  1634. 

  1635.         for (int i=0, count=fUsedPortNames.count(); i < count; ++i)

  1636.         {

  1637.             PortNameToId& portNameId(fUsedPortNames[i]);

  1638. 

  1639.             if (std::strcmp(portNameId.fullName, oldName) == 0)

  1640.             {

  1641.                 CARLA_ASSERT(portNameId.groupId == groupId);

  1642.                 portNameId.rename(portName, newName);

  1643.                 callback(CALLBACK_PATCHBAY_PORT_RENAMED, 0, portNameId.portId, 0, 0.0f, newName);

  1644.                 break;

  1645.             }

  1646.         }

  1647.     }

  1648. #endif

  1649. 

  1650.     void handleJackShutdownCallback()

  1651.     {

  1652.         for (unsigned int i=0; i < kData->curPluginCount; ++i)

  1653.         {

  1654.             //CarlaPlugin* const plugin(kData->plugins[i].plugin);

  1655. 

  1656.             //if (plugin)

  1657.             //    plugin->x_client = nullptr;

  1658.         }

  1659. 

  1660.         fClient = nullptr;

  1661.         callback(CALLBACK_QUIT, 0, 0, 0, 0.0f, nullptr);

  1662.     }

  1663. 

  1664.     // -------------------------------------

  1665. 

  1666. private:

  1667.     jack_client_t*         fClient;

  1668.     jack_position_t        fTransportPos;

  1669.     jack_transport_state_t fTransportState;

  1670.     bool fFreewheel;

  1671. 

  1672.     // -------------------------------------

  1673. 

  1674. #ifdef BUILD_BRIDGE

  1675.     bool fHasQuit;

  1676. #else

  1677.     enum RackPorts {

  1678.         kRackPortAudioIn1  = 0,

  1679.         kRackPortAudioIn2  = 1,

  1680.         kRackPortAudioOut1 = 2,

  1681.         kRackPortAudioOut2 = 3,

  1682.         kRackPortEventIn   = 4,

  1683.         kRackPortEventOut  = 5,

  1684.         kRackPortCount     = 6

  1685.     };

  1686. 

  1687.     jack_port_t* fRackPorts[kRackPortCount];

  1688. 

  1689.     struct GroupNameToId {

  1690.         int  id;

  1691.         char name[STR_MAX+1];

  1692. 

  1693.         GroupNameToId()

  1694.         {

  1695.             id = -1;

  1696.             name[0] = '\0';

  1697.         }

  1698. 

  1699.         GroupNameToId(const int id, const char name[])

  1700.         {

  1701.             this->id = id;

  1702.             std::strncpy(this->name, name, STR_MAX);

  1703.             this->name[STR_MAX] = '\0';

  1704.         }

  1705. 

  1706.         void rename(const char name[])

  1707.         {

  1708.             std::strncpy(this->name, name, STR_MAX);

  1709.             this->name[STR_MAX] = '\0';

  1710.         }

  1711. 

  1712.         bool operator==(const GroupNameToId& groupNameId)

  1713.         {

  1714.             if (groupNameId.id != id)

  1715.                 return false;

  1716.             if (std::strcmp(groupNameId.name, name) != 0)

  1717.                 return false;

  1718.             return true;

  1719.         }

  1720.     };

  1721. 

  1722.     struct PortNameToId {

  1723.         int  groupId;

  1724.         int  portId;

  1725.         char name[STR_MAX+1];

  1726.         char fullName[STR_MAX+1]; // unique

  1727. 

  1728.         PortNameToId()

  1729.         {

  1730.             groupId = -1;

  1731.             portId  = -1;

  1732.             name[0] = '\0';

  1733.             fullName[0] = '\0';

  1734.         }

  1735. 

  1736.         PortNameToId(const int groupId, const int portId, const char name[], const char fullName[])

  1737.         {

  1738.             this->groupId = groupId;

  1739.             this->portId  = portId;

  1740.             std::strncpy(this->name, name, STR_MAX);

  1741.             this->name[STR_MAX] = '\0';

  1742.             std::strncpy(this->fullName, fullName, STR_MAX);

  1743.             this->fullName[STR_MAX] = '\0';

  1744.         }

  1745. 

  1746.         void rename(const char name[], const char fullName[])

  1747.         {

  1748.             std::strncpy(this->name, name, STR_MAX);

  1749.             this->name[STR_MAX] = '\0';

  1750.             std::strncpy(this->fullName, fullName, STR_MAX);

  1751.             this->fullName[STR_MAX] = '\0';

  1752.         }

  1753. 

  1754.         bool operator==(const PortNameToId& portNameId)

  1755.         {

  1756.             if (portNameId.groupId != groupId)

  1757.                 return false;

  1758.             if (portNameId.portId != portId)

  1759.                 return false;

  1760.             if (std::strcmp(portNameId.name, name) != 0)

  1761.                 return false;

  1762.             if (std::strcmp(portNameId.fullName, fullName) != 0)

  1763.                 return false;

  1764.             return true;

  1765.         }

  1766.     };

  1767. 

  1768.     struct ConnectionToId {

  1769.         int id;

  1770.         int portOut;

  1771.         int portIn;

  1772. 

  1773.         ConnectionToId()

  1774.         {

  1775.             id = -1;

  1776.             portOut = -1;

  1777.             portIn  = -1;

  1778.         }

  1779. 

  1780.         ConnectionToId(const int id, const int portOut, const int portIn)

  1781.         {

  1782.             this->id = id;

  1783.             this->portOut = portOut;

  1784.             this->portIn  = portIn;

  1785.         }

  1786. 

  1787.         bool operator==(const ConnectionToId& connectionId)

  1788.         {

  1789.             if (connectionId.id != id)

  1790.                 return false;

  1791.             if (connectionId.portOut != portOut)

  1792.                 return false;

  1793.             if (connectionId.portIn != portIn)

  1794.                 return false;

  1795.             return true;

  1796.         }

  1797.     };

  1798. 

  1799.     int fLastGroupId;

  1800.     int fLastPortId;

  1801.     int fLastConnectionId;

  1802. 

  1803.     QList<GroupNameToId>  fUsedGroupNames;

  1804.     QList<PortNameToId>   fUsedPortNames;

  1805.     QList<ConnectionToId> fUsedConnections;

  1806.     QList<int> fGroupIconsChanged;

  1807. 

  1808.     int getGroupId(const char* const name)

  1809.     {

  1810.         CARLA_ASSERT(name != nullptr);

  1811. 

  1812.         if (name == nullptr)

  1813.             return -1;

  1814. 

  1815.         foreach (const GroupNameToId& groupNameId, fUsedGroupNames)

  1816.         {

  1817.             if (std::strcmp(groupNameId.name, name) == 0)

  1818.                 return groupNameId.id;

  1819.         }

  1820. 

  1821.         return -1;

  1822.     }

  1823. 

  1824.     const char* getGroupName(const int groupId)

  1825.     {

  1826.         CARLA_ASSERT(groupId >= 0);

  1827. 

  1828.         static const char fallback[1] = { '\0' };

  1829. 

  1830.         if (groupId < 0)

  1831.             return fallback;

  1832. 

  1833.         foreach (const GroupNameToId& groupNameId, fUsedGroupNames)

  1834.         {

  1835.             if (groupNameId.id == groupId)

  1836.                 return groupNameId.name;

  1837.         }

  1838. 

  1839.         return fallback;

  1840.     }

  1841. 

  1842.     int getPortId(const char* const fullName)

  1843.     {

  1844.         CARLA_ASSERT(fullName != nullptr);

  1845. 

  1846.         if (fullName == nullptr)

  1847.             return -1;

  1848. 

  1849.         foreach (const PortNameToId& portNameId, fUsedPortNames)

  1850.         {

  1851.             if (std::strcmp(portNameId.fullName, fullName) == 0)

  1852.                 return portNameId.portId;

  1853.         }

  1854. 

  1855.         return -1;

  1856.     }

  1857. 

  1858.     void getFullPortName(const int portId, char nameBuf[STR_MAX+1])

  1859.     {

  1860.         foreach (const PortNameToId& portNameId, fUsedPortNames)

  1861.         {

  1862.             if (portNameId.portId == portId)

  1863.             {

  1864.                 std::strncpy(nameBuf, portNameId.fullName, STR_MAX);

  1865.                 nameBuf[STR_MAX] = '\0';

  1866.                 return;

  1867.             }

  1868.         }

  1869. 

  1870.         nameBuf[0] = '\0';

  1871.     }

  1872. 

  1873.     void initJackPatchbay(const char* const ourName)

  1874.     {

  1875.         CARLA_ASSERT(fLastGroupId == 0);

  1876.         CARLA_ASSERT(fLastPortId == 0);

  1877.         CARLA_ASSERT(fLastConnectionId == 0);

  1878.         CARLA_ASSERT(ourName != nullptr);

  1879. 

  1880.         // query initial jack ports

  1881.         QStringList parsedGroups;

  1882. 

  1883.         // our client

  1884.         if (ourName != nullptr)

  1885.         {

  1886.             parsedGroups.append(QString(ourName));

  1887. 

  1888.             GroupNameToId groupNameToId(fLastGroupId++, ourName);

  1889.             fUsedGroupNames.append(groupNameToId);

  1890. 

  1891.             callback(CALLBACK_PATCHBAY_CLIENT_ADDED, 0, groupNameToId.id, PATCHBAY_ICON_CARLA, 0.0f, ourName);

  1892.         }

  1893. 

  1894.         if (const char** ports = jackbridge_get_ports(fClient, nullptr, nullptr, 0))

  1895.         {

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

  1897.             {

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

  1899.                 const char*  const portName(jackbridge_port_short_name(jackPort));

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

  1901. 

  1902.                 CARLA_ASSERT(jackPort != nullptr);

  1903.                 CARLA_ASSERT(portName != nullptr);

  1904. 

  1905.                 if (jackPort == nullptr)

  1906.                     continue;

  1907.                 if (portName == nullptr)

  1908.                     continue;

  1909. 

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

  1911. 

  1912.                 const size_t groupNameSize(std::strstr(fullPortName, portName) - fullPortName - 1);

  1913.                 char         groupName[groupNameSize+1];

  1914.                 int          groupId = -1;

  1915. 

  1916.                 carla_copy<char>(groupName, fullPortName, groupNameSize);

  1917.                 groupName[groupNameSize] = '\0';

  1918. 

  1919.                 if (parsedGroups.contains(QString(groupName)))

  1920.                 {

  1921.                     groupId = getGroupId(groupName);

  1922.                     CARLA_ASSERT(groupId != -1);

  1923.                 }

  1924.                 else

  1925.                 {

  1926.                     groupId = fLastGroupId++;

  1927.                     parsedGroups.append(groupName);

  1928. 

  1929.                     GroupNameToId groupNameToId(groupId, groupName);

  1930.                     fUsedGroupNames.append(groupNameToId);

  1931. 

  1932.                     PatchbayIconType groupIcon = PATCHBAY_ICON_APPLICATION;

  1933. 

  1934.                     void*  data = nullptr;

  1935.                     size_t dataSize = 0;

  1936. 

  1937.                     if (jackPortFlags & JackPortIsPhysical)

  1938.                     {

  1939.                         groupIcon = PATCHBAY_ICON_HARDWARE;

  1940.                     }

  1941.                     else if (jackbridge_custom_get_data(fClient, groupName, URI_CANVAS_ICON, &data, &dataSize) && data != nullptr && dataSize != 0)

  1942.                     {

  1943.                         const char* const icon((const char*)data);

  1944.                         CARLA_ASSERT(std::strlen(icon)+1 == dataSize);

  1945. 

  1946.                         if (std::strcmp(icon, "app") == 0 || std::strcmp(icon, "application") == 0)

  1947.                             groupIcon = PATCHBAY_ICON_APPLICATION;

  1948.                         else if (std::strcmp(icon, "hardware") == 0)

  1949.                             groupIcon = PATCHBAY_ICON_HARDWARE;

  1950.                         else if (std::strcmp(icon, "carla") == 0)

  1951.                             groupIcon = PATCHBAY_ICON_CARLA;

  1952.                         else if (std::strcmp(icon, "distrho") == 0)

  1953.                             groupIcon = PATCHBAY_ICON_DISTRHO;

  1954.                         else if (std::strcmp(icon, "file") == 0)

  1955.                             groupIcon = PATCHBAY_ICON_FILE;

  1956.                         else if (std::strcmp(icon, "plugin") == 0)

  1957.                             groupIcon = PATCHBAY_ICON_PLUGIN;

  1958.                     }

  1959. 

  1960.                     callback(CALLBACK_PATCHBAY_CLIENT_ADDED, 0, groupId, groupIcon, 0.0f, groupName);

  1961.                 }

  1962. 

  1963.                 bool portIsInput = (jackPortFlags & JackPortIsInput);

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

  1965.                 bool portIsCV    = (jackPortFlags & JackPortIsControlVoltage);

  1966. 

  1967.                 unsigned int canvasPortFlags = 0x0;

  1968.                 canvasPortFlags |= portIsInput ? PATCHBAY_PORT_IS_INPUT : PATCHBAY_PORT_IS_OUTPUT;

  1969.                 canvasPortFlags |= portIsAudio ? PATCHBAY_PORT_IS_AUDIO : PATCHBAY_PORT_IS_MIDI;

  1970. 

  1971.                 if (portIsAudio && portIsCV)

  1972.                     canvasPortFlags |= PATCHBAY_PORT_IS_CV;

  1973. 

  1974.                 PortNameToId portNameToId(groupId, fLastPortId++, portName, fullPortName);

  1975.                 fUsedPortNames.append(portNameToId);

  1976. 

  1977.                 callback(CALLBACK_PATCHBAY_PORT_ADDED, 0, groupId, portNameToId.portId, canvasPortFlags, portName);

  1978.             }

  1979. 

  1980.             jackbridge_free(ports);

  1981.         }

  1982. 

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

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

  1985.         {

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

  1987.             {

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

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

  1990. 

  1991.                 CARLA_ASSERT(jackPort != nullptr);

  1992. 

  1993.                 if (jackPort == nullptr)

  1994.                     continue;

  1995. 

  1996.                 const int thisPortId(getPortId(fullPortName));

  1997. 

  1998.                 if (thisPortId == -1)

  1999.                     continue;

  2000. 

  2001.                 if (const char** connections = jackbridge_port_get_connections(jackPort))

  2002.                 {

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

  2004.                     {

  2005.                         const int targetPortId(getPortId(connections[j]));

  2006. 

  2007.                         ConnectionToId connectionToId(fLastConnectionId++, thisPortId, targetPortId);

  2008.                         fUsedConnections.append(connectionToId);

  2009. 

  2010.                         callback(CALLBACK_PATCHBAY_CONNECTION_ADDED, 0, connectionToId.id, thisPortId, targetPortId, nullptr);

  2011.                     }

  2012. 

  2013.                     jackbridge_free(connections);

  2014.                 }

  2015.             }

  2016. 

  2017.             jackbridge_free(ports);

  2018.         }

  2019.     }

  2020. #endif

  2021. 

  2022.     // -------------------------------------

  2023. 

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

  2025.     {

  2026.         const uint32_t inCount(plugin->audioInCount());

  2027.         const uint32_t outCount(plugin->audioOutCount());

  2028. 

  2029.         float* inBuffer[inCount];

  2030.         float* outBuffer[outCount];

  2031. 

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

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

  2034. 

  2035.         for (uint32_t i=0; i < inCount; ++i)

  2036.         {

  2037.             CarlaEngineAudioPort* const port(CarlaPluginGetAudioInPort(plugin, i));

  2038.             inBuffer[i] = port->getBuffer();

  2039.         }

  2040. 

  2041.         for (uint32_t i=0; i < outCount; ++i)

  2042.         {

  2043.             CarlaEngineAudioPort* const port(CarlaPluginGetAudioOutPort(plugin, i));

  2044.             outBuffer[i] = port->getBuffer();

  2045.         }

  2046. 

  2047.         for (uint32_t i=0; i < inCount && i < 2; ++i)

  2048.         {

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

  2050.             {

  2051.                 const float absV(std::abs(inBuffer[i][j]));

  2052. 

  2053.                 if (absV > inPeaks[i])

  2054.                     inPeaks[i] = absV;

  2055.             }

  2056.         }

  2057. 

  2058.         plugin->process(inBuffer, outBuffer, nframes);

  2059. 

  2060.         for (uint32_t i=0; i < outCount && i < 2; ++i)

  2061.         {

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

  2063.             {

  2064.                 const float absV(std::abs(outBuffer[i][j]));

  2065. 

  2066.                 if (absV > outPeaks[i])

  2067.                     outPeaks[i] = absV;

  2068.             }

  2069.         }

  2070. 

  2071.         setPeaks(plugin->id(), inPeaks, outPeaks);

  2072.     }

  2073. 

  2074.     void latencyPlugin(CarlaPlugin* const plugin, jack_latency_callback_mode_t mode)

  2075.     {

  2076.         //const uint32_t inCount(plugin->audioInCount());

  2077.         //const uint32_t outCount(plugin->audioOutCount());

  2078.         const uint32_t latency(plugin->latency());

  2079. 

  2080.         if (latency == 0)

  2081.             return;

  2082. 

  2083.         //jack_latency_range_t range;

  2084. 

  2085.         // TODO

  2086. 

  2087.         if (mode == JackCaptureLatency)

  2088.         {

  2089. #if 0

  2090.             for (uint32_t i=0; i < inCount; ++i)

  2091.             {

  2092.                 uint32_t aOutI = (i >= outCount) ? outCount : i;

  2093.                 jack_port_t* const portIn  = ((CarlaEngineJackAudioPort*)CarlaPluginGetAudioInPort(plugin, i))->kPort;

  2094.                 jack_port_t* const portOut = ((CarlaEngineJackAudioPort*)CarlaPluginGetAudioOutPort(plugin, aOutI))->kPort;

  2095. 

  2096.                 jackbridge_port_get_latency_range(portIn, mode, &range);

  2097.                 range.min += latency;

  2098.                 range.max += latency;

  2099.                 jackbridge_port_set_latency_range(portOut, mode, &range);

  2100.             }

  2101. #endif

  2102.         }

  2103.         else

  2104.         {

  2105. #if 0

  2106.             for (uint32_t i=0; i < outCount; ++i)

  2107.             {

  2108.                 uint32_t aInI = (i >= inCount) ? inCount : i;

  2109.                 jack_port_t* const portIn  = ((CarlaEngineJackAudioPort*)CarlaPluginGetAudioInPort(plugin, aInI))->kPort;

  2110.                 jack_port_t* const portOut = ((CarlaEngineJackAudioPort*)CarlaPluginGetAudioOutPort(plugin, i))->kPort;

  2111. 

  2112.                 jackbridge_port_get_latency_range(portOut, mode, &range);

  2113.                 range.min += latency;

  2114.                 range.max += latency;

  2115.                 jackbridge_port_set_latency_range(portIn, mode, &range);

  2116.             }

  2117. #endif

  2118.         }

  2119.     }

  2120. 

  2121.     // -------------------------------------

  2122. 

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

  2124. 

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

  2126.     {

  2127.         handlePtr->handleJackBufferSizeCallback(newBufferSize);

  2128.         return 0;

  2129.     }

  2130. 

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

  2132.     {

  2133.         handlePtr->handleJackSampleRateCallback(newSampleRate);

  2134.         return 0;

  2135.     }

  2136. 

  2137.     static void carla_jack_freewheel_callback(int starting, void* arg)

  2138.     {

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

  2140.     }

  2141. 

  2142.     static int carla_jack_process_callback(jack_nframes_t nframes, void* arg)

  2143.     {

  2144.         handlePtr->handleJackProcessCallback(nframes);

  2145.         return 0;

  2146.     }

  2147. 

  2148.     static void carla_jack_latency_callback(jack_latency_callback_mode_t mode, void* arg)

  2149.     {

  2150.         handlePtr->handleJackLatencyCallback(mode);

  2151.     }

  2152. 

  2153. #ifndef BUILD_BRIDGE

  2154.     static void carla_jack_custom_appearance_callback(const char* client_name, const char* key, jack_custom_change_t change, void* arg)

  2155.     {

  2156.         handlePtr->handleCustomAppearanceCallback(client_name, key, change);

  2157.     }

  2158. 

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

  2160.     {

  2161.         handlePtr->handleJackClientRegistrationCallback(name, (reg != 0));

  2162.     }

  2163. 

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

  2165.     {

  2166.         handlePtr->handleJackPortRegistrationCallback(port, (reg != 0));

  2167.     }

  2168. 

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

  2170.     {

  2171.         handlePtr->handleJackPortConnectCallback(a, b, (connect != 0));

  2172.     }

  2173. 

  2174.     static int carla_jack_client_rename_callback(const char* oldName, const char* newName, void* arg)

  2175.     {

  2176.         handlePtr->handleJackClientRenameCallback(oldName, newName);

  2177.         return 0;

  2178.     }

  2179. 

  2180.     static int carla_jack_port_rename_callback(jack_port_id_t port, const char* oldName, const char* newName, void* arg)

  2181.     {

  2182.         handlePtr->handleJackPortRenameCallback(port, oldName, newName);

  2183.         return 0;

  2184.     }

  2185. #endif

  2186. 

  2187.     static void carla_jack_shutdown_callback(void* arg)

  2188.     {

  2189.         handlePtr->handleJackShutdownCallback();

  2190.     }

  2191. 

  2192.     #undef handlePtr

  2193. 

  2194.     // -------------------------------------

  2195. 

  2196. #ifndef BUILD_BRIDGE

  2197.     static int carla_jack_process_callback_plugin(jack_nframes_t nframes, void* arg)

  2198.     {

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

  2200. 

  2201.         if (plugin != nullptr && plugin->enabled() && plugin->tryLock())

  2202.         {

  2203.             CarlaEngineJack* const engine((CarlaEngineJack*)CarlaPluginGetEngine(plugin));

  2204.             CARLA_ASSERT(engine != nullptr);

  2205. 

  2206.             plugin->initBuffers();

  2207.             engine->saveTransportInfo();

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

  2209.             plugin->unlock();

  2210.         }

  2211. 

  2212.         return 0;

  2213.     }

  2214. 

  2215.     static void carla_jack_latency_callback_plugin(jack_latency_callback_mode_t mode, void* arg)

  2216.     {

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

  2218. 

  2219.         if (plugin != nullptr && plugin->enabled())

  2220.         {

  2221.             CarlaEngineJack* const engine((CarlaEngineJack*)CarlaPluginGetEngine(plugin));

  2222.             CARLA_ASSERT(engine != nullptr);

  2223. 

  2224.             engine->latencyPlugin(plugin, mode);

  2225.         }

  2226.     }

  2227. #endif

  2228. 

  2229.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaEngineJack)

  2230. };

  2231. 

  2232. // -----------------------------------------

  2233. 

  2234. CarlaEngine* CarlaEngine::newJack()

  2235. {

  2236.     return new CarlaEngineJack();

  2237. }

  2238. 

  2239. // -----------------------------------------

  2240. 

  2241. CARLA_BACKEND_END_NAMESPACE