falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 42 Activity
Audio plugin host https://kx.studio/carla
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
618 Commits
16 Branches
3.6GB
Tree: 2d6aac1d20
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '2d6aac1d20'
${ noResults }
Carla/source/backend/engine/CarlaEngineJack.cpp

1819 lines
60KB
Raw Blame History 

  1. /*

  2.  * Carla JACK Engine

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

  4.  *

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

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

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

  8.  * the License, or any later version.

  9.  *

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

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

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

  13.  * GNU General Public License for more details.

  14.  *

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

  16.  */

  17. 

  18. #include "CarlaEngineInternal.hpp"

  19. #include "CarlaBackendUtils.hpp"

  20. #include "CarlaMIDI.h"

  21. 

  22. #ifdef JACKBRIDGE_EXPORT

  23. # include "jackbridge/JackBridge.hpp"

  24. #else

  25. # include "jackbridge/JackBridge1.cpp"

  26. # include "jackbridge/JackBridge2.cpp"

  27. #endif

  28. 

  29. #include <cmath>

  30. #include <QtCore/QStringList>

  31. 

  32. CARLA_BACKEND_START_NAMESPACE

  33. 

  34. #if 0

  35. } // Fix editor indentation

  36. #endif

  37. 

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

  39. // Fallback data

  40. 

  41. static const EngineEvent kFallbackJackEngineEvent;

  42. 

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

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

  45. 

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

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

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

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

  50. 

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

  52. // Carla Engine JACK-Audio port

  53. 

  54. class CarlaEngineJackAudioPort : public CarlaEngineAudioPort

  55. {

  56. public:

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

  58.         : CarlaEngineAudioPort(isInput, processMode),

  59.           kClient(client),

  60.           kPort(port)

  61.     {

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

  63. 

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

  65.         {

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

  67.         }

  68.         else

  69.         {

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

  71.         }

  72.     }

  73. 

  74.     ~CarlaEngineJackAudioPort() override

  75.     {

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

  77. 

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

  79.             jackbridge_port_unregister(kClient, kPort);

  80.     }

  81. 

  82.     void initBuffer(CarlaEngine* const engine) override

  83.     {

  84.         CARLA_ASSERT(engine != nullptr);

  85. 

  86.         if (engine == nullptr)

  87.         {

  88.             fBuffer = nullptr;

  89.             return;

  90.         }

  91. 

  92.         if (kPort == nullptr)

  93.             return CarlaEngineAudioPort::initBuffer(engine);

  94. 

  95.         fBuffer = (float*)jackbridge_port_get_buffer(kPort, engine->getBufferSize());

  96. 

  97.         if (! kIsInput)

  98.            carla_zeroFloat(fBuffer, engine->getBufferSize());

  99.     }

  100. 

  101. private:

  102.     jack_client_t* const kClient;

  103.     jack_port_t*   const kPort;

  104. 

  105.     friend class CarlaEngineJack;

  106. 

  107.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaEngineJackAudioPort)

  108. };

  109. 

  110. // -------------------------------------------------------------------------------------------------------------------

  111. // Carla Engine JACK-Event port

  112. 

  113. class CarlaEngineJackEventPort : public CarlaEngineEventPort

  114. {

  115. public:

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

  117.         : CarlaEngineEventPort(isInput, processMode),

  118.           kClient(client),

  119.           kPort(port),

  120.           fJackBuffer(nullptr)

  121.     {

  122.         carla_debug("CarlaEngineJackEventPort::CarlaEngineJackEventPort(%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.     ~CarlaEngineJackEventPort() override

  135.     {

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

  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.         {

  148.             fJackBuffer = nullptr;

  149.             return;

  150.         }

  151. 

  152.         if (kPort == nullptr)

  153.             return CarlaEngineEventPort::initBuffer(engine);

  154. 

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

  156. 

  157.         if (! kIsInput)

  158.             jackbridge_midi_clear_buffer(fJackBuffer);

  159.     }

  160. 

  161.     uint32_t getEventCount() const override

  162.     {

  163.         if (kPort == nullptr)

  164.             return CarlaEngineEventPort::getEventCount();

  165. 

  166.         CARLA_ASSERT(kIsInput);

  167.         CARLA_ASSERT(fJackBuffer != nullptr);

  168. 

  169.         if (! kIsInput)

  170.             return 0;

  171.         if (fJackBuffer == nullptr)

  172.             return 0;

  173. 

  174.         return jackbridge_midi_get_event_count(fJackBuffer);

  175.     }

  176. 

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

  178.     {

  179.         if (kPort == nullptr)

  180.             return CarlaEngineEventPort::getEvent(index);

  181. 

  182.         CARLA_ASSERT(kIsInput);

  183.         CARLA_ASSERT(fJackBuffer != nullptr);

  184. 

  185.         if (! kIsInput)

  186.             return kFallbackJackEngineEvent;

  187.         if (fJackBuffer == nullptr)

  188.             return kFallbackJackEngineEvent;

  189. 

  190.         jack_midi_event_t jackEvent;

  191.         carla_zeroStruct<jack_midi_event_t>(jackEvent);

  192. 

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

  194.             return kFallbackJackEngineEvent;

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

  196.             return kFallbackJackEngineEvent;

  197. 

  198.         fRetEvent.clear();

  199. 

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

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

  202. 

  203.         fRetEvent.time    = jackEvent.time;

  204.         fRetEvent.channel = midiChannel;

  205. 

  206.         if (MIDI_IS_STATUS_CONTROL_CHANGE(midiStatus))

  207.         {

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

  209. 

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

  211.             fRetEvent.type            = kEngineEventTypeControl;

  212. 

  213.             if (MIDI_IS_CONTROL_BANK_SELECT(midiControl))

  214.             {

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

  216. 

  217.                 fRetEvent.ctrl.type  = kEngineControlEventTypeMidiBank;

  218.                 fRetEvent.ctrl.param = midiBank;

  219.                 fRetEvent.ctrl.value = 0.0f;

  220.             }

  221.             else if (midiControl == MIDI_CONTROL_ALL_SOUND_OFF)

  222.             {

  223.                 fRetEvent.ctrl.type  = kEngineControlEventTypeAllSoundOff;

  224.                 fRetEvent.ctrl.param = 0;

  225.                 fRetEvent.ctrl.value = 0.0f;

  226.             }

  227.             else if (midiControl == MIDI_CONTROL_ALL_NOTES_OFF)

  228.             {

  229.                 fRetEvent.ctrl.type  = kEngineControlEventTypeAllNotesOff;

  230.                 fRetEvent.ctrl.param = 0;

  231.                 fRetEvent.ctrl.value = 0.0f;

  232.             }

  233.             else

  234.             {

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

  236. 

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

  238. 

  239.                 fRetEvent.ctrl.type  = kEngineControlEventTypeParameter;

  240.                 fRetEvent.ctrl.param = midiControl;

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

  242.             }

  243.         }

  244.         else if (MIDI_IS_STATUS_PROGRAM_CHANGE(midiStatus))

  245.         {

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

  247. 

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

  249.             fRetEvent.type            = kEngineEventTypeControl;

  250. 

  251.             fRetEvent.ctrl.type  = kEngineControlEventTypeMidiProgram;

  252.             fRetEvent.ctrl.param = midiProgram;

  253.             fRetEvent.ctrl.value = 0.0f;

  254.         }

  255.         else

  256.         {

  257.             fRetEvent.type = kEngineEventTypeMidi;

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

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

  260. 

  261.             if (jackEvent.size > 1)

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

  263.         }

  264. 

  265.         return fRetEvent;

  266.     }

  267. 

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

  269.     {

  270.         if (kPort == nullptr)

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

  272. 

  273.         CARLA_ASSERT(! kIsInput);

  274.         CARLA_ASSERT(fJackBuffer != nullptr);

  275.         CARLA_ASSERT(type != kEngineControlEventTypeNull);

  276.         CARLA_ASSERT(channel < MAX_MIDI_CHANNELS);

  277.         CARLA_ASSERT(param < MAX_MIDI_VALUE);

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

  279. 

  280.         if (kIsInput)

  281.             return;

  282.         if (fJackBuffer == nullptr)

  283.             return;

  284.         if (type == kEngineControlEventTypeNull)

  285.             return;

  286.         if (channel >= MAX_MIDI_CHANNELS)

  287.             return;

  288.         if (param >= MAX_MIDI_VALUE)

  289.             return;

  290.         if (type == kEngineControlEventTypeParameter)

  291.         {

  292.             CARLA_ASSERT(! MIDI_IS_CONTROL_BANK_SELECT(param));

  293.         }

  294. 

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

  296. 

  297.         size_t size = 0;

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

  299. 

  300.         switch (type)

  301.         {

  302.         case kEngineControlEventTypeNull:

  303.             break;

  304.         case kEngineControlEventTypeParameter:

  305.             data[0] = MIDI_STATUS_CONTROL_CHANGE + channel;

  306.             data[1] = param;

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

  308.             size    = 3;

  309.             break;

  310.         case kEngineControlEventTypeMidiBank:

  311.             data[0] = MIDI_STATUS_CONTROL_CHANGE + channel;

  312.             data[1] = MIDI_CONTROL_BANK_SELECT;

  313.             data[2] = param;

  314.             size    = 3;

  315.             break;

  316.         case kEngineControlEventTypeMidiProgram:

  317.             data[0] = MIDI_STATUS_PROGRAM_CHANGE + channel;

  318.             data[1] = param;

  319.             size    = 2;

  320.             break;

  321.         case kEngineControlEventTypeAllSoundOff:

  322.             data[0] = MIDI_STATUS_CONTROL_CHANGE + channel;

  323.             data[1] = MIDI_CONTROL_ALL_SOUND_OFF;

  324.             data[2] = 0;

  325.             size    = 3;

  326.             break;

  327.         case kEngineControlEventTypeAllNotesOff:

  328.             data[0] = MIDI_STATUS_CONTROL_CHANGE + channel;

  329.             data[1] = MIDI_CONTROL_ALL_NOTES_OFF;

  330.             data[2] = 0;

  331.             size    = 3;

  332.             break;

  333.         }

  334. 

  335.         if (size > 0)

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

  337.     }

  338. 

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

  340.     {

  341.         if (kPort == nullptr)

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

  343. 

  344.         CARLA_ASSERT(! kIsInput);

  345.         CARLA_ASSERT(fJackBuffer != nullptr);

  346.         CARLA_ASSERT(channel < MAX_MIDI_CHANNELS);

  347.         CARLA_ASSERT(data != nullptr);

  348.         CARLA_ASSERT(size > 0);

  349. 

  350.         if (kIsInput)

  351.             return;

  352.         if (fJackBuffer == nullptr)

  353.             return;

  354.         if (channel >= MAX_MIDI_CHANNELS)

  355.             return;

  356.         if (data == nullptr)

  357.             return;

  358.         if (size == 0)

  359.             return;

  360. 

  361.         uint8_t jdata[size];

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

  363. 

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

  365. 

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

  367.     }

  368. 

  369. private:

  370.     jack_client_t* const kClient;

  371.     jack_port_t*   const kPort;

  372. 

  373.     void*       fJackBuffer;

  374.     EngineEvent fRetEvent;

  375. 

  376.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaEngineJackEventPort)

  377. };

  378. 

  379. // -------------------------------------------------------------------------------------------------------------------

  380. // Jack Engine client

  381. 

  382. class CarlaEngineJackClient : public CarlaEngineClient

  383. {

  384. public:

  385.     CarlaEngineJackClient(const EngineType engineType, const ProcessMode processMode, jack_client_t* const client)

  386.         : CarlaEngineClient(engineType, processMode),

  387.           kClient(client),

  388.           kUseClient(processMode == PROCESS_MODE_SINGLE_CLIENT || processMode == PROCESS_MODE_MULTIPLE_CLIENTS)

  389.     {

  390.         carla_debug("CarlaEngineJackClient::CarlaEngineJackClient(%s, %s, %p)", EngineType2Str(engineType), ProcessMode2Str(processMode), client);

  391. 

  392.         if (kUseClient)

  393.         {

  394.             CARLA_ASSERT(kClient != nullptr);

  395.         }

  396.         else

  397.         {

  398.             CARLA_ASSERT(kClient == nullptr);

  399.         }

  400.     }

  401. 

  402.     ~CarlaEngineJackClient() override

  403.     {

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

  405. 

  406.         if (kProcessMode == PROCESS_MODE_MULTIPLE_CLIENTS && kClient != nullptr)

  407.             jackbridge_client_close(kClient);

  408.     }

  409. 

  410.     void activate() override

  411.     {

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

  413. 

  414.         if (kProcessMode == PROCESS_MODE_MULTIPLE_CLIENTS)

  415.         {

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

  417. 

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

  419.                 jackbridge_activate(kClient);

  420.         }

  421. 

  422.         CarlaEngineClient::activate();

  423.     }

  424. 

  425.     void deactivate() override

  426.     {

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

  428. 

  429.         if (kProcessMode == PROCESS_MODE_MULTIPLE_CLIENTS)

  430.         {

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

  432. 

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

  434.                 jackbridge_deactivate(kClient);

  435.         }

  436. 

  437.         CarlaEngineClient::deactivate();

  438.     }

  439. 

  440.     bool isOk() const override

  441.     {

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

  443. 

  444.         if (kUseClient)

  445.             return (kClient != nullptr);

  446. 

  447.         return CarlaEngineClient::isOk();

  448.     }

  449. 

  450. #if 0

  451.     void setLatency(const uint32_t samples) override

  452.     {

  453.         CarlaEngineClient::setLatency(samples);

  454. 

  455.         if (kUseClient)

  456.             jackbridge_recompute_total_latencies(kClient);

  457.     }

  458. #endif

  459. 

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

  461.     {

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

  463. 

  464.         jack_port_t* port = nullptr;

  465. 

  466.         // Create JACK port first, if needed

  467.         if (kUseClient)

  468.         {

  469.             switch (portType)

  470.             {

  471.             case kEnginePortTypeNull:

  472.                 break;

  473.             case kEnginePortTypeAudio:

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

  475.                 break;

  476.             case kEnginePortTypeEvent:

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

  478.                 break;

  479.             }

  480.         }

  481. 

  482.         // Create Engine port

  483.         switch (portType)

  484.         {

  485.         case kEnginePortTypeNull:

  486.             break;

  487.         case kEnginePortTypeAudio:

  488.             return new CarlaEngineJackAudioPort(isInput, kProcessMode, kClient, port);

  489.         case kEnginePortTypeEvent:

  490.             return new CarlaEngineJackEventPort(isInput, kProcessMode, kClient, port);

  491.         }

  492. 

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

  494.         return nullptr;

  495.     }

  496. 

  497. private:

  498.     jack_client_t* const kClient;

  499.     const bool           kUseClient;

  500. 

  501.     friend class CarlaEngineJack;

  502.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaEngineJackClient)

  503. };

  504. 

  505. // -------------------------------------------------------------------------------------------------------------------

  506. // Jack Engine

  507. 

  508. class CarlaEngineJack : public CarlaEngine

  509. {

  510. public:

  511.     CarlaEngineJack()

  512.         : CarlaEngine(),

  513.           fClient(nullptr),

  514.           fTransportState(JackTransportStopped),

  515.           fFreewheel(false),

  516. #ifdef BUILD_BRIDGE

  517.           fHasQuit(false)

  518. #else

  519. # ifdef CARLA_PROPER_CPP11_SUPPORT

  520.           fRackPorts{nullptr},

  521. # endif

  522.           fLastGroupId(0),

  523.           fLastPortId(0),

  524.           fLastConnectionId(0)

  525. #endif

  526.     {

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

  528. 

  529. #ifdef BUILD_BRIDGE

  530.         fOptions.processMode = PROCESS_MODE_MULTIPLE_CLIENTS;

  531. #else

  532. # ifndef CARLA_PROPER_CPP11_SUPPORT

  533.         carla_zeroStruct<jack_port_t*>(fRackPorts, rackPortCount);

  534. # endif

  535. #endif

  536. 

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

  538.         fOptions.transportMode = TRANSPORT_MODE_JACK;

  539. 

  540.         carla_zeroStruct<jack_position_t>(fTransportPos);

  541.     }

  542. 

  543.     ~CarlaEngineJack() override

  544.     {

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

  546.         CARLA_ASSERT(fClient == nullptr);

  547. 

  548. #ifndef BUILD_BRIDGE

  549.         fUsedGroupNames.clear();

  550.         fUsedPortNames.clear();

  551.         fUsedConnections.clear();

  552. #endif

  553.     }

  554. 

  555.     // -------------------------------------------------------------------

  556.     // Maximum values

  557. 

  558.     unsigned int maxClientNameSize() const override

  559.     {

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

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

  562. 

  563.         return CarlaEngine::maxClientNameSize();

  564.     }

  565. 

  566.     unsigned int maxPortNameSize() const override

  567.     {

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

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

  570. 

  571.         return CarlaEngine::maxPortNameSize();

  572.     }

  573. 

  574.     // -------------------------------------------------------------------

  575.     // Virtual, per-engine type calls

  576. 

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

  578.     {

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

  580. 

  581.         fFreewheel      = false;

  582.         fTransportState = JackTransportStopped;

  583. 

  584.         carla_zeroStruct<jack_position_t>(fTransportPos);

  585. 

  586. #ifndef BUILD_BRIDGE

  587.         fLastGroupId = 0;

  588.         fLastPortId  = 0;

  589.         fLastConnectionId = 0;

  590. 

  591.         fUsedGroupNames.clear();

  592.         fUsedPortNames.clear();

  593.         fUsedConnections.clear();

  594. 

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

  596. 

  597.         if (fClient != nullptr)

  598.         {

  599.             fBufferSize = jackbridge_get_buffer_size(fClient);

  600.             fSampleRate = jackbridge_get_sample_rate(fClient);

  601. 

  602.             jackbridge_set_buffer_size_callback(fClient, carla_jack_bufsize_callback, this);

  603.             jackbridge_set_sample_rate_callback(fClient, carla_jack_srate_callback, this);

  604.             jackbridge_set_freewheel_callback(fClient, carla_jack_freewheel_callback, this);

  605.             jackbridge_set_process_callback(fClient, carla_jack_process_callback, this);

  606.             jackbridge_on_shutdown(fClient, carla_jack_shutdown_callback, this);

  607. # if 0

  608.             jackbridge_set_latency_callback(fClient, carla_jack_latency_callback, this);

  609. # endif

  610. 

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

  612. 

  613.             initJackPatchbay(jackClientName);

  614. 

  615.             jackbridge_set_client_registration_callback(fClient, carla_jack_client_registration_callback, this);

  616.             jackbridge_set_port_registration_callback(fClient, carla_jack_port_registration_callback, this);

  617.             jackbridge_set_port_connect_callback(fClient, carla_jack_port_connect_callback, this);

  618.             jackbridge_set_port_rename_callback(fClient, carla_jack_port_rename_callback, this);

  619. 

  620.             if (fOptions.processMode == PROCESS_MODE_CONTINUOUS_RACK)

  621.             {

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

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

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

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

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

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

  628.             }

  629. 

  630.             if (jackbridge_activate(fClient))

  631.             {

  632.                 return CarlaEngine::init(jackClientName);

  633.             }

  634.             else

  635.             {

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

  637.                 jackbridge_client_close(fClient);

  638.                 fClient = nullptr;

  639.             }

  640.         }

  641.         else

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

  643. 

  644.         return false;

  645. #else

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

  647.         {

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

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

  650.             {

  651.                 fBufferSize = jackbridge_get_buffer_size(tmpClient);

  652.                 fSampleRate = jackbridge_get_sample_rate(tmpClient);

  653. 

  654.                 jackbridge_client_close(tmpClient);

  655.             }

  656.         }

  657. 

  658.         return CarlaEngine::init(clientName);

  659. #endif

  660.     }

  661. 

  662.     bool close() override

  663.     {

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

  665.         CarlaEngine::close();

  666. 

  667. #ifdef BUILD_BRIDGE

  668.         fClient  = nullptr;

  669.         fHasQuit = true;

  670.         return true;

  671. #else

  672.         if (jackbridge_deactivate(fClient))

  673.         {

  674.             if (fOptions.processMode == PROCESS_MODE_CONTINUOUS_RACK)

  675.             {

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

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

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

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

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

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

  682.             }

  683. 

  684.             if (jackbridge_client_close(fClient))

  685.             {

  686.                 fClient = nullptr;

  687.                 return true;

  688.             }

  689.             else

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

  691.         }

  692.         else

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

  694. 

  695.         fClient = nullptr;

  696. 

  697.         fUsedGroupNames.clear();

  698.         fUsedPortNames.clear();

  699.         fUsedConnections.clear();

  700. #endif

  701.         return false;

  702.     }

  703. 

  704.     bool isRunning() const override

  705.     {

  706. #ifdef BUILD_BRIDGE

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

  708. #else

  709.         return (fClient != nullptr);

  710. #endif

  711.     }

  712. 

  713.     bool isOffline() const override

  714.     {

  715.         return fFreewheel;

  716.     }

  717. 

  718.     EngineType type() const override

  719.     {

  720.         return kEngineTypeJack;

  721.     }

  722. 

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

  724.     {

  725.         jack_client_t* client = nullptr;

  726. 

  727. #ifdef BUILD_BRIDGE

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

  729. 

  730.         fBufferSize = jackbridge_get_buffer_size(client);

  731.         fSampleRate = jackbridge_get_sample_rate(client);

  732. 

  733.         jackbridge_set_buffer_size_callback(client, carla_jack_bufsize_callback, this);

  734.         jackbridge_set_sample_rate_callback(client, carla_jack_srate_callback, this);

  735.         jackbridge_set_freewheel_callback(client, carla_jack_freewheel_callback, this);

  736.         jackbridge_set_process_callback(client, carla_jack_process_callback, this);

  737.         jackbridge_on_shutdown(client, carla_jack_shutdown_callback, this);

  738. # if 0

  739.         jackbridge_set_latency_callback(client, carla_jack_latency_callback, this);

  740. # endif

  741. #else

  742.         if (fOptions.processMode == PROCESS_MODE_SINGLE_CLIENT)

  743.         {

  744.             client = fClient;

  745.         }

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

  747.         {

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

  749.             jackbridge_set_process_callback(client, carla_jack_process_callback_plugin, plugin);

  750. # if 0

  751.             jackbridge_set_latency_callback(client, carla_jack_latency_callback_plugin, plugin);

  752. # endif

  753.         }

  754. #endif

  755. 

  756.         return new CarlaEngineJackClient(kEngineTypeJack, fOptions.processMode, client);

  757.     }

  758. 

  759. #ifndef BUILD_BRIDGE

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

  761.     {

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

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

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

  765.         CARLA_ASSERT(newName != nullptr);

  766. 

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

  768.         {

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

  770.             return nullptr;

  771.         }

  772. 

  773.         CarlaPlugin* const plugin = kData->plugins[id].plugin;

  774. 

  775.         if (plugin == nullptr)

  776.         {

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

  778.             return nullptr;

  779.         }

  780. 

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

  782. 

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

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

  785. 

  786.         // JACK client rename

  787.         if (fOptions.processMode == PROCESS_MODE_MULTIPLE_CLIENTS)

  788.         {

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

  790. 

  791.             if (bridge.client_rename_ptr != nullptr)

  792.             {

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

  794.             }

  795.             else

  796.             {

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

  798.                 needsReinit = true;

  799. 

  800.                 plugin->setEnabled(false);

  801. 

  802.                 if (client->isActive())

  803.                     client->deactivate();

  804. 

  805.                 plugin->clearBuffers();

  806. 

  807.                 jackbridge_client_close(client->kClient);

  808. 

  809.                 jack_client_t* jclient = jackbridge_client_open(name, JackNullOption, nullptr);

  810.                 name = jackbridge_get_client_name(jclient);

  811. 

  812.                 jackbridge_set_process_callback(jclient, carla_jack_process_callback_plugin, plugin);

  813. # if 0

  814.                 jackbridge_set_latency_callback(jclient, carla_jack_latency_callback_plugin, plugin);

  815. # endif

  816. 

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

  818.             }

  819.         }

  820. 

  821.         if (name == nullptr)

  822.             return nullptr;

  823. 

  824.         // Rename

  825.         plugin->setName(name);

  826. 

  827.         if (needsReinit)

  828.         {

  829.             // reload plugin to recreate its ports

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

  831.             plugin->reload();

  832.             plugin->loadSaveState(saveState);

  833.         }

  834. 

  835.         return name;

  836.     }

  837. 

  838.     // -------------------------------------------------------------------

  839.     // Patchbay

  840. 

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

  842.     {

  843.         CARLA_ASSERT(fClient != nullptr);

  844. 

  845.         if (fClient == nullptr)

  846.         {

  847.             setLastError("Invalid JACK client");

  848.             return false;

  849.         }

  850. 

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

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

  853. 

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

  855.         {

  856.             setLastError("JACK operation failed");

  857.             return false;

  858.         }

  859. 

  860.         return true;

  861.     }

  862. 

  863.     bool patchbayDisconnect(int connectionId) override

  864.     {

  865.         CARLA_ASSERT(fClient != nullptr);

  866. 

  867.         if (fClient == nullptr)

  868.         {

  869.             setLastError("Invalid JACK client");

  870.             return false;

  871.         }

  872. 

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

  874.         {

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

  876.             {

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

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

  879. 

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

  881.                 {

  882.                     setLastError("JACK operation failed");

  883.                     return false;

  884.                 }

  885. 

  886.                 return true;

  887.             }

  888.         }

  889. 

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

  891.         return false;

  892.     }

  893. 

  894.     void patchbayRefresh() override

  895.     {

  896.         CARLA_ASSERT(fClient != nullptr);

  897. 

  898.         if (fClient == nullptr)

  899.             return;

  900. 

  901.         fLastGroupId = 0;

  902.         fLastPortId  = 0;

  903.         fLastConnectionId = 0;

  904. 

  905.         fUsedGroupNames.clear();

  906.         fUsedPortNames.clear();

  907.         fUsedConnections.clear();

  908. 

  909.         initJackPatchbay(jackbridge_get_client_name(fClient));

  910.     }

  911. #endif

  912. 

  913.     // -------------------------------------------------------------------

  914.     // Transport

  915. 

  916.     void transportPlay() override

  917.     {

  918.         if (fOptions.transportMode == TRANSPORT_MODE_INTERNAL)

  919.             CarlaEngine::transportPlay();

  920.         else if (fClient != nullptr)

  921.             jackbridge_transport_start(fClient);

  922.     }

  923. 

  924.     void transportPause() override

  925.     {

  926.         if (fOptions.transportMode == TRANSPORT_MODE_INTERNAL)

  927.             CarlaEngine::transportPause();

  928.         else if (fClient != nullptr)

  929.             jackbridge_transport_stop(fClient);

  930.     }

  931. 

  932.     void transportRelocate(const uint32_t frame) override

  933.     {

  934.         if (fOptions.transportMode == TRANSPORT_MODE_INTERNAL)

  935.             CarlaEngine::transportRelocate(frame);

  936.         else if (fClient != nullptr)

  937.             jackbridge_transport_locate(fClient, frame);

  938.     }

  939. 

  940.     // -------------------------------------

  941. 

  942. protected:

  943.     void handleJackBufferSizeCallback(const uint32_t newBufferSize)

  944.     {

  945.         if (fBufferSize == newBufferSize)

  946.             return;

  947. 

  948.         fBufferSize = newBufferSize;

  949.         bufferSizeChanged(newBufferSize);

  950.     }

  951. 

  952.     void handleJackSampleRateCallback(const double newSampleRate)

  953.     {

  954.         if (fSampleRate == newSampleRate)

  955.             return;

  956. 

  957.         fSampleRate = newSampleRate;

  958.         sampleRateChanged(newSampleRate);

  959.     }

  960. 

  961.     void handleJackFreewheelCallback(const bool isFreewheel)

  962.     {

  963.         fFreewheel = isFreewheel;

  964.     }

  965. 

  966.     void saveTransportInfo()

  967.     {

  968.         if (fOptions.transportMode != TRANSPORT_MODE_JACK)

  969.             return;

  970. 

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

  972. 

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

  974. 

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

  976. 

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

  978.         {

  979.             fTimeInfo.frame = fTransportPos.frame;

  980.             fTimeInfo.usecs = fTransportPos.usecs;

  981. 

  982.             if (fTransportPos.valid & JackPositionBBT)

  983.             {

  984.                 fTimeInfo.valid              = EngineTimeInfo::ValidBBT;

  985.                 fTimeInfo.bbt.bar            = fTransportPos.bar;

  986.                 fTimeInfo.bbt.beat           = fTransportPos.beat;

  987.                 fTimeInfo.bbt.tick           = fTransportPos.tick;

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

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

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

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

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

  993.             }

  994.             else

  995.                 fTimeInfo.valid = 0x0;

  996.         }

  997.         else

  998.         {

  999.             fTimeInfo.frame = 0;

  1000.             fTimeInfo.valid = 0x0;

  1001.         }

  1002.     }

  1003. 

  1004.     void handleJackProcessCallback(const uint32_t nframes)

  1005.     {

  1006.         saveTransportInfo();

  1007. 

  1008. #ifndef BUILD_BRIDGE

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

  1010.         {

  1011.             // pass-through

  1012.             if (fOptions.processMode == PROCESS_MODE_CONTINUOUS_RACK)

  1013.             {

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

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

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

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

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

  1019. 

  1020.                 CARLA_ASSERT(audioIn1 != nullptr);

  1021.                 CARLA_ASSERT(audioIn2 != nullptr);

  1022.                 CARLA_ASSERT(audioOut1 != nullptr);

  1023.                 CARLA_ASSERT(audioOut2 != nullptr);

  1024.                 CARLA_ASSERT(eventOut != nullptr);

  1025. 

  1026.                 carla_copyFloat(audioOut1, audioIn1, nframes);

  1027.                 carla_copyFloat(audioOut2, audioIn2, nframes);

  1028.                 jackbridge_midi_clear_buffer(eventOut);

  1029.             }

  1030. 

  1031.             return proccessPendingEvents();

  1032.         }

  1033. #endif

  1034. 

  1035. #ifdef BUILD_BRIDGE

  1036.         CarlaPlugin* const plugin = getPluginUnchecked(0);

  1037. 

  1038.         if (plugin && plugin->enabled() && plugin->tryLock())

  1039.         {

  1040.             plugin->initBuffers();

  1041.             processPlugin(plugin, nframes);

  1042.             plugin->unlock();

  1043.         }

  1044. #else

  1045.         if (fOptions.processMode == PROCESS_MODE_SINGLE_CLIENT)

  1046.         {

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

  1048.             {

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

  1050. 

  1051.                 if (plugin && plugin->enabled() && plugin->tryLock())

  1052.                 {

  1053.                     plugin->initBuffers();

  1054.                     processPlugin(plugin, nframes);

  1055.                     plugin->unlock();

  1056.                 }

  1057.             }

  1058.         }

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

  1060.         {

  1061.             // get buffers from jack

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

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

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

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

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

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

  1068. 

  1069.             // assert buffers

  1070.             CARLA_ASSERT(audioIn1 != nullptr);

  1071.             CARLA_ASSERT(audioIn2 != nullptr);

  1072.             CARLA_ASSERT(audioOut1 != nullptr);

  1073.             CARLA_ASSERT(audioOut2 != nullptr);

  1074.             CARLA_ASSERT(eventIn != nullptr);

  1075.             CARLA_ASSERT(eventOut != nullptr);

  1076. 

  1077.             // create audio buffers

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

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

  1080. 

  1081.             // initialize input events

  1082.             carla_zeroStruct<EngineEvent>(kData->bufEvent.in, INTERNAL_EVENT_COUNT);

  1083.             {

  1084.                 uint32_t engineEventIndex = 0;

  1085. 

  1086.                 jack_midi_event_t jackEvent;

  1087.                 const uint32_t jackEventCount = jackbridge_midi_get_event_count(eventIn);

  1088. 

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

  1090.                 {

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

  1092.                         continue;

  1093. 

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

  1095.                     engineEvent->clear();

  1096. 

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

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

  1099. 

  1100.                     engineEvent->time    = jackEvent.time;

  1101.                     engineEvent->channel = midiChannel;

  1102. 

  1103.                     if (MIDI_IS_STATUS_CONTROL_CHANGE(midiStatus))

  1104.                     {

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

  1106.                         engineEvent->type         = kEngineEventTypeControl;

  1107. 

  1108.                         if (MIDI_IS_CONTROL_BANK_SELECT(midiControl))

  1109.                         {

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

  1111. 

  1112.                             engineEvent->ctrl.type  = kEngineControlEventTypeMidiBank;

  1113.                             engineEvent->ctrl.param = midiBank;

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

  1115.                         }

  1116.                         else if (midiControl == MIDI_CONTROL_ALL_SOUND_OFF)

  1117.                         {

  1118.                             engineEvent->ctrl.type  = kEngineControlEventTypeAllSoundOff;

  1119.                             engineEvent->ctrl.param = 0;

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

  1121.                         }

  1122.                         else if (midiControl == MIDI_CONTROL_ALL_NOTES_OFF)

  1123.                         {

  1124.                             engineEvent->ctrl.type  = kEngineControlEventTypeAllNotesOff;

  1125.                             engineEvent->ctrl.param = 0;

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

  1127.                         }

  1128.                         else

  1129.                         {

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

  1131. 

  1132.                             engineEvent->ctrl.type  = kEngineControlEventTypeParameter;

  1133.                             engineEvent->ctrl.param = midiControl;

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

  1135.                         }

  1136.                     }

  1137.                     else if (MIDI_IS_STATUS_PROGRAM_CHANGE(midiStatus))

  1138.                     {

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

  1140.                         engineEvent->type         = kEngineEventTypeControl;

  1141. 

  1142.                         engineEvent->ctrl.type  = kEngineControlEventTypeMidiProgram;

  1143.                         engineEvent->ctrl.param = midiProgram;

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

  1145.                     }

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

  1147.                     {

  1148.                         engineEvent->type = kEngineEventTypeMidi;

  1149. 

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

  1151. 

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

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

  1154.                     }

  1155. 

  1156.                     if (engineEventIndex >= INTERNAL_EVENT_COUNT)

  1157.                         break;

  1158.                 }

  1159.             }

  1160. 

  1161.             // process rack

  1162.             processRack(inBuf, outBuf, nframes);

  1163. 

  1164.             // output control

  1165.             {

  1166.                 jackbridge_midi_clear_buffer(eventOut);

  1167. 

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

  1169.                 {

  1170.                     EngineEvent* const engineEvent = &kData->bufEvent.out[i];

  1171. 

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

  1173.                     uint8_t size    = 0;

  1174. 

  1175.                     switch (engineEvent->type)

  1176.                     {

  1177.                     case kEngineEventTypeNull:

  1178.                         break;

  1179. 

  1180.                     case kEngineEventTypeControl:

  1181.                     {

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

  1183. 

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

  1185.                         {

  1186.                             // FIXME?

  1187.                             ctrlEvent->type  = kEngineControlEventTypeMidiBank;

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

  1189.                             ctrlEvent->value = 0.0f;

  1190.                         }

  1191. 

  1192.                         switch (ctrlEvent->type)

  1193.                         {

  1194.                         case kEngineControlEventTypeNull:

  1195.                             break;

  1196.                         case kEngineControlEventTypeParameter:

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

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

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

  1200.                             size    = 3;

  1201.                             break;

  1202.                         case kEngineControlEventTypeMidiBank:

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

  1204.                             data[1] = MIDI_CONTROL_BANK_SELECT;

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

  1206.                             size    = 3;

  1207.                             break;

  1208.                         case kEngineControlEventTypeMidiProgram:

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

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

  1211.                             size    = 2;

  1212.                             break;

  1213.                         case kEngineControlEventTypeAllSoundOff:

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

  1215.                             data[1] = MIDI_CONTROL_ALL_SOUND_OFF;

  1216.                             size    = 2;

  1217.                             break;

  1218.                         case kEngineControlEventTypeAllNotesOff:

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

  1220.                             data[1] = MIDI_CONTROL_ALL_NOTES_OFF;

  1221.                             size    = 2;

  1222.                             break;

  1223.                         }

  1224.                         break;

  1225.                     }

  1226. 

  1227.                     case kEngineEventTypeMidi:

  1228.                     {

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

  1230. 

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

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

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

  1234.                         size    = midiEvent->size;

  1235.                         break;

  1236.                     }

  1237.                     }

  1238. 

  1239.                     if (size > 0)

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

  1241.                 }

  1242.             }

  1243.         }

  1244. #endif // ! BUILD_BRIDGE

  1245. 

  1246.         proccessPendingEvents();

  1247.     }

  1248. 

  1249. #if 0

  1250.     void handleJackLatencyCallback(const jack_latency_callback_mode_t mode)

  1251.     {

  1252.         if (fOptions.processMode != PROCESS_MODE_SINGLE_CLIENT)

  1253.             return;

  1254. 

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

  1256.         {

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

  1258. 

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

  1260.                 latencyPlugin(plugin, mode);

  1261.         }

  1262.     }

  1263. #endif

  1264. 

  1265. #ifndef BUILD_BRIDGE

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

  1267.     {

  1268.         if (reg)

  1269.         {

  1270.             GroupNameToId groupNameToId;

  1271.             groupNameToId.id   = fLastGroupId;

  1272.             groupNameToId.name = name;

  1273. 

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

  1275.             fUsedGroupNames.append(groupNameToId);

  1276.             fLastGroupId++;

  1277.         }

  1278.         else

  1279.         {

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

  1281.             {

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

  1283.                 {

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

  1285.                     fUsedGroupNames.takeAt(i);

  1286.                     break;

  1287.                 }

  1288.             }

  1289.         }

  1290.     }

  1291. 

  1292.     void handleJackPortRegistrationCallback(jack_port_id_t port, bool reg)

  1293.     {

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

  1295. 

  1296.         QString fullName(jackbridge_port_name(jackPort));

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

  1298.         int     groupId   = getGroupId(groupName);

  1299. 

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

  1301. 

  1302.         if (reg)

  1303.         {

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

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

  1306. 

  1307.             unsigned int portFlags = 0x0;

  1308.             portFlags |= portIsInput ? PATCHBAY_PORT_IS_INPUT : PATCHBAY_PORT_IS_OUTPUT;

  1309.             portFlags |= portIsAudio ? PATCHBAY_PORT_IS_AUDIO : PATCHBAY_PORT_IS_MIDI;

  1310. 

  1311.             PortNameToId portNameToId;

  1312.             portNameToId.groupId  = groupId;

  1313.             portNameToId.portId   = fLastPortId;

  1314.             portNameToId.name     = portName;

  1315.             portNameToId.fullName = fullName;

  1316. 

  1317.             fUsedPortNames.append(portNameToId);

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

  1319.             fLastPortId++;

  1320.         }

  1321.         else

  1322.         {

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

  1324.             {

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

  1326.                 {

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

  1328.                     fUsedPortNames.takeAt(i);

  1329.                     break;

  1330.                 }

  1331.             }

  1332.         }

  1333.     }

  1334. 

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

  1336.     {

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

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

  1339. 

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

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

  1342. 

  1343.         if (connect)

  1344.         {

  1345.             ConnectionToId connectionToId;

  1346.             connectionToId.id      = fLastConnectionId;

  1347.             connectionToId.portOut = portIdA;

  1348.             connectionToId.portIn  = portIdB;

  1349. 

  1350.             fUsedConnections.append(connectionToId);

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

  1352.             fLastConnectionId++;

  1353.         }

  1354.         else

  1355.         {

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

  1357.             {

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

  1359.                 {

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

  1361.                     fUsedConnections.takeAt(i);

  1362.                     break;

  1363.                 }

  1364.             }

  1365.         }

  1366.     }

  1367. 

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

  1369.     {

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

  1371. 

  1372.         QString fullName(oldName);

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

  1374.         int     groupId   = getGroupId(groupName);

  1375. 

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

  1377. 

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

  1379.         {

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

  1381.             {

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

  1383.                 fUsedPortNames[i].name = newName;

  1384.                 break;

  1385.             }

  1386.         }

  1387.     }

  1388. #endif

  1389. 

  1390.     void handleJackShutdownCallback()

  1391.     {

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

  1393.         {

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

  1395. 

  1396.             //if (plugin)

  1397.             //    plugin->x_client = nullptr;

  1398.         }

  1399. 

  1400.         fClient = nullptr;

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

  1402.     }

  1403. 

  1404.     // -------------------------------------

  1405. 

  1406. private:

  1407.     jack_client_t*         fClient;

  1408.     jack_position_t        fTransportPos;

  1409.     jack_transport_state_t fTransportState;

  1410.     bool fFreewheel;

  1411. 

  1412.     // -------------------------------------

  1413. 

  1414. #ifdef BUILD_BRIDGE

  1415.     bool fHasQuit;

  1416. #else

  1417.     enum RackPorts {

  1418.         rackPortAudioIn1  = 0,

  1419.         rackPortAudioIn2  = 1,

  1420.         rackPortAudioOut1 = 2,

  1421.         rackPortAudioOut2 = 3,

  1422.         rackPortEventIn   = 4,

  1423.         rackPortEventOut  = 5,

  1424.         rackPortCount     = 8

  1425.     };

  1426. 

  1427.     jack_port_t* fRackPorts[rackPortCount];

  1428. 

  1429.     struct GroupNameToId {

  1430.         int id;

  1431.         QString name;

  1432.     };

  1433. 

  1434.     struct PortNameToId {

  1435.         int groupId;

  1436.         int portId;

  1437.         QString name;

  1438.         QString fullName;

  1439.     };

  1440. 

  1441.     struct ConnectionToId {

  1442.         int id;

  1443.         int portOut;

  1444.         int portIn;

  1445.     };

  1446. 

  1447.     int fLastGroupId;

  1448.     int fLastPortId;

  1449.     int fLastConnectionId;

  1450. 

  1451.     QList<GroupNameToId>  fUsedGroupNames;

  1452.     QList<PortNameToId>   fUsedPortNames;

  1453.     QList<ConnectionToId> fUsedConnections;

  1454. 

  1455.     int getGroupId(QString groupName)

  1456.     {

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

  1458.         {

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

  1460.             {

  1461.                 return fUsedGroupNames[i].id;

  1462.             }

  1463.         }

  1464.         return -1;

  1465.     }

  1466. 

  1467.     int getPortId(QString fullPortName)

  1468.     {

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

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

  1471. 

  1472.         int groupId = getGroupId(groupName);

  1473. 

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

  1475.         {

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

  1477.             {

  1478.                 return fUsedPortNames[i].portId;

  1479.             }

  1480.         }

  1481. 

  1482.         return -1;

  1483.     }

  1484. 

  1485.     QString& getFullPortName(int portId)

  1486.     {

  1487.         static QString fallbackString;

  1488. 

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

  1490.         {

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

  1492.             {

  1493.                 return fUsedPortNames[i].fullName;

  1494.             }

  1495.         }

  1496. 

  1497.         return fallbackString;

  1498.     }

  1499. 

  1500.     void initJackPatchbay(const char* const ourName)

  1501.     {

  1502.         // query initial jack ports

  1503.         QList<QString> parsedGroups;

  1504. 

  1505.         // our client

  1506.         {

  1507.             GroupNameToId groupNameToId;

  1508.             groupNameToId.id   = fLastGroupId;

  1509.             groupNameToId.name = ourName;

  1510. 

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

  1512.             fUsedGroupNames.append(groupNameToId);

  1513.             fLastGroupId++;

  1514. 

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

  1516.         }

  1517. 

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

  1519.         {

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

  1521.             {

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

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

  1524. 

  1525.                 QString fullName(ports[i]);

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

  1527.                 int     groupId   = -1;

  1528. 

  1529.                 //if (groupName == ourName)

  1530.                 //    continue;

  1531. 

  1532.                 if (parsedGroups.contains(groupName))

  1533.                 {

  1534.                     groupId = getGroupId(groupName);

  1535.                 }

  1536.                 else

  1537.                 {

  1538.                     groupId = fLastGroupId++;

  1539. 

  1540.                     GroupNameToId groupNameToId;

  1541.                     groupNameToId.id   = groupId;

  1542.                     groupNameToId.name = groupName;

  1543. 

  1544.                     fUsedGroupNames.append(groupNameToId);

  1545.                     parsedGroups.append(groupName);

  1546. 

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

  1548.                 }

  1549. 

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

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

  1552. 

  1553.                 unsigned int portFlags = 0x0;

  1554.                 portFlags |= portIsInput ? PATCHBAY_PORT_IS_INPUT : PATCHBAY_PORT_IS_OUTPUT;

  1555.                 portFlags |= portIsAudio ? PATCHBAY_PORT_IS_AUDIO : PATCHBAY_PORT_IS_MIDI;

  1556. 

  1557.                 PortNameToId portNameToId;

  1558.                 portNameToId.groupId  = groupId;

  1559.                 portNameToId.portId   = fLastPortId;

  1560.                 portNameToId.name     = portName;

  1561.                 portNameToId.fullName = fullName;

  1562. 

  1563.                 fUsedPortNames.append(portNameToId);

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

  1565.                 fLastPortId++;

  1566.             }

  1567. 

  1568.             jackbridge_free(ports);

  1569.         }

  1570. 

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

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

  1573.         {

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

  1575.             {

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

  1577. 

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

  1579. 

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

  1581.                 {

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

  1583.                     {

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

  1585. 

  1586.                         ConnectionToId connectionToId;

  1587.                         connectionToId.id      = fLastConnectionId;

  1588.                         connectionToId.portOut = thisPortId;

  1589.                         connectionToId.portIn  = targetPortId;

  1590. 

  1591.                         fUsedConnections.append(connectionToId);

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

  1593.                         fLastConnectionId++;

  1594.                     }

  1595. 

  1596.                     jackbridge_free(jackConnections);

  1597.                 }

  1598.             }

  1599. 

  1600.             jackbridge_free(ports);

  1601.         }

  1602.     }

  1603. #endif

  1604. 

  1605.     // -------------------------------------

  1606. 

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

  1608.     {

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

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

  1611. 

  1612.         float* inBuffer[inCount];

  1613.         float* outBuffer[outCount];

  1614. 

  1615.         float inPeaks[inCount];

  1616.         float outPeaks[outCount];

  1617. 

  1618.         if (inCount > 0)

  1619.             carla_zeroFloat(inPeaks, inCount);

  1620.         if (outCount > 0)

  1621.             carla_zeroFloat(outPeaks, outCount);

  1622. 

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

  1624.         {

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

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

  1627.         }

  1628. 

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

  1630.         {

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

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

  1633.         }

  1634. 

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

  1636.         {

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

  1638.             {

  1639.                 const float absV = std::fabs(inBuffer[i][j]);

  1640. 

  1641.                 if (absV > inPeaks[i])

  1642.                     inPeaks[i] = absV;

  1643.             }

  1644.         }

  1645. 

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

  1647. 

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

  1649.         {

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

  1651.             {

  1652.                 const float absV = std::fabs(outBuffer[i][j]);

  1653. 

  1654.                 if (absV > outPeaks[i])

  1655.                     outPeaks[i] = absV;

  1656.             }

  1657.         }

  1658. 

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

  1660.     }

  1661. 

  1662. #if 0

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

  1664.     {

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

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

  1667. 

  1668.         jack_latency_range_t range;

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

  1670. 

  1671.         if (pluginLatency == 0)

  1672.             return;

  1673. 

  1674.         if (mode == JackCaptureLatency)

  1675.         {

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

  1677.             {

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

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

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

  1681. 

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

  1683.                 range.min += pluginLatency;

  1684.                 range.max += pluginLatency;

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

  1686.             }

  1687.         }

  1688.         else

  1689.         {

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

  1691.             {

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

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

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

  1695. 

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

  1697.                 range.min += pluginLatency;

  1698.                 range.max += pluginLatency;

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

  1700.             }

  1701.         }

  1702.     }

  1703. #endif

  1704. 

  1705.     // -------------------------------------

  1706. 

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

  1708. 

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

  1710.     {

  1711.         handlePtr->handleJackSampleRateCallback(newSampleRate);

  1712.         return 0;

  1713.     }

  1714. 

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

  1716.     {

  1717.         handlePtr->handleJackBufferSizeCallback(newBufferSize);

  1718.         return 0;

  1719.     }

  1720. 

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

  1722.     {

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

  1724.     }

  1725. 

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

  1727.     {

  1728.         handlePtr->handleJackProcessCallback(nframes);

  1729.         return 0;

  1730.     }

  1731. 

  1732. #if 0

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

  1734.     {

  1735.         handlePtr->handleJackLatencyCallback(mode);

  1736.     }

  1737. #endif

  1738. 

  1739. #ifndef BUILD_BRIDGE

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

  1741.     {

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

  1743.     }

  1744. 

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

  1746.     {

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

  1748.     }

  1749. 

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

  1751.     {

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

  1753.     }

  1754. 

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

  1756.     {

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

  1758.         return 0;

  1759.     }

  1760. #endif

  1761. 

  1762.     static void carla_jack_shutdown_callback(void* arg)

  1763.     {

  1764.         handlePtr->handleJackShutdownCallback();

  1765.     }

  1766. 

  1767.     #undef handlePtr

  1768. 

  1769.     // -------------------------------------

  1770. 

  1771. #ifndef BUILD_BRIDGE

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

  1773.     {

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

  1775. 

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

  1777.         {

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

  1779. 

  1780.             plugin->initBuffers();

  1781.             engine->saveTransportInfo();

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

  1783.             plugin->unlock();

  1784.         }

  1785.         else

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

  1787. 

  1788.         return 0;

  1789.     }

  1790. 

  1791. # if 0

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

  1793.     {

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

  1795. 

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

  1797.         {

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

  1799. 

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

  1801.         }

  1802.     }

  1803. # endif

  1804. #endif

  1805. 

  1806.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaEngineJack)

  1807. };

  1808. 

  1809. // -----------------------------------------

  1810. 

  1811. CarlaEngine* CarlaEngine::newJack()

  1812. {

  1813.     return new CarlaEngineJack();

  1814. }

  1815. 

  1816. // -----------------------------------------

  1817. 

  1818. CARLA_BACKEND_END_NAMESPACE