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

2241 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(const uint32_t frames, const uint32_t timeOffset) override

  166.     {

  167.         CARLA_ASSERT(! kIsInput);

  168. 

  169.         if (kIsInput)

  170.             return;

  171. 

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

  173.         carla_copyFloat(jackBuffer+timeOffset, fBuffer, frames);

  174.     }

  175. 

  176. private:

  177.     jack_client_t* const kClient;

  178.     jack_port_t*   const kPort;

  179. 

  180.     friend class CarlaEngineJack;

  181. 

  182.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaEngineJackCVPort)

  183. };

  184. 

  185. // -------------------------------------------------------------------------------------------------------------------

  186. // Carla Engine JACK-Event port

  187. 

  188. class CarlaEngineJackEventPort : public CarlaEngineEventPort

  189. {

  190. public:

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

  192.         : CarlaEngineEventPort(isInput, processMode),

  193.           kClient(client),

  194.           kPort(port),

  195.           fJackBuffer(nullptr)

  196.     {

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

  198. 

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

  200.         {

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

  202.         }

  203.         else

  204.         {

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

  206.         }

  207.     }

  208. 

  209.     ~CarlaEngineJackEventPort() override

  210.     {

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

  212. 

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

  214.             jackbridge_port_unregister(kClient, kPort);

  215.     }

  216. 

  217.     void initBuffer(CarlaEngine* const engine) override

  218.     {

  219.         CARLA_ASSERT(engine != nullptr);

  220. 

  221.         if (engine == nullptr)

  222.             return;

  223. 

  224.         if (kPort == nullptr)

  225.             return CarlaEngineEventPort::initBuffer(engine);

  226. 

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

  228. 

  229.         if (! kIsInput)

  230.             jackbridge_midi_clear_buffer(fJackBuffer);

  231.     }

  232. 

  233.     uint32_t getEventCount() const override

  234.     {

  235.         if (kPort == nullptr)

  236.             return CarlaEngineEventPort::getEventCount();

  237. 

  238.         CARLA_ASSERT(kIsInput);

  239.         CARLA_ASSERT(fJackBuffer != nullptr);

  240. 

  241.         if (! kIsInput)

  242.             return 0;

  243.         if (fJackBuffer == nullptr)

  244.             return 0;

  245. 

  246.         return jackbridge_midi_get_event_count(fJackBuffer);

  247.     }

  248. 

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

  250.     {

  251.         if (kPort == nullptr)

  252.             return CarlaEngineEventPort::getEvent(index);

  253. 

  254.         CARLA_ASSERT(kIsInput);

  255.         CARLA_ASSERT(fJackBuffer != nullptr);

  256. 

  257.         if (! kIsInput)

  258.             return kFallbackJackEngineEvent;

  259.         if (fJackBuffer == nullptr)

  260.             return kFallbackJackEngineEvent;

  261. 

  262.         jack_midi_event_t jackEvent;

  263.         carla_zeroStruct<jack_midi_event_t>(jackEvent);

  264. 

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

  266.             return kFallbackJackEngineEvent;

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

  268.             return kFallbackJackEngineEvent;

  269. 

  270.         fRetEvent.clear();

  271. 

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

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

  274. 

  275.         fRetEvent.time    = jackEvent.time;

  276.         fRetEvent.channel = midiChannel;

  277. 

  278.         if (MIDI_IS_STATUS_CONTROL_CHANGE(midiStatus))

  279.         {

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

  281. 

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

  283.             fRetEvent.type            = kEngineEventTypeControl;

  284. 

  285.             if (MIDI_IS_CONTROL_BANK_SELECT(midiControl))

  286.             {

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

  288. 

  289.                 fRetEvent.ctrl.type  = kEngineControlEventTypeMidiBank;

  290.                 fRetEvent.ctrl.param = midiBank;

  291.                 fRetEvent.ctrl.value = 0.0f;

  292.             }

  293.             else if (midiControl == MIDI_CONTROL_ALL_SOUND_OFF)

  294.             {

  295.                 fRetEvent.ctrl.type  = kEngineControlEventTypeAllSoundOff;

  296.                 fRetEvent.ctrl.param = 0;

  297.                 fRetEvent.ctrl.value = 0.0f;

  298.             }

  299.             else if (midiControl == MIDI_CONTROL_ALL_NOTES_OFF)

  300.             {

  301.                 fRetEvent.ctrl.type  = kEngineControlEventTypeAllNotesOff;

  302.                 fRetEvent.ctrl.param = 0;

  303.                 fRetEvent.ctrl.value = 0.0f;

  304.             }

  305.             else

  306.             {

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

  308. 

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

  310. 

  311.                 fRetEvent.ctrl.type  = kEngineControlEventTypeParameter;

  312.                 fRetEvent.ctrl.param = midiControl;

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

  314.             }

  315.         }

  316.         else if (MIDI_IS_STATUS_PROGRAM_CHANGE(midiStatus))

  317.         {

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

  319. 

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

  321.             fRetEvent.type            = kEngineEventTypeControl;

  322. 

  323.             fRetEvent.ctrl.type  = kEngineControlEventTypeMidiProgram;

  324.             fRetEvent.ctrl.param = midiProgram;

  325.             fRetEvent.ctrl.value = 0.0f;

  326.         }

  327.         else

  328.         {

  329.             fRetEvent.type = kEngineEventTypeMidi;

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

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

  332. 

  333.             if (jackEvent.size > 1)

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

  335.         }

  336. 

  337.         return fRetEvent;

  338.     }

  339. 

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

  341.     {

  342.         if (kPort == nullptr)

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

  344. 

  345.         CARLA_ASSERT(! kIsInput);

  346.         CARLA_ASSERT(fJackBuffer != nullptr);

  347.         CARLA_ASSERT(type != kEngineControlEventTypeNull);

  348.         CARLA_ASSERT(channel < MAX_MIDI_CHANNELS);

  349.         CARLA_ASSERT(param < MAX_MIDI_VALUE);

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

  351. 

  352.         if (kIsInput)

  353.             return;

  354.         if (fJackBuffer == nullptr)

  355.             return;

  356.         if (type == kEngineControlEventTypeNull)

  357.             return;

  358.         if (channel >= MAX_MIDI_CHANNELS)

  359.             return;

  360.         if (param >= MAX_MIDI_VALUE)

  361.             return;

  362.         if (type == kEngineControlEventTypeParameter)

  363.         {

  364.             CARLA_ASSERT(! MIDI_IS_CONTROL_BANK_SELECT(param));

  365.         }

  366. 

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

  368. 

  369.         size_t size = 0;

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

  371. 

  372.         switch (type)

  373.         {

  374.         case kEngineControlEventTypeNull:

  375.             break;

  376.         case kEngineControlEventTypeParameter:

  377.             data[0] = MIDI_STATUS_CONTROL_CHANGE + channel;

  378.             data[1] = param;

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

  380.             size    = 3;

  381.             break;

  382.         case kEngineControlEventTypeMidiBank:

  383.             data[0] = MIDI_STATUS_CONTROL_CHANGE + channel;

  384.             data[1] = MIDI_CONTROL_BANK_SELECT;

  385.             data[2] = param;

  386.             size    = 3;

  387.             break;

  388.         case kEngineControlEventTypeMidiProgram:

  389.             data[0] = MIDI_STATUS_PROGRAM_CHANGE + channel;

  390.             data[1] = param;

  391.             size    = 2;

  392.             break;

  393.         case kEngineControlEventTypeAllSoundOff:

  394.             data[0] = MIDI_STATUS_CONTROL_CHANGE + channel;

  395.             data[1] = MIDI_CONTROL_ALL_SOUND_OFF;

  396.             data[2] = 0;

  397.             size    = 3;

  398.             break;

  399.         case kEngineControlEventTypeAllNotesOff:

  400.             data[0] = MIDI_STATUS_CONTROL_CHANGE + channel;

  401.             data[1] = MIDI_CONTROL_ALL_NOTES_OFF;

  402.             data[2] = 0;

  403.             size    = 3;

  404.             break;

  405.         }

  406. 

  407.         if (size > 0)

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

  409.     }

  410. 

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

  412.     {

  413.         if (kPort == nullptr)

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

  415. 

  416.         CARLA_ASSERT(! kIsInput);

  417.         CARLA_ASSERT(fJackBuffer != nullptr);

  418.         CARLA_ASSERT(channel < MAX_MIDI_CHANNELS);

  419.         CARLA_ASSERT(data != nullptr);

  420.         CARLA_ASSERT(size != 0);

  421. 

  422.         if (kIsInput)

  423.             return;

  424.         if (fJackBuffer == nullptr)

  425.             return;

  426.         if (channel >= MAX_MIDI_CHANNELS)

  427.             return;

  428.         if (data == nullptr)

  429.             return;

  430.         if (size == 0)

  431.             return;

  432. 

  433.         uint8_t jdata[size];

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

  435. 

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

  437. 

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

  439.     }

  440. 

  441. private:

  442.     jack_client_t* const kClient;

  443.     jack_port_t*   const kPort;

  444. 

  445.     void*       fJackBuffer;

  446.     EngineEvent fRetEvent;

  447. 

  448.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaEngineJackEventPort)

  449. };

  450. 

  451. // -------------------------------------------------------------------------------------------------------------------

  452. // Jack Engine client

  453. 

  454. class CarlaEngineJackClient : public CarlaEngineClient

  455. {

  456. public:

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

  458.         : CarlaEngineClient(engine),

  459.           kClient(client),

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

  461.     {

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

  463. 

  464.         if (kUseClient)

  465.         {

  466.             CARLA_ASSERT(kClient != nullptr);

  467.         }

  468.         else

  469.         {

  470.             CARLA_ASSERT(kClient == nullptr);

  471.         }

  472.     }

  473. 

  474.     ~CarlaEngineJackClient() override

  475.     {

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

  477. 

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

  479.             jackbridge_client_close(kClient);

  480.     }

  481. 

  482.     void activate() override

  483.     {

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

  485. 

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

  487.         {

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

  489. 

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

  491.                 jackbridge_activate(kClient);

  492.         }

  493. 

  494.         CarlaEngineClient::activate();

  495.     }

  496. 

  497.     void deactivate() override

  498.     {

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

  500. 

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

  502.         {

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

  504. 

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

  506.                 jackbridge_deactivate(kClient);

  507.         }

  508. 

  509.         CarlaEngineClient::deactivate();

  510.     }

  511. 

  512.     bool isOk() const override

  513.     {

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

  515. 

  516.         if (kUseClient)

  517.             return (kClient != nullptr);

  518. 

  519.         return CarlaEngineClient::isOk();

  520.     }

  521. 

  522. #if 0

  523.     void setLatency(const uint32_t samples) override

  524.     {

  525.         CarlaEngineClient::setLatency(samples);

  526. 

  527.         if (kUseClient)

  528.             jackbridge_recompute_total_latencies(kClient);

  529.     }

  530. #endif

  531. 

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

  533.     {

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

  535. 

  536.         jack_port_t* port = nullptr;

  537. 

  538.         // Create JACK port first, if needed

  539.         if (kUseClient)

  540.         {

  541.             switch (portType)

  542.             {

  543.             case kEnginePortTypeNull:

  544.                 break;

  545.             case kEnginePortTypeAudio:

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

  547.                 break;

  548.             case kEnginePortTypeCV:

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

  550.                 break;

  551.             case kEnginePortTypeEvent:

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

  553.                 break;

  554.             }

  555.         }

  556. 

  557.         // Create Engine port

  558.         switch (portType)

  559.         {

  560.         case kEnginePortTypeNull:

  561.             break;

  562.         case kEnginePortTypeAudio:

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

  564.         case kEnginePortTypeCV:

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

  566.         case kEnginePortTypeEvent:

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

  568.         }

  569. 

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

  571.         return nullptr;

  572.     }

  573. 

  574. private:

  575.     jack_client_t* const kClient;

  576.     const bool           kUseClient;

  577. 

  578.     friend class CarlaEngineJack;

  579.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaEngineJackClient)

  580. };

  581. 

  582. // -------------------------------------------------------------------------------------------------------------------

  583. // Jack Engine

  584. 

  585. class CarlaEngineJack : public CarlaEngine

  586. {

  587. public:

  588.     CarlaEngineJack()

  589.         : CarlaEngine(),

  590.           fClient(nullptr),

  591.           fTransportState(JackTransportStopped),

  592.           fFreewheel(false),

  593. #ifdef BUILD_BRIDGE

  594.           fHasQuit(false)

  595. #else

  596. # ifdef CARLA_PROPER_CPP11_SUPPORT

  597.           fRackPorts{nullptr},

  598. # endif

  599.           fLastGroupId(0),

  600.           fLastPortId(0),

  601.           fLastConnectionId(0)

  602. #endif

  603.     {

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

  605. 

  606. #ifdef BUILD_BRIDGE

  607.         fOptions.processMode = PROCESS_MODE_MULTIPLE_CLIENTS;

  608. #else

  609. # ifndef CARLA_PROPER_CPP11_SUPPORT

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

  611. # endif

  612. #endif

  613. 

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

  615.         fOptions.transportMode = TRANSPORT_MODE_JACK;

  616. 

  617.         carla_zeroStruct<jack_position_t>(fTransportPos);

  618.     }

  619. 

  620.     ~CarlaEngineJack() override

  621.     {

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

  623.         CARLA_ASSERT(fClient == nullptr);

  624. 

  625. #ifndef BUILD_BRIDGE

  626.         fUsedGroupNames.clear();

  627.         fUsedPortNames.clear();

  628.         fUsedConnections.clear();

  629.         fGroupIconsChanged.clear();

  630. #endif

  631.     }

  632. 

  633.     // -------------------------------------------------------------------

  634.     // Maximum values

  635. 

  636.     unsigned int maxClientNameSize() const override

  637.     {

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

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

  640. 

  641.         return CarlaEngine::maxClientNameSize();

  642.     }

  643. 

  644.     unsigned int maxPortNameSize() const override

  645.     {

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

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

  648. 

  649.         return CarlaEngine::maxPortNameSize();

  650.     }

  651. 

  652.     // -------------------------------------------------------------------

  653.     // Virtual, per-engine type calls

  654. 

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

  656.     {

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

  658. 

  659.         fFreewheel      = false;

  660.         fTransportState = JackTransportStopped;

  661. 

  662.         carla_zeroStruct<jack_position_t>(fTransportPos);

  663. 

  664. #ifndef BUILD_BRIDGE

  665.         fLastGroupId = 0;

  666.         fLastPortId  = 0;

  667.         fLastConnectionId = 0;

  668. 

  669.         fUsedGroupNames.clear();

  670.         fUsedPortNames.clear();

  671.         fUsedConnections.clear();

  672.         fGroupIconsChanged.clear();

  673. 

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

  675. 

  676.         if (fClient != nullptr)

  677.         {

  678.             fBufferSize = jackbridge_get_buffer_size(fClient);

  679.             fSampleRate = jackbridge_get_sample_rate(fClient);

  680. 

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

  682.             jackbridge_custom_set_data_appearance_callback(fClient, carla_jack_custom_appearance_callback, this);

  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_latency_callback(fClient, carla_jack_latency_callback, this);

  688.             jackbridge_set_process_callback(fClient, carla_jack_process_callback, this);

  689.             jackbridge_on_shutdown(fClient, carla_jack_shutdown_callback, this);

  690. 

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

  692. 

  693.             initJackPatchbay(jackClientName);

  694. 

  695.             jackbridge_set_client_registration_callback(fClient, carla_jack_client_registration_callback, this);

  696.             jackbridge_set_port_registration_callback(fClient, carla_jack_port_registration_callback, this);

  697.             jackbridge_set_port_connect_callback(fClient, carla_jack_port_connect_callback, this);

  698.             jackbridge_set_port_rename_callback(fClient, carla_jack_port_rename_callback, this);

  699. 

  700.             if (fOptions.processMode == PROCESS_MODE_CONTINUOUS_RACK)

  701.             {

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

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

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

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

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

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

  708.             }

  709. 

  710.             if (jackbridge_activate(fClient))

  711.             {

  712.                 CarlaEngine::init(jackClientName);

  713.                 return true;

  714.             }

  715.             else

  716.             {

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

  718.                 jackbridge_client_close(fClient);

  719.                 fClient = nullptr;

  720.             }

  721.         }

  722.         else

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

  724. 

  725.         return false;

  726. #else

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

  728.         {

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

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

  731.             {

  732.                 fBufferSize = jackbridge_get_buffer_size(tmpClient);

  733.                 fSampleRate = jackbridge_get_sample_rate(tmpClient);

  734. 

  735.                 jackbridge_client_close(tmpClient);

  736.             }

  737.         }

  738. 

  739.         return CarlaEngine::init(clientName);

  740. #endif

  741.     }

  742. 

  743.     bool close() override

  744.     {

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

  746.         CarlaEngine::close();

  747. 

  748. #ifdef BUILD_BRIDGE

  749.         fClient  = nullptr;

  750.         fHasQuit = true;

  751.         return true;

  752. #else

  753.         if (jackbridge_deactivate(fClient))

  754.         {

  755.             if (fOptions.processMode == PROCESS_MODE_CONTINUOUS_RACK)

  756.             {

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

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

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

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

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

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

  763.             }

  764. 

  765.             if (jackbridge_client_close(fClient))

  766.             {

  767.                 fClient = nullptr;

  768.                 return true;

  769.             }

  770.             else

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

  772.         }

  773.         else

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

  775. 

  776.         fClient = nullptr;

  777. 

  778.         fUsedGroupNames.clear();

  779.         fUsedPortNames.clear();

  780.         fUsedConnections.clear();

  781.         fGroupIconsChanged.clear();

  782. #endif

  783.         return false;

  784.     }

  785. 

  786. #ifndef BUILD_BRIDGE

  787.     void idle() override

  788.     {

  789.         CarlaEngine::idle();

  790. 

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

  792.             return;

  793. 

  794.         static bool checkIcons = false;

  795. 

  796.         if (! checkIcons)

  797.         {

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

  799.             return;

  800.         }

  801. 

  802.         checkIcons = false;

  803. 

  804.         void*  data;

  805.         size_t dataSize;

  806. 

  807.         QList<int> groupIconsCopy(fGroupIconsChanged);

  808.         fGroupIconsChanged.clear();

  809. 

  810.         foreach (const int& groupId, groupIconsCopy)

  811.         {

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

  813. 

  814.             data = nullptr;

  815.             dataSize = 0;

  816. 

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

  818.             {

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

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

  821. 

  822.                 PatchbayIconType groupIcon;

  823. 

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

  825.                     groupIcon = PATCHBAY_ICON_APPLICATION;

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

  827.                     groupIcon = PATCHBAY_ICON_HARDWARE;

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

  829.                     groupIcon = PATCHBAY_ICON_CARLA;

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

  831.                     groupIcon = PATCHBAY_ICON_DISTRHO;

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

  833.                     groupIcon = PATCHBAY_ICON_FILE;

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

  835.                     groupIcon = PATCHBAY_ICON_PLUGIN;

  836.                 else

  837.                     groupIcon = PATCHBAY_ICON_APPLICATION;

  838. 

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

  840. 

  841.                 jackbridge_free(data);

  842.             }

  843.         }

  844.     }

  845. #endif

  846. 

  847.     bool isRunning() const override

  848.     {

  849. #ifdef BUILD_BRIDGE

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

  851. #else

  852.         return (fClient != nullptr);

  853. #endif

  854.     }

  855. 

  856.     bool isOffline() const override

  857.     {

  858.         return fFreewheel;

  859.     }

  860. 

  861.     EngineType type() const override

  862.     {

  863.         return kEngineTypeJack;

  864.     }

  865. 

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

  867.     {

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

  869.         jack_client_t* client = nullptr;

  870. 

  871. #ifdef BUILD_BRIDGE

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

  873. 

  874.         fBufferSize = jackbridge_get_buffer_size(client);

  875.         fSampleRate = jackbridge_get_sample_rate(client);

  876. 

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

  878. 

  879.         jackbridge_set_buffer_size_callback(client, carla_jack_bufsize_callback, this);

  880.         jackbridge_set_sample_rate_callback(client, carla_jack_srate_callback, this);

  881.         jackbridge_set_freewheel_callback(client, carla_jack_freewheel_callback, this);

  882.         jackbridge_set_latency_callback(client, carla_jack_latency_callback, this);

  883.         jackbridge_set_process_callback(client, carla_jack_process_callback, this);

  884.         jackbridge_on_shutdown(client, carla_jack_shutdown_callback, this);

  885. #else

  886.         if (fOptions.processMode == PROCESS_MODE_SINGLE_CLIENT)

  887.         {

  888.             client = fClient;

  889.         }

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

  891.         {

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

  893. 

  894.             CARLA_ASSERT(client != nullptr);

  895. 

  896.             if (client == nullptr)

  897.                 return nullptr;

  898. 

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

  900. 

  901.             jackbridge_set_latency_callback(client, carla_jack_latency_callback_plugin, plugin);

  902.             jackbridge_set_process_callback(client, carla_jack_process_callback_plugin, plugin);

  903.         }

  904. #endif

  905. 

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

  907.     }

  908. 

  909. #ifndef BUILD_BRIDGE

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

  911.     {

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

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

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

  915.         CARLA_ASSERT(newName != nullptr);

  916. 

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

  918.         {

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

  920.             return nullptr;

  921.         }

  922. 

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

  924. 

  925.         if (plugin == nullptr)

  926.         {

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

  928.             return nullptr;

  929.         }

  930. 

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

  932. 

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

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

  935. 

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

  937. 

  938.         // JACK client rename

  939.         if (fOptions.processMode == PROCESS_MODE_MULTIPLE_CLIENTS)

  940.         {

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

  942. 

  943.             if (bridge.client_rename_ptr != nullptr)

  944.             {

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

  946.             }

  947.             else

  948.             {

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

  950.                 needsReinit = true;

  951. 

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

  953.                 {

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

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

  956. 

  957.                     // close old client

  958.                     plugin->setEnabled(false);

  959. 

  960.                     if (client->isActive())

  961.                         client->deactivate();

  962. 

  963.                     plugin->clearBuffers();

  964. 

  965.                     jackbridge_client_close(client->kClient);

  966. 

  967.                     // set new client data

  968.                     name = jackbridge_get_client_name(jclient);

  969. 

  970.                     jackbridge_set_process_callback(jclient, carla_jack_process_callback_plugin, plugin);

  971.                     jackbridge_set_latency_callback(jclient, carla_jack_latency_callback_plugin, plugin);

  972. 

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

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

  975.                 }

  976.             }

  977.         }

  978. 

  979.         if (name == nullptr)

  980.             return nullptr;

  981. 

  982.         // Rename

  983.         plugin->setName(name);

  984. 

  985.         if (needsReinit)

  986.         {

  987.             // reload plugin to recreate its ports

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

  989.             plugin->reload();

  990.             plugin->loadSaveState(saveState);

  991.         }

  992. 

  993.         return name;

  994.     }

  995. 

  996.     // -------------------------------------------------------------------

  997.     // Patchbay

  998. 

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

  1000.     {

  1001.         CARLA_ASSERT(fClient != nullptr);

  1002. 

  1003.         if (fClient == nullptr)

  1004.         {

  1005.             setLastError("Invalid JACK client");

  1006.             return false;

  1007.         }

  1008. 

  1009.         char portNameA[STR_MAX+1];

  1010.         char portNameB[STR_MAX+1];

  1011.         getFullPortName(portA, portNameA);

  1012.         getFullPortName(portB, portNameB);

  1013. 

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

  1015.         {

  1016.             setLastError("JACK operation failed");

  1017.             return false;

  1018.         }

  1019. 

  1020.         return true;

  1021.     }

  1022. 

  1023.     bool patchbayDisconnect(int connectionId) override

  1024.     {

  1025.         CARLA_ASSERT(fClient != nullptr);

  1026. 

  1027.         if (fClient == nullptr)

  1028.         {

  1029.             setLastError("Invalid JACK client");

  1030.             return false;

  1031.         }

  1032. 

  1033.         foreach (const ConnectionToId& connectionToId, fUsedConnections)

  1034.         {

  1035.             if (connectionToId.id == connectionId)

  1036.             {

  1037.                 char portNameOut[STR_MAX+1];

  1038.                 char portNameIn[STR_MAX+1];

  1039. 

  1040.                 getFullPortName(connectionToId.portOut, portNameOut);

  1041.                 getFullPortName(connectionToId.portIn, portNameIn);

  1042. 

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

  1044.                 {

  1045.                     setLastError("JACK operation failed");

  1046.                     return false;

  1047.                 }

  1048. 

  1049.                 return true;

  1050.             }

  1051.         }

  1052. 

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

  1054.         return false;

  1055.     }

  1056. 

  1057.     void patchbayRefresh() override

  1058.     {

  1059.         CARLA_ASSERT(fClient != nullptr);

  1060. 

  1061.         if (fClient == nullptr)

  1062.             return;

  1063. 

  1064.         fLastGroupId = 0;

  1065.         fLastPortId  = 0;

  1066.         fLastConnectionId = 0;

  1067. 

  1068.         fUsedGroupNames.clear();

  1069.         fUsedPortNames.clear();

  1070.         fUsedConnections.clear();

  1071.         fGroupIconsChanged.clear();

  1072. 

  1073.         initJackPatchbay(jackbridge_get_client_name(fClient));

  1074.     }

  1075. #endif

  1076. 

  1077.     // -------------------------------------------------------------------

  1078.     // Transport

  1079. 

  1080.     void transportPlay() override

  1081.     {

  1082.         if (fOptions.transportMode == TRANSPORT_MODE_INTERNAL)

  1083.             CarlaEngine::transportPlay();

  1084.         else if (fClient != nullptr)

  1085.             jackbridge_transport_start(fClient);

  1086.     }

  1087. 

  1088.     void transportPause() override

  1089.     {

  1090.         if (fOptions.transportMode == TRANSPORT_MODE_INTERNAL)

  1091.             CarlaEngine::transportPause();

  1092.         else if (fClient != nullptr)

  1093.             jackbridge_transport_stop(fClient);

  1094.     }

  1095. 

  1096.     void transportRelocate(const uint32_t frame) override

  1097.     {

  1098.         if (fOptions.transportMode == TRANSPORT_MODE_INTERNAL)

  1099.             CarlaEngine::transportRelocate(frame);

  1100.         else if (fClient != nullptr)

  1101.             jackbridge_transport_locate(fClient, frame);

  1102.     }

  1103. 

  1104.     // -------------------------------------

  1105. 

  1106. protected:

  1107.     void handleJackBufferSizeCallback(const uint32_t newBufferSize)

  1108.     {

  1109.         if (fBufferSize == newBufferSize)

  1110.             return;

  1111. 

  1112.         fBufferSize = newBufferSize;

  1113.         bufferSizeChanged(newBufferSize);

  1114.     }

  1115. 

  1116.     void handleJackSampleRateCallback(const double newSampleRate)

  1117.     {

  1118.         if (fSampleRate == newSampleRate)

  1119.             return;

  1120. 

  1121.         fSampleRate = newSampleRate;

  1122.         sampleRateChanged(newSampleRate);

  1123.     }

  1124. 

  1125.     void handleJackFreewheelCallback(const bool isFreewheel)

  1126.     {

  1127.         if (fFreewheel == isFreewheel)

  1128.             return;

  1129. 

  1130.         fFreewheel = isFreewheel;

  1131.         offlineModeChanged(isFreewheel);

  1132.     }

  1133. 

  1134.     void saveTransportInfo()

  1135.     {

  1136.         if (fOptions.transportMode != TRANSPORT_MODE_JACK)

  1137.             return;

  1138. 

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

  1140. 

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

  1142. 

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

  1144. 

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

  1146.         {

  1147.             fTimeInfo.frame = fTransportPos.frame;

  1148.             fTimeInfo.usecs = fTransportPos.usecs;

  1149. 

  1150.             if (fTransportPos.valid & JackPositionBBT)

  1151.             {

  1152.                 fTimeInfo.valid              = EngineTimeInfo::ValidBBT;

  1153.                 fTimeInfo.bbt.bar            = fTransportPos.bar;

  1154.                 fTimeInfo.bbt.beat           = fTransportPos.beat;

  1155.                 fTimeInfo.bbt.tick           = fTransportPos.tick;

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

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

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

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

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

  1161.             }

  1162.             else

  1163.                 fTimeInfo.valid = 0x0;

  1164.         }

  1165.         else

  1166.         {

  1167.             fTimeInfo.frame = 0;

  1168.             fTimeInfo.valid = 0x0;

  1169.         }

  1170.     }

  1171. 

  1172.     void handleJackProcessCallback(const uint32_t nframes)

  1173.     {

  1174.         saveTransportInfo();

  1175. 

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

  1177.         {

  1178. #ifndef BUILD_BRIDGE

  1179.             // pass-through

  1180.             if (fOptions.processMode == PROCESS_MODE_CONTINUOUS_RACK)

  1181.             {

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

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

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

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

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

  1187. 

  1188.                 CARLA_ASSERT(audioIn1 != nullptr);

  1189.                 CARLA_ASSERT(audioIn2 != nullptr);

  1190.                 CARLA_ASSERT(audioOut1 != nullptr);

  1191.                 CARLA_ASSERT(audioOut2 != nullptr);

  1192.                 CARLA_ASSERT(eventOut != nullptr);

  1193. 

  1194.                 carla_copyFloat(audioOut1, audioIn1, nframes);

  1195.                 carla_copyFloat(audioOut2, audioIn2, nframes);

  1196.                 jackbridge_midi_clear_buffer(eventOut);

  1197.             }

  1198. #endif

  1199. 

  1200.             return proccessPendingEvents();

  1201.         }

  1202. 

  1203. #ifdef BUILD_BRIDGE

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

  1205. 

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

  1207.         {

  1208.             plugin->initBuffers();

  1209.             processPlugin(plugin, nframes);

  1210.             plugin->unlock();

  1211.         }

  1212. #else

  1213.         if (fOptions.processMode == PROCESS_MODE_SINGLE_CLIENT)

  1214.         {

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

  1216.             {

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

  1218. 

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

  1220.                 {

  1221.                     plugin->initBuffers();

  1222.                     processPlugin(plugin, nframes);

  1223.                     plugin->unlock();

  1224.                 }

  1225.             }

  1226.         }

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

  1228.         {

  1229.             // get buffers from jack

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

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

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

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

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

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

  1236. 

  1237.             // assert buffers

  1238.             CARLA_ASSERT(audioIn1 != nullptr);

  1239.             CARLA_ASSERT(audioIn2 != nullptr);

  1240.             CARLA_ASSERT(audioOut1 != nullptr);

  1241.             CARLA_ASSERT(audioOut2 != nullptr);

  1242.             CARLA_ASSERT(eventIn != nullptr);

  1243.             CARLA_ASSERT(eventOut != nullptr);

  1244. 

  1245.             // create audio buffers

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

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

  1248. 

  1249.             // initialize input events

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

  1251.             {

  1252.                 uint32_t engineEventIndex = 0;

  1253. 

  1254.                 jack_midi_event_t jackEvent;

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

  1256. 

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

  1258.                 {

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

  1260.                         continue;

  1261. 

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

  1263.                     engineEvent->clear();

  1264. 

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

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

  1267. 

  1268.                     engineEvent->time    = jackEvent.time;

  1269.                     engineEvent->channel = midiChannel;

  1270. 

  1271.                     if (MIDI_IS_STATUS_CONTROL_CHANGE(midiStatus))

  1272.                     {

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

  1274. 

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

  1276.                         engineEvent->type         = kEngineEventTypeControl;

  1277. 

  1278.                         if (MIDI_IS_CONTROL_BANK_SELECT(midiControl))

  1279.                         {

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

  1281. 

  1282.                             engineEvent->ctrl.type  = kEngineControlEventTypeMidiBank;

  1283.                             engineEvent->ctrl.param = midiBank;

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

  1285.                         }

  1286.                         else if (midiControl == MIDI_CONTROL_ALL_SOUND_OFF)

  1287.                         {

  1288.                             engineEvent->ctrl.type  = kEngineControlEventTypeAllSoundOff;

  1289.                             engineEvent->ctrl.param = 0;

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

  1291.                         }

  1292.                         else if (midiControl == MIDI_CONTROL_ALL_NOTES_OFF)

  1293.                         {

  1294.                             engineEvent->ctrl.type  = kEngineControlEventTypeAllNotesOff;

  1295.                             engineEvent->ctrl.param = 0;

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

  1297.                         }

  1298.                         else

  1299.                         {

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

  1301. 

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

  1303. 

  1304.                             engineEvent->ctrl.type  = kEngineControlEventTypeParameter;

  1305.                             engineEvent->ctrl.param = midiControl;

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

  1307.                         }

  1308.                     }

  1309.                     else if (MIDI_IS_STATUS_PROGRAM_CHANGE(midiStatus))

  1310.                     {

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

  1312. 

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

  1314.                         engineEvent->type         = kEngineEventTypeControl;

  1315. 

  1316.                         engineEvent->ctrl.type  = kEngineControlEventTypeMidiProgram;

  1317.                         engineEvent->ctrl.param = midiProgram;

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

  1319.                     }

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

  1321.                     {

  1322.                         engineEvent->type = kEngineEventTypeMidi;

  1323. 

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

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

  1326. 

  1327.                         if (jackEvent.size > 1)

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

  1329.                     }

  1330. 

  1331.                     if (engineEventIndex >= INTERNAL_EVENT_COUNT)

  1332.                         break;

  1333.                 }

  1334.             }

  1335. 

  1336.             // process rack

  1337.             processRack(inBuf, outBuf, nframes);

  1338. 

  1339.             // output control

  1340.             {

  1341.                 jackbridge_midi_clear_buffer(eventOut);

  1342. 

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

  1344.                 {

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

  1346. 

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

  1348.                     uint8_t size    = 0;

  1349. 

  1350.                     switch (engineEvent->type)

  1351.                     {

  1352.                     case kEngineEventTypeNull:

  1353.                         break;

  1354. 

  1355.                     case kEngineEventTypeControl:

  1356.                     {

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

  1358. 

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

  1360.                         {

  1361.                             // FIXME?

  1362.                             ctrlEvent->type  = kEngineControlEventTypeMidiBank;

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

  1364.                             ctrlEvent->value = 0.0f;

  1365.                         }

  1366. 

  1367.                         switch (ctrlEvent->type)

  1368.                         {

  1369.                         case kEngineControlEventTypeNull:

  1370.                             break;

  1371.                         case kEngineControlEventTypeParameter:

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

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

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

  1375.                             size    = 3;

  1376.                             break;

  1377.                         case kEngineControlEventTypeMidiBank:

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

  1379.                             data[1] = MIDI_CONTROL_BANK_SELECT;

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

  1381.                             size    = 3;

  1382.                             break;

  1383.                         case kEngineControlEventTypeMidiProgram:

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

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

  1386.                             size    = 2;

  1387.                             break;

  1388.                         case kEngineControlEventTypeAllSoundOff:

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

  1390.                             data[1] = MIDI_CONTROL_ALL_SOUND_OFF;

  1391.                             size    = 2;

  1392.                             break;

  1393.                         case kEngineControlEventTypeAllNotesOff:

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

  1395.                             data[1] = MIDI_CONTROL_ALL_NOTES_OFF;

  1396.                             size    = 2;

  1397.                             break;

  1398.                         }

  1399.                         break;

  1400.                     }

  1401. 

  1402.                     case kEngineEventTypeMidi:

  1403.                     {

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

  1405. 

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

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

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

  1409.                         size    = midiEvent->size;

  1410.                         break;

  1411.                     }

  1412.                     }

  1413. 

  1414.                     if (size > 0)

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

  1416.                 }

  1417.             }

  1418.         }

  1419. #endif // ! BUILD_BRIDGE

  1420. 

  1421.         proccessPendingEvents();

  1422.     }

  1423. 

  1424.     void handleJackLatencyCallback(const jack_latency_callback_mode_t mode)

  1425.     {

  1426.         if (fOptions.processMode != PROCESS_MODE_SINGLE_CLIENT)

  1427.             return;

  1428. 

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

  1430.         {

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

  1432. 

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

  1434.                 latencyPlugin(plugin, mode);

  1435.         }

  1436.     }

  1437. 

  1438. #ifndef BUILD_BRIDGE

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

  1440.     {

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

  1442.         {

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

  1444. 

  1445.             if (groupId == -1)

  1446.                 return;

  1447. 

  1448.             fGroupIconsChanged.append(groupId);

  1449.         }

  1450.     }

  1451. 

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

  1453.     {

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

  1455.         if (reg) return;

  1456. 

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

  1458. 

  1459.         if (id == -1)

  1460.             return;

  1461. 

  1462.         GroupNameToId groupNameId(id, name);

  1463.         fUsedGroupNames.removeAll(groupNameId);

  1464. 

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

  1466.     }

  1467. 

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

  1469.     {

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

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

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

  1473. 

  1474.         CARLA_ASSERT(jackPort != nullptr);

  1475.         CARLA_ASSERT(portName != nullptr);

  1476.         CARLA_ASSERT(fullPortName != nullptr);

  1477. 

  1478.         if (jackPort == nullptr)

  1479.             return;

  1480.         if (portName == nullptr)

  1481.             return;

  1482.         if (fullPortName == nullptr)

  1483.             return;

  1484. 

  1485.         CarlaString groupName(fullPortName);

  1486.         groupName.truncate(groupName.rfind(portName)-1);

  1487. 

  1488.         int groupId = getGroupId(groupName);

  1489. 

  1490.         if (reg)

  1491.         {

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

  1493. 

  1494.             if (groupId == -1)

  1495.             {

  1496.                 groupId = fLastGroupId++;

  1497. 

  1498.                 GroupNameToId groupNameToId(groupId, groupName);

  1499.                 fUsedGroupNames.append(groupNameToId);

  1500. 

  1501.                 if (jackPortFlags & JackPortIsPhysical)

  1502.                 {

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

  1504.                 }

  1505.                 else

  1506.                 {

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

  1508.                     fGroupIconsChanged.append(groupId);

  1509.                 }

  1510.             }

  1511. 

  1512.             bool portIsInput = (jackPortFlags & JackPortIsInput);

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

  1514.             bool portIsCV    = (jackPortFlags & JackPortIsControlVoltage);

  1515. 

  1516.             unsigned int canvasPortFlags = 0x0;

  1517.             canvasPortFlags |= portIsInput ? PATCHBAY_PORT_IS_INPUT : PATCHBAY_PORT_IS_OUTPUT;

  1518.             canvasPortFlags |= portIsAudio ? PATCHBAY_PORT_IS_AUDIO : PATCHBAY_PORT_IS_MIDI;

  1519. 

  1520.             if (portIsAudio && portIsCV)

  1521.                 canvasPortFlags |= PATCHBAY_PORT_IS_CV;

  1522. 

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

  1524.             fUsedPortNames.append(portNameToId);

  1525. 

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

  1527.         }

  1528.         else

  1529.         {

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

  1531. 

  1532.             CARLA_ASSERT(groupId != -1);

  1533.             CARLA_ASSERT(portId != -1);

  1534. 

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

  1536.                 return;

  1537. 

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

  1539.             fUsedPortNames.removeOne(portNameId);

  1540. 

  1541.             callback(CALLBACK_PATCHBAY_PORT_REMOVED, 0, portId, 0, 0.0f, fullPortName);

  1542.         }

  1543.     }

  1544. 

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

  1546.     {

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

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

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

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

  1551. 

  1552.         CARLA_ASSERT(jackPortA != nullptr);

  1553.         CARLA_ASSERT(jackPortB != nullptr);

  1554.         CARLA_ASSERT(fullPortNameA != nullptr);

  1555.         CARLA_ASSERT(fullPortNameB != nullptr);

  1556. 

  1557.         if (jackPortA == nullptr)

  1558.             return;

  1559.         if (jackPortB == nullptr)

  1560.             return;

  1561.         if (fullPortNameA == nullptr)

  1562.             return;

  1563.         if (fullPortNameB == nullptr)

  1564.             return;

  1565. 

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

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

  1568. 

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

  1570.             return;

  1571. 

  1572.         if (connect)

  1573.         {

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

  1575.             fUsedConnections.append(connectionToId);

  1576. 

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

  1578.         }

  1579.         else

  1580.         {

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

  1582.             {

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

  1584. 

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

  1586.                 {

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

  1588.                     fUsedConnections.takeAt(i);

  1589.                     break;

  1590.                 }

  1591.             }

  1592.         }

  1593.     }

  1594. 

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

  1596.     {

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

  1598.         {

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

  1600. 

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

  1602.             {

  1603.                 groupNameToId.rename(newName);

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

  1605.                 break;

  1606.             }

  1607.         }

  1608.     }

  1609. 

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

  1611.     {

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

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

  1614. 

  1615.         CARLA_ASSERT(jackPort != nullptr);

  1616.         CARLA_ASSERT(portName != nullptr);

  1617. 

  1618.         if (jackPort == nullptr)

  1619.             return;

  1620.         if (portName == nullptr)

  1621.             return;

  1622. 

  1623.         CarlaString groupName(newName);

  1624.         groupName.truncate(groupName.rfind(portName)-1);

  1625. 

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

  1627. 

  1628.         CARLA_ASSERT(groupId != -1);

  1629. 

  1630.         if (groupId == -1)

  1631.             return;

  1632. 

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

  1634.         {

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

  1636. 

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

  1638.             {

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

  1640.                 portNameId.rename(portName, newName);

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

  1642.                 break;

  1643.             }

  1644.         }

  1645.     }

  1646. #endif

  1647. 

  1648.     void handleJackShutdownCallback()

  1649.     {

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

  1651.         {

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

  1653. 

  1654.             //if (plugin)

  1655.             //    plugin->x_client = nullptr;

  1656.         }

  1657. 

  1658.         fClient = nullptr;

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

  1660.     }

  1661. 

  1662.     // -------------------------------------

  1663. 

  1664. private:

  1665.     jack_client_t*         fClient;

  1666.     jack_position_t        fTransportPos;

  1667.     jack_transport_state_t fTransportState;

  1668.     bool fFreewheel;

  1669. 

  1670.     // -------------------------------------

  1671. 

  1672. #ifdef BUILD_BRIDGE

  1673.     bool fHasQuit;

  1674. #else

  1675.     enum RackPorts {

  1676.         kRackPortAudioIn1  = 0,

  1677.         kRackPortAudioIn2  = 1,

  1678.         kRackPortAudioOut1 = 2,

  1679.         kRackPortAudioOut2 = 3,

  1680.         kRackPortEventIn   = 4,

  1681.         kRackPortEventOut  = 5,

  1682.         kRackPortCount     = 6

  1683.     };

  1684. 

  1685.     jack_port_t* fRackPorts[kRackPortCount];

  1686. 

  1687.     struct GroupNameToId {

  1688.         int  id;

  1689.         char name[STR_MAX+1];

  1690. 

  1691.         GroupNameToId()

  1692.         {

  1693.             id = -1;

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

  1695.         }

  1696. 

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

  1698.         {

  1699.             this->id = id;

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

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

  1702.         }

  1703. 

  1704.         void rename(const char name[])

  1705.         {

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

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

  1708.         }

  1709. 

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

  1711.         {

  1712.             if (groupNameId.id != id)

  1713.                 return false;

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

  1715.                 return false;

  1716.             return true;

  1717.         }

  1718.     };

  1719. 

  1720.     struct PortNameToId {

  1721.         int  groupId;

  1722.         int  portId;

  1723.         char name[STR_MAX+1];

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

  1725. 

  1726.         PortNameToId()

  1727.         {

  1728.             groupId = -1;

  1729.             portId  = -1;

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

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

  1732.         }

  1733. 

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

  1735.         {

  1736.             this->groupId = groupId;

  1737.             this->portId  = portId;

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

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

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

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

  1742.         }

  1743. 

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

  1745.         {

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

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

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

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

  1750.         }

  1751. 

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

  1753.         {

  1754.             if (portNameId.groupId != groupId)

  1755.                 return false;

  1756.             if (portNameId.portId != portId)

  1757.                 return false;

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

  1759.                 return false;

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

  1761.                 return false;

  1762.             return true;

  1763.         }

  1764.     };

  1765. 

  1766.     struct ConnectionToId {

  1767.         int id;

  1768.         int portOut;

  1769.         int portIn;

  1770. 

  1771.         ConnectionToId()

  1772.         {

  1773.             id = -1;

  1774.             portOut = -1;

  1775.             portIn  = -1;

  1776.         }

  1777. 

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

  1779.         {

  1780.             this->id = id;

  1781.             this->portOut = portOut;

  1782.             this->portIn  = portIn;

  1783.         }

  1784. 

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

  1786.         {

  1787.             if (connectionId.id != id)

  1788.                 return false;

  1789.             if (connectionId.portOut != portOut)

  1790.                 return false;

  1791.             if (connectionId.portIn != portIn)

  1792.                 return false;

  1793.             return true;

  1794.         }

  1795.     };

  1796. 

  1797.     int fLastGroupId;

  1798.     int fLastPortId;

  1799.     int fLastConnectionId;

  1800. 

  1801.     QList<GroupNameToId>  fUsedGroupNames;

  1802.     QList<PortNameToId>   fUsedPortNames;

  1803.     QList<ConnectionToId> fUsedConnections;

  1804.     QList<int> fGroupIconsChanged;

  1805. 

  1806.     int getGroupId(const char* const name)

  1807.     {

  1808.         CARLA_ASSERT(name != nullptr);

  1809. 

  1810.         if (name == nullptr)

  1811.             return -1;

  1812. 

  1813.         foreach (const GroupNameToId& groupNameId, fUsedGroupNames)

  1814.         {

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

  1816.                 return groupNameId.id;

  1817.         }

  1818. 

  1819.         return -1;

  1820.     }

  1821. 

  1822.     const char* getGroupName(const int groupId)

  1823.     {

  1824.         CARLA_ASSERT(groupId >= 0);

  1825. 

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

  1827. 

  1828.         if (groupId < 0)

  1829.             return fallback;

  1830. 

  1831.         foreach (const GroupNameToId& groupNameId, fUsedGroupNames)

  1832.         {

  1833.             if (groupNameId.id == groupId)

  1834.                 return groupNameId.name;

  1835.         }

  1836. 

  1837.         return fallback;

  1838.     }

  1839. 

  1840.     int getPortId(const char* const fullName)

  1841.     {

  1842.         CARLA_ASSERT(fullName != nullptr);

  1843. 

  1844.         if (fullName == nullptr)

  1845.             return -1;

  1846. 

  1847.         foreach (const PortNameToId& portNameId, fUsedPortNames)

  1848.         {

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

  1850.                 return portNameId.portId;

  1851.         }

  1852. 

  1853.         return -1;

  1854.     }

  1855. 

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

  1857.     {

  1858.         foreach (const PortNameToId& portNameId, fUsedPortNames)

  1859.         {

  1860.             if (portNameId.portId == portId)

  1861.             {

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

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

  1864.                 return;

  1865.             }

  1866.         }

  1867. 

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

  1869.     }

  1870. 

  1871.     void initJackPatchbay(const char* const ourName)

  1872.     {

  1873.         CARLA_ASSERT(fLastGroupId == 0);

  1874.         CARLA_ASSERT(fLastPortId == 0);

  1875.         CARLA_ASSERT(fLastConnectionId == 0);

  1876.         CARLA_ASSERT(ourName != nullptr);

  1877. 

  1878.         // query initial jack ports

  1879.         QStringList parsedGroups;

  1880. 

  1881.         // our client

  1882.         if (ourName != nullptr)

  1883.         {

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

  1885. 

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

  1887.             fUsedGroupNames.append(groupNameToId);

  1888. 

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

  1890.         }

  1891. 

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

  1893.         {

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

  1895.             {

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

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

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

  1899. 

  1900.                 CARLA_ASSERT(jackPort != nullptr);

  1901.                 CARLA_ASSERT(portName != nullptr);

  1902. 

  1903.                 if (jackPort == nullptr)

  1904.                     continue;

  1905.                 if (portName == nullptr)

  1906.                     continue;

  1907. 

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

  1909. 

  1910.                 int groupId = -1;

  1911. 

  1912.                 CarlaString groupName(fullPortName);

  1913.                 groupName.truncate(groupName.rfind(portName)-1);

  1914. 

  1915.                 QString qGroupName(groupName);

  1916. 

  1917.                 if (parsedGroups.contains(qGroupName))

  1918.                 {

  1919.                     groupId = getGroupId(groupName);

  1920.                     CARLA_ASSERT(groupId != -1);

  1921.                 }

  1922.                 else

  1923.                 {

  1924.                     groupId = fLastGroupId++;

  1925.                     parsedGroups.append(qGroupName);

  1926. 

  1927.                     GroupNameToId groupNameToId(groupId, groupName);

  1928.                     fUsedGroupNames.append(groupNameToId);

  1929. 

  1930.                     PatchbayIconType groupIcon = PATCHBAY_ICON_APPLICATION;

  1931. 

  1932.                     void*  data = nullptr;

  1933.                     size_t dataSize = 0;

  1934. 

  1935.                     if (jackPortFlags & JackPortIsPhysical)

  1936.                     {

  1937.                         groupIcon = PATCHBAY_ICON_HARDWARE;

  1938.                     }

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

  1940.                     {

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

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

  1943. 

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

  1945.                             groupIcon = PATCHBAY_ICON_APPLICATION;

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

  1947.                             groupIcon = PATCHBAY_ICON_HARDWARE;

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

  1949.                             groupIcon = PATCHBAY_ICON_CARLA;

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

  1951.                             groupIcon = PATCHBAY_ICON_DISTRHO;

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

  1953.                             groupIcon = PATCHBAY_ICON_FILE;

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

  1955.                             groupIcon = PATCHBAY_ICON_PLUGIN;

  1956.                     }

  1957. 

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

  1959.                 }

  1960. 

  1961.                 bool portIsInput = (jackPortFlags & JackPortIsInput);

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

  1963.                 bool portIsCV    = (jackPortFlags & JackPortIsControlVoltage);

  1964. 

  1965.                 unsigned int canvasPortFlags = 0x0;

  1966.                 canvasPortFlags |= portIsInput ? PATCHBAY_PORT_IS_INPUT : PATCHBAY_PORT_IS_OUTPUT;

  1967.                 canvasPortFlags |= portIsAudio ? PATCHBAY_PORT_IS_AUDIO : PATCHBAY_PORT_IS_MIDI;

  1968. 

  1969.                 if (portIsAudio && portIsCV)

  1970.                     canvasPortFlags |= PATCHBAY_PORT_IS_CV;

  1971. 

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

  1973.                 fUsedPortNames.append(portNameToId);

  1974. 

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

  1976.             }

  1977. 

  1978.             jackbridge_free(ports);

  1979.         }

  1980. 

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

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

  1983.         {

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

  1985.             {

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

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

  1988. 

  1989.                 CARLA_ASSERT(jackPort != nullptr);

  1990. 

  1991.                 if (jackPort == nullptr)

  1992.                     continue;

  1993. 

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

  1995. 

  1996.                 if (thisPortId == -1)

  1997.                     continue;

  1998. 

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

  2000.                 {

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

  2002.                     {

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

  2004. 

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

  2006.                         fUsedConnections.append(connectionToId);

  2007. 

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

  2009.                     }

  2010. 

  2011.                     jackbridge_free(connections);

  2012.                 }

  2013.             }

  2014. 

  2015.             jackbridge_free(ports);

  2016.         }

  2017.     }

  2018. #endif

  2019. 

  2020.     // -------------------------------------

  2021. 

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

  2023.     {

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

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

  2026. 

  2027.         float* inBuffer[inCount];

  2028.         float* outBuffer[outCount];

  2029. 

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

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

  2032. 

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

  2034.         {

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

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

  2037.         }

  2038. 

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

  2040.         {

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

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

  2043.         }

  2044. 

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

  2046.         {

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

  2048.             {

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

  2050. 

  2051.                 if (absV > inPeaks[i])

  2052.                     inPeaks[i] = absV;

  2053.             }

  2054.         }

  2055. 

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

  2057. 

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

  2059.         {

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

  2061.             {

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

  2063. 

  2064.                 if (absV > outPeaks[i])

  2065.                     outPeaks[i] = absV;

  2066.             }

  2067.         }

  2068. 

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

  2070.     }

  2071. 

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

  2073.     {

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

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

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

  2077. 

  2078.         if (latency == 0)

  2079.             return;

  2080. 

  2081.         //jack_latency_range_t range;

  2082. 

  2083.         // TODO

  2084. 

  2085.         if (mode == JackCaptureLatency)

  2086.         {

  2087. #if 0

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

  2089.             {

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

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

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

  2093. 

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

  2095.                 range.min += latency;

  2096.                 range.max += latency;

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

  2098.             }

  2099. #endif

  2100.         }

  2101.         else

  2102.         {

  2103. #if 0

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

  2105.             {

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

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

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

  2109. 

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

  2111.                 range.min += latency;

  2112.                 range.max += latency;

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

  2114.             }

  2115. #endif

  2116.         }

  2117.     }

  2118. 

  2119.     // -------------------------------------

  2120. 

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

  2122. 

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

  2124.     {

  2125.         handlePtr->handleJackBufferSizeCallback(newBufferSize);

  2126.         return 0;

  2127.     }

  2128. 

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

  2130.     {

  2131.         handlePtr->handleJackSampleRateCallback(newSampleRate);

  2132.         return 0;

  2133.     }

  2134. 

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

  2136.     {

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

  2138.     }

  2139. 

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

  2141.     {

  2142.         handlePtr->handleJackProcessCallback(nframes);

  2143.         return 0;

  2144.     }

  2145. 

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

  2147.     {

  2148.         handlePtr->handleJackLatencyCallback(mode);

  2149.     }

  2150. 

  2151. #ifndef BUILD_BRIDGE

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

  2153.     {

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

  2155.     }

  2156. 

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

  2158.     {

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

  2160.     }

  2161. 

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

  2163.     {

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

  2165.     }

  2166. 

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

  2168.     {

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

  2170.     }

  2171. 

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

  2173.     {

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

  2175.         return 0;

  2176.     }

  2177. 

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

  2179.     {

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

  2181.         return 0;

  2182.     }

  2183. #endif

  2184. 

  2185.     static void carla_jack_shutdown_callback(void* arg)

  2186.     {

  2187.         handlePtr->handleJackShutdownCallback();

  2188.     }

  2189. 

  2190.     #undef handlePtr

  2191. 

  2192.     // -------------------------------------

  2193. 

  2194. #ifndef BUILD_BRIDGE

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

  2196.     {

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

  2198. 

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

  2200.         {

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

  2202.             CARLA_ASSERT(engine != nullptr);

  2203. 

  2204.             plugin->initBuffers();

  2205.             engine->saveTransportInfo();

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

  2207.             plugin->unlock();

  2208.         }

  2209. 

  2210.         return 0;

  2211.     }

  2212. 

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

  2214.     {

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

  2216. 

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

  2218.         {

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

  2220.             CARLA_ASSERT(engine != nullptr);

  2221. 

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

  2223.         }

  2224.     }

  2225. #endif

  2226. 

  2227.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaEngineJack)

  2228. };

  2229. 

  2230. // -----------------------------------------

  2231. 

  2232. CarlaEngine* CarlaEngine::newJack()

  2233. {

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

  2235.     return new CarlaEngineJack();

  2236. }

  2237. 

  2238. // -----------------------------------------

  2239. 

  2240. CARLA_BACKEND_END_NAMESPACE