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.
663 Commits
17 Branches
549MB
Tree: 33de508be2
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '33de508be2'
${ noResults }
Carla/source/backend/engine/CarlaEngineJack.cpp

1931 lines
64KB
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. CARLA_BACKEND_START_NAMESPACE

  33. 

  34. #if 0

  35. } // Fix editor indentation

  36. #endif

  37. 

  38. // -------------------------------------------------------------------------------------------------------------------

  39. // Fallback data

  40. 

  41. static const EngineEvent kFallbackJackEngineEvent;

  42. 

  43. // -------------------------------------------------------------------------------------------------------------------

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

  45. 

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

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

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

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

  50. 

  51. // -------------------------------------------------------------------------------------------------------------------

  52. // Carla Engine JACK-Audio port

  53. 

  54. class CarlaEngineJackAudioPort : public CarlaEngineAudioPort

  55. {

  56. public:

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

  58.         : CarlaEngineAudioPort(isInput, processMode),

  59.           kClient(client),

  60.           kPort(port)

  61.     {

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

  63. 

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

  65.         {

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

  67.         }

  68.         else

  69.         {

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

  71.         }

  72.     }

  73. 

  74.     ~CarlaEngineJackAudioPort() override

  75.     {

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

  77. 

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

  79.             jackbridge_port_unregister(kClient, kPort);

  80.     }

  81. 

  82.     void initBuffer(CarlaEngine* const engine) override

  83.     {

  84.         CARLA_ASSERT(engine != nullptr);

  85. 

  86.         if (engine == nullptr)

  87.             return;

  88. 

  89.         if (kPort == nullptr)

  90.             return CarlaEngineAudioPort::initBuffer(engine);

  91. 

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

  93. 

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

  95. 

  96.         if (! kIsInput)

  97.            carla_zeroFloat(fBuffer, bufferSize);

  98.     }

  99. 

  100. private:

  101.     jack_client_t* const kClient;

  102.     jack_port_t*   const kPort;

  103. 

  104.     friend class CarlaEngineJack;

  105. 

  106.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaEngineJackAudioPort)

  107. };

  108. 

  109. // -------------------------------------------------------------------------------------------------------------------

  110. // Carla Engine JACK-CV port

  111. 

  112. class CarlaEngineJackCVPort : public CarlaEngineCVPort

  113. {

  114. public:

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

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

  117.           kClient(client),

  118.           kPort(port)

  119.     {

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

  121. 

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

  123.         {

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

  125.         }

  126.         else

  127.         {

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

  129.         }

  130.     }

  131. 

  132.     ~CarlaEngineJackCVPort() override

  133.     {

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

  135. 

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

  137.             jackbridge_port_unregister(kClient, kPort);

  138.     }

  139. 

  140.     void initBuffer(CarlaEngine* const engine) override

  141.     {

  142.         CARLA_ASSERT(engine != nullptr);

  143. 

  144.         if (engine == nullptr)

  145.             return;

  146. 

  147.         if (kPort == nullptr)

  148.             return CarlaEngineCVPort::initBuffer(engine);

  149. 

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

  151. 

  152.         if (kIsInput)

  153.         {

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

  155.             carla_copyFloat(fBuffer, jackBuffer, fBufferSize);

  156.         }

  157.         else

  158.         {

  159.             carla_zeroFloat(fBuffer, fBufferSize);

  160.         }

  161.     }

  162. 

  163.     void writeBuffer(CarlaEngine* const engine) override

  164.     {

  165.         CARLA_ASSERT(! kIsInput);

  166.         CARLA_ASSERT(engine != nullptr);

  167. 

  168.         if (kIsInput)

  169.             return;

  170.         if (engine == nullptr)

  171.             return;

  172. 

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

  174. 

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

  176.         carla_copyFloat(jackBuffer, fBuffer, fBufferSize);

  177.     }

  178. 

  179. private:

  180.     jack_client_t* const kClient;

  181.     jack_port_t*   const kPort;

  182. 

  183.     friend class CarlaEngineJack;

  184. 

  185.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaEngineJackCVPort)

  186. };

  187. 

  188. // -------------------------------------------------------------------------------------------------------------------

  189. // Carla Engine JACK-Event port

  190. 

  191. class CarlaEngineJackEventPort : public CarlaEngineEventPort

  192. {

  193. public:

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

  195.         : CarlaEngineEventPort(isInput, processMode),

  196.           kClient(client),

  197.           kPort(port),

  198.           fJackBuffer(nullptr)

  199.     {

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

  201. 

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

  203.         {

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

  205.         }

  206.         else

  207.         {

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

  209.         }

  210.     }

  211. 

  212.     ~CarlaEngineJackEventPort() override

  213.     {

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

  215. 

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

  217.             jackbridge_port_unregister(kClient, kPort);

  218.     }

  219. 

  220.     void initBuffer(CarlaEngine* const engine) override

  221.     {

  222.         CARLA_ASSERT(engine != nullptr);

  223. 

  224.         if (engine == nullptr)

  225.             return;

  226. 

  227.         if (kPort == nullptr)

  228.             return CarlaEngineEventPort::initBuffer(engine);

  229. 

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

  231. 

  232.         if (! kIsInput)

  233.             jackbridge_midi_clear_buffer(fJackBuffer);

  234.     }

  235. 

  236.     uint32_t getEventCount() const override

  237.     {

  238.         if (kPort == nullptr)

  239.             return CarlaEngineEventPort::getEventCount();

  240. 

  241.         CARLA_ASSERT(kIsInput);

  242.         CARLA_ASSERT(fJackBuffer != nullptr);

  243. 

  244.         if (! kIsInput)

  245.             return 0;

  246.         if (fJackBuffer == nullptr)

  247.             return 0;

  248. 

  249.         return jackbridge_midi_get_event_count(fJackBuffer);

  250.     }

  251. 

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

  253.     {

  254.         if (kPort == nullptr)

  255.             return CarlaEngineEventPort::getEvent(index);

  256. 

  257.         CARLA_ASSERT(kIsInput);

  258.         CARLA_ASSERT(fJackBuffer != nullptr);

  259. 

  260.         if (! kIsInput)

  261.             return kFallbackJackEngineEvent;

  262.         if (fJackBuffer == nullptr)

  263.             return kFallbackJackEngineEvent;

  264. 

  265.         jack_midi_event_t jackEvent;

  266.         carla_zeroStruct<jack_midi_event_t>(jackEvent);

  267. 

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

  269.             return kFallbackJackEngineEvent;

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

  271.             return kFallbackJackEngineEvent;

  272. 

  273.         fRetEvent.clear();

  274. 

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

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

  277. 

  278.         fRetEvent.time    = jackEvent.time;

  279.         fRetEvent.channel = midiChannel;

  280. 

  281.         if (MIDI_IS_STATUS_CONTROL_CHANGE(midiStatus))

  282.         {

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

  284. 

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

  286.             fRetEvent.type            = kEngineEventTypeControl;

  287. 

  288.             if (MIDI_IS_CONTROL_BANK_SELECT(midiControl))

  289.             {

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

  291. 

  292.                 fRetEvent.ctrl.type  = kEngineControlEventTypeMidiBank;

  293.                 fRetEvent.ctrl.param = midiBank;

  294.                 fRetEvent.ctrl.value = 0.0f;

  295.             }

  296.             else if (midiControl == MIDI_CONTROL_ALL_SOUND_OFF)

  297.             {

  298.                 fRetEvent.ctrl.type  = kEngineControlEventTypeAllSoundOff;

  299.                 fRetEvent.ctrl.param = 0;

  300.                 fRetEvent.ctrl.value = 0.0f;

  301.             }

  302.             else if (midiControl == MIDI_CONTROL_ALL_NOTES_OFF)

  303.             {

  304.                 fRetEvent.ctrl.type  = kEngineControlEventTypeAllNotesOff;

  305.                 fRetEvent.ctrl.param = 0;

  306.                 fRetEvent.ctrl.value = 0.0f;

  307.             }

  308.             else

  309.             {

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

  311. 

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

  313. 

  314.                 fRetEvent.ctrl.type  = kEngineControlEventTypeParameter;

  315.                 fRetEvent.ctrl.param = midiControl;

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

  317.             }

  318.         }

  319.         else if (MIDI_IS_STATUS_PROGRAM_CHANGE(midiStatus))

  320.         {

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

  322. 

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

  324.             fRetEvent.type            = kEngineEventTypeControl;

  325. 

  326.             fRetEvent.ctrl.type  = kEngineControlEventTypeMidiProgram;

  327.             fRetEvent.ctrl.param = midiProgram;

  328.             fRetEvent.ctrl.value = 0.0f;

  329.         }

  330.         else

  331.         {

  332.             fRetEvent.type = kEngineEventTypeMidi;

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

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

  335. 

  336.             if (jackEvent.size > 1)

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

  338.         }

  339. 

  340.         return fRetEvent;

  341.     }

  342. 

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

  344.     {

  345.         if (kPort == nullptr)

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

  347. 

  348.         CARLA_ASSERT(! kIsInput);

  349.         CARLA_ASSERT(fJackBuffer != nullptr);

  350.         CARLA_ASSERT(type != kEngineControlEventTypeNull);

  351.         CARLA_ASSERT(channel < MAX_MIDI_CHANNELS);

  352.         CARLA_ASSERT(param < MAX_MIDI_VALUE);

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

  354. 

  355.         if (kIsInput)

  356.             return;

  357.         if (fJackBuffer == nullptr)

  358.             return;

  359.         if (type == kEngineControlEventTypeNull)

  360.             return;

  361.         if (channel >= MAX_MIDI_CHANNELS)

  362.             return;

  363.         if (param >= MAX_MIDI_VALUE)

  364.             return;

  365.         if (type == kEngineControlEventTypeParameter)

  366.         {

  367.             CARLA_ASSERT(! MIDI_IS_CONTROL_BANK_SELECT(param));

  368.         }

  369. 

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

  371. 

  372.         size_t size = 0;

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

  374. 

  375.         switch (type)

  376.         {

  377.         case kEngineControlEventTypeNull:

  378.             break;

  379.         case kEngineControlEventTypeParameter:

  380.             data[0] = MIDI_STATUS_CONTROL_CHANGE + channel;

  381.             data[1] = param;

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

  383.             size    = 3;

  384.             break;

  385.         case kEngineControlEventTypeMidiBank:

  386.             data[0] = MIDI_STATUS_CONTROL_CHANGE + channel;

  387.             data[1] = MIDI_CONTROL_BANK_SELECT;

  388.             data[2] = param;

  389.             size    = 3;

  390.             break;

  391.         case kEngineControlEventTypeMidiProgram:

  392.             data[0] = MIDI_STATUS_PROGRAM_CHANGE + channel;

  393.             data[1] = param;

  394.             size    = 2;

  395.             break;

  396.         case kEngineControlEventTypeAllSoundOff:

  397.             data[0] = MIDI_STATUS_CONTROL_CHANGE + channel;

  398.             data[1] = MIDI_CONTROL_ALL_SOUND_OFF;

  399.             data[2] = 0;

  400.             size    = 3;

  401.             break;

  402.         case kEngineControlEventTypeAllNotesOff:

  403.             data[0] = MIDI_STATUS_CONTROL_CHANGE + channel;

  404.             data[1] = MIDI_CONTROL_ALL_NOTES_OFF;

  405.             data[2] = 0;

  406.             size    = 3;

  407.             break;

  408.         }

  409. 

  410.         if (size > 0)

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

  412.     }

  413. 

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

  415.     {

  416.         if (kPort == nullptr)

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

  418. 

  419.         CARLA_ASSERT(! kIsInput);

  420.         CARLA_ASSERT(fJackBuffer != nullptr);

  421.         CARLA_ASSERT(channel < MAX_MIDI_CHANNELS);

  422.         CARLA_ASSERT(data != nullptr);

  423.         CARLA_ASSERT(size != 0);

  424. 

  425.         if (kIsInput)

  426.             return;

  427.         if (fJackBuffer == nullptr)

  428.             return;

  429.         if (channel >= MAX_MIDI_CHANNELS)

  430.             return;

  431.         if (data == nullptr)

  432.             return;

  433.         if (size == 0)

  434.             return;

  435. 

  436.         uint8_t jdata[size];

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

  438. 

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

  440. 

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

  442.     }

  443. 

  444. private:

  445.     jack_client_t* const kClient;

  446.     jack_port_t*   const kPort;

  447. 

  448.     void*       fJackBuffer;

  449.     EngineEvent fRetEvent;

  450. 

  451.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaEngineJackEventPort)

  452. };

  453. 

  454. // -------------------------------------------------------------------------------------------------------------------

  455. // Jack Engine client

  456. 

  457. class CarlaEngineJackClient : public CarlaEngineClient

  458. {

  459. public:

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

  461.         : CarlaEngineClient(engine),

  462.           kClient(client),

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

  464.     {

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

  466. 

  467.         if (kUseClient)

  468.         {

  469.             CARLA_ASSERT(kClient != nullptr);

  470.         }

  471.         else

  472.         {

  473.             CARLA_ASSERT(kClient == nullptr);

  474.         }

  475.     }

  476. 

  477.     ~CarlaEngineJackClient() override

  478.     {

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

  480. 

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

  482.             jackbridge_client_close(kClient);

  483.     }

  484. 

  485.     void activate() override

  486.     {

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

  488. 

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

  490.         {

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

  492. 

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

  494.                 jackbridge_activate(kClient);

  495.         }

  496. 

  497.         CarlaEngineClient::activate();

  498.     }

  499. 

  500.     void deactivate() override

  501.     {

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

  503. 

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

  505.         {

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

  507. 

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

  509.                 jackbridge_deactivate(kClient);

  510.         }

  511. 

  512.         CarlaEngineClient::deactivate();

  513.     }

  514. 

  515.     bool isOk() const override

  516.     {

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

  518. 

  519.         if (kUseClient)

  520.             return (kClient != nullptr);

  521. 

  522.         return CarlaEngineClient::isOk();

  523.     }

  524. 

  525. #if 0

  526.     void setLatency(const uint32_t samples) override

  527.     {

  528.         CarlaEngineClient::setLatency(samples);

  529. 

  530.         if (kUseClient)

  531.             jackbridge_recompute_total_latencies(kClient);

  532.     }

  533. #endif

  534. 

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

  536.     {

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

  538. 

  539.         jack_port_t* port = nullptr;

  540. 

  541.         // Create JACK port first, if needed

  542.         if (kUseClient)

  543.         {

  544.             switch (portType)

  545.             {

  546.             case kEnginePortTypeNull:

  547.                 break;

  548.             case kEnginePortTypeAudio:

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

  550.                 break;

  551.             case kEnginePortTypeCV:

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

  553.                 break;

  554.             case kEnginePortTypeEvent:

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

  556.                 break;

  557.             }

  558.         }

  559. 

  560.         // Create Engine port

  561.         switch (portType)

  562.         {

  563.         case kEnginePortTypeNull:

  564.             break;

  565.         case kEnginePortTypeAudio:

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

  567.         case kEnginePortTypeCV:

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

  569.         case kEnginePortTypeEvent:

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

  571.         }

  572. 

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

  574.         return nullptr;

  575.     }

  576. 

  577. private:

  578.     jack_client_t* const kClient;

  579.     const bool           kUseClient;

  580. 

  581.     friend class CarlaEngineJack;

  582.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaEngineJackClient)

  583. };

  584. 

  585. // -------------------------------------------------------------------------------------------------------------------

  586. // Jack Engine

  587. 

  588. class CarlaEngineJack : public CarlaEngine

  589. {

  590. public:

  591.     CarlaEngineJack()

  592.         : CarlaEngine(),

  593.           fClient(nullptr),

  594.           fTransportState(JackTransportStopped),

  595.           fFreewheel(false),

  596. #ifdef BUILD_BRIDGE

  597.           fHasQuit(false)

  598. #else

  599. # ifdef CARLA_PROPER_CPP11_SUPPORT

  600.           fRackPorts{nullptr},

  601. # endif

  602.           fLastGroupId(0),

  603.           fLastPortId(0),

  604.           fLastConnectionId(0)

  605. #endif

  606.     {

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

  608. 

  609. #ifdef BUILD_BRIDGE

  610.         fOptions.processMode = PROCESS_MODE_MULTIPLE_CLIENTS;

  611. #else

  612. # ifndef CARLA_PROPER_CPP11_SUPPORT

  613.         carla_fill<jack_port_t*>(fRackPorts, rackPortCount, nullptr);

  614. # endif

  615. #endif

  616. 

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

  618.         fOptions.transportMode = TRANSPORT_MODE_JACK;

  619. 

  620.         carla_zeroStruct<jack_position_t>(fTransportPos);

  621.     }

  622. 

  623.     ~CarlaEngineJack() override

  624.     {

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

  626.         CARLA_ASSERT(fClient == nullptr);

  627. 

  628. #ifndef BUILD_BRIDGE

  629.         fUsedGroupNames.clear();

  630.         fUsedPortNames.clear();

  631.         fUsedConnections.clear();

  632.         fPluginClientNames.clear();

  633. #endif

  634.     }

  635. 

  636.     // -------------------------------------------------------------------

  637.     // Maximum values

  638. 

  639.     unsigned int maxClientNameSize() const override

  640.     {

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

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

  643. 

  644.         return CarlaEngine::maxClientNameSize();

  645.     }

  646. 

  647.     unsigned int maxPortNameSize() const override

  648.     {

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

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

  651. 

  652.         return CarlaEngine::maxPortNameSize();

  653.     }

  654. 

  655.     // -------------------------------------------------------------------

  656.     // Virtual, per-engine type calls

  657. 

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

  659.     {

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

  661. 

  662.         fFreewheel      = false;

  663.         fTransportState = JackTransportStopped;

  664. 

  665.         carla_zeroStruct<jack_position_t>(fTransportPos);

  666. 

  667. #ifndef BUILD_BRIDGE

  668.         fLastGroupId = 0;

  669.         fLastPortId  = 0;

  670.         fLastConnectionId = 0;

  671. 

  672.         fUsedGroupNames.clear();

  673.         fUsedPortNames.clear();

  674.         fUsedConnections.clear();

  675.         fPluginClientNames.clear();

  676. 

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

  678. 

  679.         if (fClient != nullptr)

  680.         {

  681.             fBufferSize = jackbridge_get_buffer_size(fClient);

  682.             fSampleRate = jackbridge_get_sample_rate(fClient);

  683. 

  684.             jackbridge_set_buffer_size_callback(fClient, carla_jack_bufsize_callback, this);

  685.             jackbridge_set_sample_rate_callback(fClient, carla_jack_srate_callback, this);

  686.             jackbridge_set_freewheel_callback(fClient, carla_jack_freewheel_callback, this);

  687.             jackbridge_set_process_callback(fClient, carla_jack_process_callback, this);

  688.             jackbridge_on_shutdown(fClient, carla_jack_shutdown_callback, this);

  689. # if 0

  690.             jackbridge_set_latency_callback(fClient, carla_jack_latency_callback, this);

  691. # endif

  692. 

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

  694. 

  695.             initJackPatchbay(jackClientName);

  696. 

  697.             jackbridge_set_client_registration_callback(fClient, carla_jack_client_registration_callback, this);

  698.             jackbridge_set_port_registration_callback(fClient, carla_jack_port_registration_callback, this);

  699.             jackbridge_set_port_connect_callback(fClient, carla_jack_port_connect_callback, this);

  700.             jackbridge_set_port_rename_callback(fClient, carla_jack_port_rename_callback, this);

  701. 

  702.             if (fOptions.processMode == PROCESS_MODE_CONTINUOUS_RACK)

  703.             {

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

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

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

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

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

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

  710.             }

  711. 

  712.             if (jackbridge_activate(fClient))

  713.             {

  714.                 return CarlaEngine::init(jackClientName);

  715.             }

  716.             else

  717.             {

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

  719.                 jackbridge_client_close(fClient);

  720.                 fClient = nullptr;

  721.             }

  722.         }

  723.         else

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

  725. 

  726.         return false;

  727. #else

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

  729.         {

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

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

  732.             {

  733.                 fBufferSize = jackbridge_get_buffer_size(tmpClient);

  734.                 fSampleRate = jackbridge_get_sample_rate(tmpClient);

  735. 

  736.                 jackbridge_client_close(tmpClient);

  737.             }

  738.         }

  739. 

  740.         return CarlaEngine::init(clientName);

  741. #endif

  742.     }

  743. 

  744.     bool close() override

  745.     {

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

  747.         CarlaEngine::close();

  748. 

  749. #ifdef BUILD_BRIDGE

  750.         fClient  = nullptr;

  751.         fHasQuit = true;

  752.         return true;

  753. #else

  754.         if (jackbridge_deactivate(fClient))

  755.         {

  756.             if (fOptions.processMode == PROCESS_MODE_CONTINUOUS_RACK)

  757.             {

  758.                 jackbridge_port_unregister(fClient, fRackPorts[rackPortAudioIn1]);

  759.                 jackbridge_port_unregister(fClient, fRackPorts[rackPortAudioIn2]);

  760.                 jackbridge_port_unregister(fClient, fRackPorts[rackPortAudioOut1]);

  761.                 jackbridge_port_unregister(fClient, fRackPorts[rackPortAudioOut2]);

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

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

  764.             }

  765. 

  766.             if (jackbridge_client_close(fClient))

  767.             {

  768.                 fClient = nullptr;

  769.                 return true;

  770.             }

  771.             else

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

  773.         }

  774.         else

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

  776. 

  777.         fClient = nullptr;

  778. 

  779.         fUsedGroupNames.clear();

  780.         fUsedPortNames.clear();

  781.         fUsedConnections.clear();

  782.         fPluginClientNames.clear();

  783. #endif

  784.         return false;

  785.     }

  786. 

  787.     bool isRunning() const override

  788.     {

  789. #ifdef BUILD_BRIDGE

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

  791. #else

  792.         return (fClient != nullptr);

  793. #endif

  794.     }

  795. 

  796.     bool isOffline() const override

  797.     {

  798.         return fFreewheel;

  799.     }

  800. 

  801.     EngineType type() const override

  802.     {

  803.         return kEngineTypeJack;

  804.     }

  805. 

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

  807.     {

  808.         jack_client_t* client = nullptr;

  809. 

  810. #ifdef BUILD_BRIDGE

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

  812. 

  813.         fBufferSize = jackbridge_get_buffer_size(client);

  814.         fSampleRate = jackbridge_get_sample_rate(client);

  815. 

  816.         jackbridge_set_buffer_size_callback(client, carla_jack_bufsize_callback, this);

  817.         jackbridge_set_sample_rate_callback(client, carla_jack_srate_callback, this);

  818.         jackbridge_set_freewheel_callback(client, carla_jack_freewheel_callback, this);

  819.         jackbridge_set_process_callback(client, carla_jack_process_callback, this);

  820.         jackbridge_on_shutdown(client, carla_jack_shutdown_callback, this);

  821. # if 0

  822.         jackbridge_set_latency_callback(client, carla_jack_latency_callback, this);

  823. # endif

  824. #else

  825.         if (fOptions.processMode == PROCESS_MODE_SINGLE_CLIENT)

  826.         {

  827.             client = fClient;

  828.         }

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

  830.         {

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

  832.             jackbridge_set_process_callback(client, carla_jack_process_callback_plugin, plugin);

  833. # if 0

  834.             jackbridge_set_latency_callback(client, carla_jack_latency_callback_plugin, plugin);

  835. # endif

  836.             CARLA_ASSERT(client != nullptr);

  837. 

  838.             if (client == nullptr)

  839.                 return nullptr;

  840. 

  841.             fPluginClientNames.append(QString(jackbridge_get_client_name(client)));

  842.         }

  843. #endif

  844. 

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

  846.     }

  847. 

  848. #ifndef BUILD_BRIDGE

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

  850.     {

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

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

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

  854.         CARLA_ASSERT(newName != nullptr);

  855. 

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

  857.         {

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

  859.             return nullptr;

  860.         }

  861. 

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

  863. 

  864.         if (plugin == nullptr)

  865.         {

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

  867.             return nullptr;

  868.         }

  869. 

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

  871. 

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

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

  874. 

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

  876. 

  877.         // JACK client rename

  878.         if (fOptions.processMode == PROCESS_MODE_MULTIPLE_CLIENTS)

  879.         {

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

  881. 

  882.             if (bridge.client_rename_ptr != nullptr)

  883.             {

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

  885.             }

  886.             else

  887.             {

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

  889.                 needsReinit = true;

  890. 

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

  892.                 {

  893.                     // close old client

  894.                     plugin->setEnabled(false);

  895. 

  896.                     if (client->isActive())

  897.                         client->deactivate();

  898. 

  899.                     plugin->clearBuffers();

  900. 

  901.                     jackbridge_client_close(client->kClient);

  902. 

  903.                     // set new client data

  904.                     name = jackbridge_get_client_name(jclient);

  905. 

  906.                     jackbridge_set_process_callback(jclient, carla_jack_process_callback_plugin, plugin);

  907. # if 0

  908.                     jackbridge_set_latency_callback(jclient, carla_jack_latency_callback_plugin, plugin);

  909. # endif

  910. 

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

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

  913.                 }

  914.             }

  915.         }

  916. 

  917.         if (name == nullptr)

  918.             return nullptr;

  919. 

  920.         // Rename

  921.         plugin->setName(name);

  922. 

  923.         if (needsReinit)

  924.         {

  925.             // reload plugin to recreate its ports

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

  927.             plugin->reload();

  928.             plugin->loadSaveState(saveState);

  929.         }

  930. 

  931.         return name;

  932.     }

  933. 

  934.     // -------------------------------------------------------------------

  935.     // Patchbay

  936. 

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

  938.     {

  939.         CARLA_ASSERT(fClient != nullptr);

  940. 

  941.         if (fClient == nullptr)

  942.         {

  943.             setLastError("Invalid JACK client");

  944.             return false;

  945.         }

  946. 

  947.         const char* const portNameA(getFullPortName(portA).toUtf8().constData());

  948.         const char* const portNameB(getFullPortName(portB).toUtf8().constData());

  949. 

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

  951.         {

  952.             setLastError("JACK operation failed");

  953.             return false;

  954.         }

  955. 

  956.         return true;

  957.     }

  958. 

  959.     bool patchbayDisconnect(int connectionId) override

  960.     {

  961.         CARLA_ASSERT(fClient != nullptr);

  962. 

  963.         if (fClient == nullptr)

  964.         {

  965.             setLastError("Invalid JACK client");

  966.             return false;

  967.         }

  968. 

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

  970.         {

  971.             if (fUsedConnections[i].id == connectionId)

  972.             {

  973.                 const char* const portNameA(getFullPortName(fUsedConnections[i].portOut).toUtf8().constData());

  974.                 const char* const portNameB(getFullPortName(fUsedConnections[i].portIn).toUtf8().constData());

  975. 

  976.                 if (! jackbridge_disconnect(fClient, portNameA, portNameB))

  977.                 {

  978.                     setLastError("JACK operation failed");

  979.                     return false;

  980.                 }

  981. 

  982.                 return true;

  983.             }

  984.         }

  985. 

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

  987.         return false;

  988.     }

  989. 

  990.     void patchbayRefresh() override

  991.     {

  992.         CARLA_ASSERT(fClient != nullptr);

  993. 

  994.         if (fClient == nullptr)

  995.             return;

  996. 

  997.         fLastGroupId = 0;

  998.         fLastPortId  = 0;

  999.         fLastConnectionId = 0;

  1000. 

  1001.         fUsedGroupNames.clear();

  1002.         fUsedPortNames.clear();

  1003.         fUsedConnections.clear();

  1004. 

  1005.         initJackPatchbay(jackbridge_get_client_name(fClient));

  1006.     }

  1007. #endif

  1008. 

  1009.     // -------------------------------------------------------------------

  1010.     // Transport

  1011. 

  1012.     void transportPlay() override

  1013.     {

  1014.         if (fOptions.transportMode == TRANSPORT_MODE_INTERNAL)

  1015.             CarlaEngine::transportPlay();

  1016.         else if (fClient != nullptr)

  1017.             jackbridge_transport_start(fClient);

  1018.     }

  1019. 

  1020.     void transportPause() override

  1021.     {

  1022.         if (fOptions.transportMode == TRANSPORT_MODE_INTERNAL)

  1023.             CarlaEngine::transportPause();

  1024.         else if (fClient != nullptr)

  1025.             jackbridge_transport_stop(fClient);

  1026.     }

  1027. 

  1028.     void transportRelocate(const uint32_t frame) override

  1029.     {

  1030.         if (fOptions.transportMode == TRANSPORT_MODE_INTERNAL)

  1031.             CarlaEngine::transportRelocate(frame);

  1032.         else if (fClient != nullptr)

  1033.             jackbridge_transport_locate(fClient, frame);

  1034.     }

  1035. 

  1036.     // -------------------------------------

  1037. 

  1038. protected:

  1039.     void handleJackBufferSizeCallback(const uint32_t newBufferSize)

  1040.     {

  1041.         if (fBufferSize == newBufferSize)

  1042.             return;

  1043. 

  1044.         fBufferSize = newBufferSize;

  1045.         bufferSizeChanged(newBufferSize);

  1046.     }

  1047. 

  1048.     void handleJackSampleRateCallback(const double newSampleRate)

  1049.     {

  1050.         if (fSampleRate == newSampleRate)

  1051.             return;

  1052. 

  1053.         fSampleRate = newSampleRate;

  1054.         sampleRateChanged(newSampleRate);

  1055.     }

  1056. 

  1057.     void handleJackFreewheelCallback(const bool isFreewheel)

  1058.     {

  1059.         fFreewheel = isFreewheel;

  1060.     }

  1061. 

  1062.     void saveTransportInfo()

  1063.     {

  1064.         if (fOptions.transportMode != TRANSPORT_MODE_JACK)

  1065.             return;

  1066. 

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

  1068. 

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

  1070. 

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

  1072. 

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

  1074.         {

  1075.             fTimeInfo.frame = fTransportPos.frame;

  1076.             fTimeInfo.usecs = fTransportPos.usecs;

  1077. 

  1078.             if (fTransportPos.valid & JackPositionBBT)

  1079.             {

  1080.                 fTimeInfo.valid              = EngineTimeInfo::ValidBBT;

  1081.                 fTimeInfo.bbt.bar            = fTransportPos.bar;

  1082.                 fTimeInfo.bbt.beat           = fTransportPos.beat;

  1083.                 fTimeInfo.bbt.tick           = fTransportPos.tick;

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

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

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

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

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

  1089.             }

  1090.             else

  1091.                 fTimeInfo.valid = 0x0;

  1092.         }

  1093.         else

  1094.         {

  1095.             fTimeInfo.frame = 0;

  1096.             fTimeInfo.valid = 0x0;

  1097.         }

  1098.     }

  1099. 

  1100.     void handleJackProcessCallback(const uint32_t nframes)

  1101.     {

  1102.         saveTransportInfo();

  1103. 

  1104. #ifndef BUILD_BRIDGE

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

  1106.         {

  1107.             // pass-through

  1108.             if (fOptions.processMode == PROCESS_MODE_CONTINUOUS_RACK)

  1109.             {

  1110.                 float* const audioIn1  = (float*)jackbridge_port_get_buffer(fRackPorts[rackPortAudioIn1], nframes);

  1111.                 float* const audioIn2  = (float*)jackbridge_port_get_buffer(fRackPorts[rackPortAudioIn2], nframes);

  1112.                 float* const audioOut1 = (float*)jackbridge_port_get_buffer(fRackPorts[rackPortAudioOut1], nframes);

  1113.                 float* const audioOut2 = (float*)jackbridge_port_get_buffer(fRackPorts[rackPortAudioOut2], nframes);

  1114.                 void*  const eventOut  = jackbridge_port_get_buffer(fRackPorts[rackPortEventOut], nframes);

  1115. 

  1116.                 CARLA_ASSERT(audioIn1 != nullptr);

  1117.                 CARLA_ASSERT(audioIn2 != nullptr);

  1118.                 CARLA_ASSERT(audioOut1 != nullptr);

  1119.                 CARLA_ASSERT(audioOut2 != nullptr);

  1120.                 CARLA_ASSERT(eventOut != nullptr);

  1121. 

  1122.                 carla_copyFloat(audioOut1, audioIn1, nframes);

  1123.                 carla_copyFloat(audioOut2, audioIn2, nframes);

  1124.                 jackbridge_midi_clear_buffer(eventOut);

  1125.             }

  1126. 

  1127.             return proccessPendingEvents();

  1128.         }

  1129. #endif

  1130. 

  1131. #ifdef BUILD_BRIDGE

  1132.         CarlaPlugin* const plugin(getPluginUnchecked(0));

  1133. 

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

  1135.         {

  1136.             plugin->initBuffers();

  1137.             processPlugin(plugin, nframes);

  1138.             plugin->unlock();

  1139.         }

  1140. #else

  1141.         if (fOptions.processMode == PROCESS_MODE_SINGLE_CLIENT)

  1142.         {

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

  1144.             {

  1145.                 CarlaPlugin* const plugin(getPluginUnchecked(i));

  1146. 

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

  1148.                 {

  1149.                     plugin->initBuffers();

  1150.                     processPlugin(plugin, nframes);

  1151.                     plugin->unlock();

  1152.                 }

  1153.             }

  1154.         }

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

  1156.         {

  1157.             // get buffers from jack

  1158.             float* const audioIn1  = (float*)jackbridge_port_get_buffer(fRackPorts[rackPortAudioIn1], nframes);

  1159.             float* const audioIn2  = (float*)jackbridge_port_get_buffer(fRackPorts[rackPortAudioIn2], nframes);

  1160.             float* const audioOut1 = (float*)jackbridge_port_get_buffer(fRackPorts[rackPortAudioOut1], nframes);

  1161.             float* const audioOut2 = (float*)jackbridge_port_get_buffer(fRackPorts[rackPortAudioOut2], nframes);

  1162.             void* const  eventIn   = jackbridge_port_get_buffer(fRackPorts[rackPortEventIn],  nframes);

  1163.             void* const  eventOut  = jackbridge_port_get_buffer(fRackPorts[rackPortEventOut], nframes);

  1164. 

  1165.             // assert buffers

  1166.             CARLA_ASSERT(audioIn1 != nullptr);

  1167.             CARLA_ASSERT(audioIn2 != nullptr);

  1168.             CARLA_ASSERT(audioOut1 != nullptr);

  1169.             CARLA_ASSERT(audioOut2 != nullptr);

  1170.             CARLA_ASSERT(eventIn != nullptr);

  1171.             CARLA_ASSERT(eventOut != nullptr);

  1172. 

  1173.             // create audio buffers

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

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

  1176. 

  1177.             // initialize input events

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

  1179.             {

  1180.                 uint32_t engineEventIndex = 0;

  1181. 

  1182.                 jack_midi_event_t jackEvent;

  1183.                 const uint32_t jackEventCount = jackbridge_midi_get_event_count(eventIn);

  1184. 

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

  1186.                 {

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

  1188.                         continue;

  1189. 

  1190.                     EngineEvent* const engineEvent = &kData->bufEvents.in[engineEventIndex++];

  1191.                     engineEvent->clear();

  1192. 

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

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

  1195. 

  1196.                     engineEvent->time    = jackEvent.time;

  1197.                     engineEvent->channel = midiChannel;

  1198. 

  1199.                     if (MIDI_IS_STATUS_CONTROL_CHANGE(midiStatus))

  1200.                     {

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

  1202.                         engineEvent->type         = kEngineEventTypeControl;

  1203. 

  1204.                         if (MIDI_IS_CONTROL_BANK_SELECT(midiControl))

  1205.                         {

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

  1207. 

  1208.                             engineEvent->ctrl.type  = kEngineControlEventTypeMidiBank;

  1209.                             engineEvent->ctrl.param = midiBank;

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

  1211.                         }

  1212.                         else if (midiControl == MIDI_CONTROL_ALL_SOUND_OFF)

  1213.                         {

  1214.                             engineEvent->ctrl.type  = kEngineControlEventTypeAllSoundOff;

  1215.                             engineEvent->ctrl.param = 0;

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

  1217.                         }

  1218.                         else if (midiControl == MIDI_CONTROL_ALL_NOTES_OFF)

  1219.                         {

  1220.                             engineEvent->ctrl.type  = kEngineControlEventTypeAllNotesOff;

  1221.                             engineEvent->ctrl.param = 0;

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

  1223.                         }

  1224.                         else

  1225.                         {

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

  1227. 

  1228.                             engineEvent->ctrl.type  = kEngineControlEventTypeParameter;

  1229.                             engineEvent->ctrl.param = midiControl;

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

  1231.                         }

  1232.                     }

  1233.                     else if (MIDI_IS_STATUS_PROGRAM_CHANGE(midiStatus))

  1234.                     {

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

  1236.                         engineEvent->type         = kEngineEventTypeControl;

  1237. 

  1238.                         engineEvent->ctrl.type  = kEngineControlEventTypeMidiProgram;

  1239.                         engineEvent->ctrl.param = midiProgram;

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

  1241.                     }

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

  1243.                     {

  1244.                         engineEvent->type = kEngineEventTypeMidi;

  1245. 

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

  1247. 

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

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

  1250.                     }

  1251. 

  1252.                     if (engineEventIndex >= INTERNAL_EVENT_COUNT)

  1253.                         break;

  1254.                 }

  1255.             }

  1256. 

  1257.             // process rack

  1258.             processRack(inBuf, outBuf, nframes);

  1259. 

  1260.             // output control

  1261.             {

  1262.                 jackbridge_midi_clear_buffer(eventOut);

  1263. 

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

  1265.                 {

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

  1267. 

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

  1269.                     uint8_t size    = 0;

  1270. 

  1271.                     switch (engineEvent->type)

  1272.                     {

  1273.                     case kEngineEventTypeNull:

  1274.                         break;

  1275. 

  1276.                     case kEngineEventTypeControl:

  1277.                     {

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

  1279. 

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

  1281.                         {

  1282.                             // FIXME?

  1283.                             ctrlEvent->type  = kEngineControlEventTypeMidiBank;

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

  1285.                             ctrlEvent->value = 0.0f;

  1286.                         }

  1287. 

  1288.                         switch (ctrlEvent->type)

  1289.                         {

  1290.                         case kEngineControlEventTypeNull:

  1291.                             break;

  1292.                         case kEngineControlEventTypeParameter:

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

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

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

  1296.                             size    = 3;

  1297.                             break;

  1298.                         case kEngineControlEventTypeMidiBank:

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

  1300.                             data[1] = MIDI_CONTROL_BANK_SELECT;

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

  1302.                             size    = 3;

  1303.                             break;

  1304.                         case kEngineControlEventTypeMidiProgram:

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

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

  1307.                             size    = 2;

  1308.                             break;

  1309.                         case kEngineControlEventTypeAllSoundOff:

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

  1311.                             data[1] = MIDI_CONTROL_ALL_SOUND_OFF;

  1312.                             size    = 2;

  1313.                             break;

  1314.                         case kEngineControlEventTypeAllNotesOff:

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

  1316.                             data[1] = MIDI_CONTROL_ALL_NOTES_OFF;

  1317.                             size    = 2;

  1318.                             break;

  1319.                         }

  1320.                         break;

  1321.                     }

  1322. 

  1323.                     case kEngineEventTypeMidi:

  1324.                     {

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

  1326. 

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

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

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

  1330.                         size    = midiEvent->size;

  1331.                         break;

  1332.                     }

  1333.                     }

  1334. 

  1335.                     if (size > 0)

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

  1337.                 }

  1338.             }

  1339.         }

  1340. #endif // ! BUILD_BRIDGE

  1341. 

  1342.         proccessPendingEvents();

  1343.     }

  1344. 

  1345. #if 0

  1346.     void handleJackLatencyCallback(const jack_latency_callback_mode_t mode)

  1347.     {

  1348.         if (fOptions.processMode != PROCESS_MODE_SINGLE_CLIENT)

  1349.             return;

  1350. 

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

  1352.         {

  1353.             CarlaPlugin* const plugin = getPluginUnchecked(i);

  1354. 

  1355.             if (plugin && plugin->enabled())

  1356.                 latencyPlugin(plugin, mode);

  1357.         }

  1358.     }

  1359. #endif

  1360. 

  1361. #ifndef BUILD_BRIDGE

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

  1363.     {

  1364.         if (reg)

  1365.         {

  1366.             GroupNameToId groupNameToId;

  1367.             groupNameToId.id   = fLastGroupId;

  1368.             groupNameToId.name = name;

  1369. 

  1370.             PatchbayIconType groupIcon = PATCHBAY_ICON_APPLICATION;

  1371. 

  1372.             if (fPluginClientNames.contains(QString(name)))

  1373.             {

  1374.                 // TODO - identify distrho or file icon

  1375.                 groupIcon = PATCHBAY_ICON_PLUGIN;

  1376.             }

  1377. 

  1378.             callback(CALLBACK_PATCHBAY_CLIENT_ADDED, groupIcon, fLastGroupId, 0, 0.0f, name);

  1379.             fUsedGroupNames.append(groupNameToId);

  1380.             fLastGroupId++;

  1381.         }

  1382.         else

  1383.         {

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

  1385.             {

  1386.                 if (fUsedGroupNames[i].name == name)

  1387.                 {

  1388.                     callback(CALLBACK_PATCHBAY_CLIENT_REMOVED, 0, fUsedGroupNames[i].id, 0, 0.0f, nullptr);

  1389.                     fUsedGroupNames.takeAt(i);

  1390.                     break;

  1391.                 }

  1392.             }

  1393.         }

  1394.     }

  1395. 

  1396.     void handleJackPortRegistrationCallback(jack_port_id_t port, bool reg)

  1397.     {

  1398.         jack_port_t* jackPort = jackbridge_port_by_id(fClient, port);

  1399. 

  1400.         QString fullName(jackbridge_port_name(jackPort));

  1401.         QString groupName = fullName.split(":").at(0);

  1402.         int     groupId   = getGroupId(groupName);

  1403. 

  1404.         const char* portName = jackbridge_port_short_name(jackPort);

  1405. 

  1406.         if (reg)

  1407.         {

  1408.             bool portIsInput = (jackbridge_port_flags(jackPort) & JackPortIsInput);

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

  1410. 

  1411.             unsigned int portFlags = 0x0;

  1412.             portFlags |= portIsInput ? PATCHBAY_PORT_IS_INPUT : PATCHBAY_PORT_IS_OUTPUT;

  1413.             portFlags |= portIsAudio ? PATCHBAY_PORT_IS_AUDIO : PATCHBAY_PORT_IS_MIDI;

  1414. 

  1415.             PortNameToId portNameToId;

  1416.             portNameToId.groupId  = groupId;

  1417.             portNameToId.portId   = fLastPortId;

  1418.             portNameToId.name     = portName;

  1419.             portNameToId.fullName = fullName;

  1420. 

  1421.             fUsedPortNames.append(portNameToId);

  1422.             callback(CALLBACK_PATCHBAY_PORT_ADDED, 0, groupId, fLastPortId, portFlags, portName);

  1423.             fLastPortId++;

  1424.         }

  1425.         else

  1426.         {

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

  1428.             {

  1429.                 if (fUsedPortNames[i].groupId == groupId && fUsedPortNames[i].name == portName)

  1430.                 {

  1431.                     callback(CALLBACK_PATCHBAY_PORT_REMOVED, 0, fUsedPortNames[i].portId, 0, 0.0f, nullptr);

  1432.                     fUsedPortNames.takeAt(i);

  1433.                     break;

  1434.                 }

  1435.             }

  1436.         }

  1437.     }

  1438. 

  1439.     void handleJackPortConnectCallback(jack_port_id_t a, jack_port_id_t b, bool connect)

  1440.     {

  1441.         jack_port_t* jackPortA = jackbridge_port_by_id(fClient, a);

  1442.         jack_port_t* jackPortB = jackbridge_port_by_id(fClient, b);

  1443. 

  1444.         int portIdA = getPortId(QString(jackbridge_port_name(jackPortA)));

  1445.         int portIdB = getPortId(QString(jackbridge_port_name(jackPortB)));

  1446. 

  1447.         if (connect)

  1448.         {

  1449.             ConnectionToId connectionToId;

  1450.             connectionToId.id      = fLastConnectionId;

  1451.             connectionToId.portOut = portIdA;

  1452.             connectionToId.portIn  = portIdB;

  1453. 

  1454.             fUsedConnections.append(connectionToId);

  1455.             callback(CALLBACK_PATCHBAY_CONNECTION_ADDED, 0, fLastConnectionId, portIdA, portIdB, nullptr);

  1456.             fLastConnectionId++;

  1457.         }

  1458.         else

  1459.         {

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

  1461.             {

  1462.                 if (fUsedConnections[i].portOut == portIdA && fUsedConnections[i].portIn == portIdB)

  1463.                 {

  1464.                     callback(CALLBACK_PATCHBAY_CONNECTION_REMOVED, 0, fUsedConnections[i].id, 0, 0.0f, nullptr);

  1465.                     fUsedConnections.takeAt(i);

  1466.                     break;

  1467.                 }

  1468.             }

  1469.         }

  1470.     }

  1471. 

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

  1473.     {

  1474.         jack_port_t* jackPort = jackbridge_port_by_id(fClient, port);

  1475. 

  1476.         QString fullName(oldName);

  1477.         QString groupName = fullName.split(":").at(0);

  1478.         int     groupId   = getGroupId(groupName);

  1479. 

  1480.         const char* portName = jackbridge_port_short_name(jackPort);

  1481. 

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

  1483.         {

  1484.             if (fUsedPortNames[i].groupId == groupId && fUsedPortNames[i].name == portName)

  1485.             {

  1486.                 callback(CALLBACK_PATCHBAY_PORT_RENAMED, 0, fUsedPortNames[i].portId, 0, 0.0f, newName);

  1487.                 fUsedPortNames[i].name = newName;

  1488.                 break;

  1489.             }

  1490.         }

  1491.     }

  1492. #endif

  1493. 

  1494.     void handleJackShutdownCallback()

  1495.     {

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

  1497.         {

  1498.             //CarlaPlugin* const plugin = getPluginUnchecked(i);

  1499. 

  1500.             //if (plugin)

  1501.             //    plugin->x_client = nullptr;

  1502.         }

  1503. 

  1504.         fClient = nullptr;

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

  1506.     }

  1507. 

  1508.     // -------------------------------------

  1509. 

  1510. private:

  1511.     jack_client_t*         fClient;

  1512.     jack_position_t        fTransportPos;

  1513.     jack_transport_state_t fTransportState;

  1514.     bool fFreewheel;

  1515. 

  1516.     // -------------------------------------

  1517. 

  1518. #ifdef BUILD_BRIDGE

  1519.     bool fHasQuit;

  1520. #else

  1521.     enum RackPorts {

  1522.         rackPortAudioIn1  = 0,

  1523.         rackPortAudioIn2  = 1,

  1524.         rackPortAudioOut1 = 2,

  1525.         rackPortAudioOut2 = 3,

  1526.         rackPortEventIn   = 4,

  1527.         rackPortEventOut  = 5,

  1528.         rackPortCount     = 8

  1529.     };

  1530. 

  1531.     jack_port_t* fRackPorts[rackPortCount];

  1532. 

  1533.     struct GroupNameToId {

  1534.         int id;

  1535.         QString name;

  1536.     };

  1537. 

  1538.     struct PortNameToId {

  1539.         int groupId;

  1540.         int portId;

  1541.         QString name;

  1542.         QString fullName;

  1543.     };

  1544. 

  1545.     struct ConnectionToId {

  1546.         int id;

  1547.         int portOut;

  1548.         int portIn;

  1549.     };

  1550. 

  1551.     int fLastGroupId;

  1552.     int fLastPortId;

  1553.     int fLastConnectionId;

  1554. 

  1555.     QList<GroupNameToId>  fUsedGroupNames;

  1556.     QList<PortNameToId>   fUsedPortNames;

  1557.     QList<ConnectionToId> fUsedConnections;

  1558. 

  1559.     QStringList fPluginClientNames;

  1560. 

  1561.     int getGroupId(QString groupName)

  1562.     {

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

  1564.         {

  1565.             if (fUsedGroupNames[i].name == groupName)

  1566.             {

  1567.                 return fUsedGroupNames[i].id;

  1568.             }

  1569.         }

  1570.         return -1;

  1571.     }

  1572. 

  1573.     int getPortId(QString fullPortName)

  1574.     {

  1575.         QString groupName = fullPortName.split(":").at(0);

  1576.         QString portName  = fullPortName.replace(groupName+":", "");

  1577. 

  1578.         int groupId = getGroupId(groupName);

  1579. 

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

  1581.         {

  1582.             if (fUsedPortNames[i].groupId == groupId && fUsedPortNames[i].name == portName)

  1583.             {

  1584.                 return fUsedPortNames[i].portId;

  1585.             }

  1586.         }

  1587. 

  1588.         return -1;

  1589.     }

  1590. 

  1591.     QString& getFullPortName(int portId)

  1592.     {

  1593.         static QString fallbackString;

  1594. 

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

  1596.         {

  1597.             if (fUsedPortNames[i].portId == portId)

  1598.             {

  1599.                 return fUsedPortNames[i].fullName;

  1600.             }

  1601.         }

  1602. 

  1603.         return fallbackString;

  1604.     }

  1605. 

  1606.     void initJackPatchbay(const char* const ourName)

  1607.     {

  1608.         // query initial jack ports

  1609.         QList<QString> parsedGroups;

  1610. 

  1611.         // our client

  1612.         {

  1613.             GroupNameToId groupNameToId;

  1614.             groupNameToId.id   = fLastGroupId;

  1615.             groupNameToId.name = ourName;

  1616. 

  1617.             callback(CALLBACK_PATCHBAY_CLIENT_ADDED, 0, fLastGroupId, 0, 0.0f, ourName);

  1618.             fUsedGroupNames.append(groupNameToId);

  1619.             fLastGroupId++;

  1620. 

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

  1622.         }

  1623. 

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

  1625.         {

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

  1627.             {

  1628.                 jack_port_t* jackPort = jackbridge_port_by_name(fClient, ports[i]);

  1629.                 const char* portName  = jackbridge_port_short_name(jackPort);

  1630. 

  1631.                 QString fullName(ports[i]);

  1632.                 QString groupName(fullName.split(":").at(0));

  1633.                 int     groupId   = -1;

  1634.                 int jackPortFlags = jackbridge_port_flags(jackPort);

  1635. 

  1636.                 //if (groupName == ourName)

  1637.                 //    continue;

  1638. 

  1639.                 if (parsedGroups.contains(groupName))

  1640.                 {

  1641.                     groupId = getGroupId(groupName);

  1642.                 }

  1643.                 else

  1644.                 {

  1645.                     groupId = fLastGroupId++;

  1646. 

  1647.                     GroupNameToId groupNameToId;

  1648.                     groupNameToId.id   = groupId;

  1649.                     groupNameToId.name = groupName;

  1650. 

  1651.                     fUsedGroupNames.append(groupNameToId);

  1652.                     parsedGroups.append(groupName);

  1653. 

  1654.                     PatchbayIconType groupIcon = PATCHBAY_ICON_APPLICATION;

  1655. 

  1656.                     if (fPluginClientNames.contains(groupName))

  1657.                     {

  1658.                         // TODO - identify distrho or file icon

  1659.                         groupIcon = PATCHBAY_ICON_PLUGIN;

  1660.                     }

  1661.                     else if (jackPortFlags & JackPortIsPhysical)

  1662.                         groupIcon = PATCHBAY_ICON_HARDWARE;

  1663. 

  1664.                     callback(CALLBACK_PATCHBAY_CLIENT_ADDED, 0, groupId, groupIcon, 0.0f, groupName.toUtf8().constData());

  1665.                 }

  1666. 

  1667.                 bool portIsInput = (jackPortFlags & JackPortIsInput);

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

  1669. 

  1670.                 unsigned int portFlags = 0x0;

  1671.                 portFlags |= portIsInput ? PATCHBAY_PORT_IS_INPUT : PATCHBAY_PORT_IS_OUTPUT;

  1672.                 portFlags |= portIsAudio ? PATCHBAY_PORT_IS_AUDIO : PATCHBAY_PORT_IS_MIDI;

  1673. 

  1674.                 PortNameToId portNameToId;

  1675.                 portNameToId.groupId  = groupId;

  1676.                 portNameToId.portId   = fLastPortId;

  1677.                 portNameToId.name     = portName;

  1678.                 portNameToId.fullName = fullName;

  1679. 

  1680.                 fUsedPortNames.append(portNameToId);

  1681.                 callback(CALLBACK_PATCHBAY_PORT_ADDED, 0, groupId, fLastPortId, portFlags, portName);

  1682.                 fLastPortId++;

  1683.             }

  1684. 

  1685.             jackbridge_free(ports);

  1686.         }

  1687. 

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

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

  1690.         {

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

  1692.             {

  1693.                 jack_port_t* jackPort = jackbridge_port_by_name(fClient, ports[i]);

  1694. 

  1695.                 int thisPortId = getPortId(QString(ports[i]));

  1696. 

  1697.                 if (const char** jackConnections = jackbridge_port_get_connections(jackPort))

  1698.                 {

  1699.                     for (int j=0; jackConnections[j] != nullptr; ++j)

  1700.                     {

  1701.                         int targetPortId = getPortId(QString(jackConnections[j]));

  1702. 

  1703.                         ConnectionToId connectionToId;

  1704.                         connectionToId.id      = fLastConnectionId;

  1705.                         connectionToId.portOut = thisPortId;

  1706.                         connectionToId.portIn  = targetPortId;

  1707. 

  1708.                         fUsedConnections.append(connectionToId);

  1709.                         callback(CALLBACK_PATCHBAY_CONNECTION_ADDED, 0, fLastConnectionId, thisPortId, targetPortId, nullptr);

  1710.                         fLastConnectionId++;

  1711.                     }

  1712. 

  1713.                     jackbridge_free(jackConnections);

  1714.                 }

  1715.             }

  1716. 

  1717.             jackbridge_free(ports);

  1718.         }

  1719.     }

  1720. #endif

  1721. 

  1722.     // -------------------------------------

  1723. 

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

  1725.     {

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

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

  1728. 

  1729.         float* inBuffer[inCount];

  1730.         float* outBuffer[outCount];

  1731. 

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

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

  1734. 

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

  1736.         {

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

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

  1739.         }

  1740. 

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

  1742.         {

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

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

  1745.         }

  1746. 

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

  1748.         {

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

  1750.             {

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

  1752. 

  1753.                 if (absV > inPeaks[i])

  1754.                     inPeaks[i] = absV;

  1755.             }

  1756.         }

  1757. 

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

  1759. 

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

  1761.         {

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

  1763.             {

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

  1765. 

  1766.                 if (absV > outPeaks[i])

  1767.                     outPeaks[i] = absV;

  1768.             }

  1769.         }

  1770. 

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

  1772.     }

  1773. 

  1774. #if 0

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

  1776.     {

  1777.         const uint32_t inCount  = plugin->audioInCount();

  1778.         const uint32_t outCount = plugin->audioOutCount();

  1779. 

  1780.         jack_latency_range_t range;

  1781.         uint32_t pluginLatency = plugin->latency();

  1782. 

  1783.         if (pluginLatency == 0)

  1784.             return;

  1785. 

  1786.         if (mode == JackCaptureLatency)

  1787.         {

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

  1789.             {

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

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

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

  1793. 

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

  1795.                 range.min += pluginLatency;

  1796.                 range.max += pluginLatency;

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

  1798.             }

  1799.         }

  1800.         else

  1801.         {

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

  1803.             {

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

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

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

  1807. 

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

  1809.                 range.min += pluginLatency;

  1810.                 range.max += pluginLatency;

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

  1812.             }

  1813.         }

  1814.     }

  1815. #endif

  1816. 

  1817.     // -------------------------------------

  1818. 

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

  1820. 

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

  1822.     {

  1823.         handlePtr->handleJackSampleRateCallback(newSampleRate);

  1824.         return 0;

  1825.     }

  1826. 

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

  1828.     {

  1829.         handlePtr->handleJackBufferSizeCallback(newBufferSize);

  1830.         return 0;

  1831.     }

  1832. 

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

  1834.     {

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

  1836.     }

  1837. 

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

  1839.     {

  1840.         handlePtr->handleJackProcessCallback(nframes);

  1841.         return 0;

  1842.     }

  1843. 

  1844. #if 0

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

  1846.     {

  1847.         handlePtr->handleJackLatencyCallback(mode);

  1848.     }

  1849. #endif

  1850. 

  1851. #ifndef BUILD_BRIDGE

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

  1853.     {

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

  1855.     }

  1856. 

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

  1858.     {

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

  1860.     }

  1861. 

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

  1863.     {

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

  1865.     }

  1866. 

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

  1868.     {

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

  1870.         return 0;

  1871.     }

  1872. #endif

  1873. 

  1874.     static void carla_jack_shutdown_callback(void* arg)

  1875.     {

  1876.         handlePtr->handleJackShutdownCallback();

  1877.     }

  1878. 

  1879.     #undef handlePtr

  1880. 

  1881.     // -------------------------------------

  1882. 

  1883. #ifndef BUILD_BRIDGE

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

  1885.     {

  1886.         CarlaPlugin* const plugin = (CarlaPlugin*)arg;

  1887. 

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

  1889.         {

  1890.             CarlaEngineJack* const engine = (CarlaEngineJack*)CarlaPluginGetEngine(plugin);

  1891. 

  1892.             plugin->initBuffers();

  1893.             engine->saveTransportInfo();

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

  1895.             plugin->unlock();

  1896.         }

  1897.         else

  1898.             carla_stdout("Plugin not enabled or locked");

  1899. 

  1900.         return 0;

  1901.     }

  1902. 

  1903. # if 0

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

  1905.     {

  1906.         CarlaPlugin* const plugin = (CarlaPlugin*)arg;

  1907. 

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

  1909.         {

  1910.             CarlaEngineJack* const engine = (CarlaEngineJack*)CarlaPluginGetEngine(plugin);

  1911. 

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

  1913.         }

  1914.     }

  1915. # endif

  1916. #endif

  1917. 

  1918.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaEngineJack)

  1919. };

  1920. 

  1921. // -----------------------------------------

  1922. 

  1923. CarlaEngine* CarlaEngine::newJack()

  1924. {

  1925.     return new CarlaEngineJack();

  1926. }

  1927. 

  1928. // -----------------------------------------

  1929. 

  1930. CARLA_BACKEND_END_NAMESPACE