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.
3554 Commits
16 Branches
141MB
Tree: 3f0ecb6ce2
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '3f0ecb6ce2'
${ noResults }
Carla/source/interposer/libjack.cpp

1661 lines
49KB
Raw Blame History 

  1. /*

  2.  * Carla JACK API for external applications

  3.  * Copyright (C) 2016-2017 Filipe Coelho <falktx@falktx.com>

  4.  *

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

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

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

  8.  * the License, or any later version.

  9.  *

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

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

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

  13.  * GNU General Public License for more details.

  14.  *

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

  16.  */

  17. 

  18. // need to include this first

  19. #include "CarlaDefines.h"

  20. 

  21. // then define this for bridge utils

  22. #define BUILD_BRIDGE 1

  23. 

  24. // now include a bunch of stuff

  25. #include "CarlaBackendUtils.hpp"

  26. #include "CarlaBridgeUtils.hpp"

  27. #include "CarlaMIDI.h"

  28. #include "CarlaMutex.hpp"

  29. #include "LinkedList.hpp"

  30. 

  31. #include "AppConfig.h"

  32. #include "juce_core/juce_core.h"

  33. 

  34. #ifdef __SSE2_MATH__

  35. # include <xmmintrin.h>

  36. #endif

  37. 

  38. #if 0

  39. #include <jack/jack.h>

  40. #include <jack/midiport.h>

  41. #include <jack/transport.h>

  42. #include <jack/session.h>

  43. #include <jack/metadata.h>

  44. #endif

  45. 

  46. // must be last

  47. #include "jackbridge/JackBridge.hpp"

  48. 

  49. // small check to not hurt myself

  50. #ifdef JACKBRIDGE_DIRECT

  51. # error "Cannot create custom jack server while linking to libjack directly"

  52. #endif

  53. 

  54. using juce::File;

  55. using juce::MemoryBlock;

  56. using juce::String;

  57. using juce::Time;

  58. using juce::Thread;

  59. 

  60. CARLA_BACKEND_START_NAMESPACE

  61. 

  62. // --------------------------------------------------------------------------------------------------------------------

  63. 

  64. struct JackPortState {

  65.     char* name;

  66.     char* fullname;

  67.     void* buffer;

  68.     uint index;

  69.     uint flags;

  70.     bool isSystem;

  71. 

  72.     JackPortState()

  73.         : name(nullptr),

  74.           fullname(nullptr),

  75.           buffer(nullptr),

  76.           index(0),

  77.           flags(0),

  78.           isSystem(false) {}

  79. 

  80.     JackPortState(const char* const cn, const char* const pn, const uint i, const uint f, const bool sys)

  81.         : name(strdup(pn)),

  82.           fullname(nullptr),

  83.           buffer(nullptr),

  84.           index(i),

  85.           flags(f),

  86.           isSystem(sys)

  87.     {

  88.         char strBuf[STR_MAX+1];

  89.         snprintf(strBuf, STR_MAX, "%s:%s", cn, pn);

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

  91. 

  92.         fullname = strdup(strBuf);

  93.     }

  94. 

  95.     ~JackPortState()

  96.     {

  97.         free(name);

  98.         free(fullname);

  99.     }

  100. };

  101. 

  102. struct JackClientState {

  103.     bool activated;

  104.     bool prematurelyActivated;

  105. 

  106.     char* name;

  107. 

  108.     uint32_t bufferSize;

  109.     double   sampleRate;

  110. 

  111.     bool playing;

  112.     jack_position_t position;

  113. 

  114.     LinkedList<JackPortState*> audioIns;

  115.     LinkedList<JackPortState*> audioOuts;

  116.     uint32_t fakeIns, fakeOuts;

  117. 

  118.     LinkedList<JackPortState> midiIns;

  119.     LinkedList<JackPortState> midiOuts;

  120. 

  121.     JackProcessCallback process;

  122.     void* processPtr;

  123. 

  124.     JackShutdownCallback shutdown;

  125.     void* shutdownPtr;

  126. 

  127.     JackClientState()

  128.         : activated(false),

  129.           prematurelyActivated(false),

  130.           name(nullptr),

  131.           bufferSize(0),

  132.           sampleRate(0.0),

  133.           playing(false),

  134.           audioIns(),

  135.           audioOuts(),

  136.           fakeIns(0),

  137.           fakeOuts(0),

  138.           midiIns(),

  139.           midiOuts(),

  140.           process(nullptr),

  141.           processPtr(nullptr),

  142.           shutdown(nullptr),

  143.           shutdownPtr(nullptr)

  144.     {

  145.         carla_zeroStruct(position);

  146.     }

  147. 

  148.     ~JackClientState()

  149.     {

  150.         free(name);

  151.     }

  152. };

  153. 

  154. class CarlaJackClient : public Thread

  155. {

  156. public:

  157.     JackClientState fState;

  158. 

  159.     CarlaJackClient(const char* const audioPoolBaseName, const char* const rtClientBaseName, const char* const nonRtClientBaseName, const char* const nonRtServerBaseName)

  160.         : Thread("CarlaJackClient"),

  161.           fState(),

  162.           fShmAudioPool(),

  163.           fShmRtClientControl(),

  164.           fShmNonRtClientControl(),

  165.           fShmNonRtServerControl(),

  166.           fBaseNameAudioPool(audioPoolBaseName),

  167.           fBaseNameRtClientControl(rtClientBaseName),

  168.           fBaseNameNonRtClientControl(nonRtClientBaseName),

  169.           fBaseNameNonRtServerControl(nonRtServerBaseName),

  170.           fIsOffline(false),

  171.           fFirstIdle(true),

  172.           fLastPingTime(-1),

  173.           fAudioIns(0),

  174.           fAudioOuts(0)

  175.     {

  176.         carla_debug("CarlaJackClient::CarlaJackClient(\"%s\", \"%s\", \"%s\", \"%s\")", audioPoolBaseName, rtClientBaseName, nonRtClientBaseName, nonRtServerBaseName);

  177.     }

  178. 

  179.     ~CarlaJackClient() noexcept override

  180.     {

  181.         carla_debug("CarlaJackClient::~CarlaJackClient()");

  182. 

  183.         clear();

  184.     }

  185. 

  186.     bool init(const char* const clientName)

  187.     {

  188.         carla_debug("CarlaJackClient::init(\"%s\")", clientName);

  189. 

  190.         if (! fShmAudioPool.attachClient(fBaseNameAudioPool))

  191.         {

  192.             carla_stderr("Failed to attach to audio pool shared memory");

  193.             return false;

  194.         }

  195. 

  196.         if (! fShmRtClientControl.attachClient(fBaseNameRtClientControl))

  197.         {

  198.             clear();

  199.             carla_stderr("Failed to attach to rt client control shared memory");

  200.             return false;

  201.         }

  202. 

  203.         if (! fShmRtClientControl.mapData())

  204.         {

  205.             clear();

  206.             carla_stderr("Failed to map rt client control shared memory");

  207.             return false;

  208.         }

  209. 

  210.         if (! fShmNonRtClientControl.attachClient(fBaseNameNonRtClientControl))

  211.         {

  212.             clear();

  213.             carla_stderr("Failed to attach to non-rt client control shared memory");

  214.             return false;

  215.         }

  216. 

  217.         if (! fShmNonRtClientControl.mapData())

  218.         {

  219.             clear();

  220.             carla_stderr("Failed to map non-rt control client shared memory");

  221.             return false;

  222.         }

  223. 

  224.         if (! fShmNonRtServerControl.attachClient(fBaseNameNonRtServerControl))

  225.         {

  226.             clear();

  227.             carla_stderr("Failed to attach to non-rt server control shared memory");

  228.             return false;

  229.         }

  230. 

  231.         if (! fShmNonRtServerControl.mapData())

  232.         {

  233.             clear();

  234.             carla_stderr("Failed to map non-rt control server shared memory");

  235.             return false;

  236.         }

  237. 

  238.         PluginBridgeNonRtClientOpcode opcode;

  239. 

  240.         opcode = fShmNonRtClientControl.readOpcode();

  241.         CARLA_SAFE_ASSERT_INT(opcode == kPluginBridgeNonRtClientNull, opcode);

  242. 

  243.         const uint32_t shmRtClientDataSize = fShmNonRtClientControl.readUInt();

  244.         CARLA_SAFE_ASSERT_INT2(shmRtClientDataSize == sizeof(BridgeRtClientData), shmRtClientDataSize, sizeof(BridgeRtClientData));

  245. 

  246.         const uint32_t shmNonRtClientDataSize = fShmNonRtClientControl.readUInt();

  247.         CARLA_SAFE_ASSERT_INT2(shmNonRtClientDataSize == sizeof(BridgeNonRtClientData), shmNonRtClientDataSize, sizeof(BridgeNonRtClientData));

  248. 

  249.         const uint32_t shmNonRtServerDataSize = fShmNonRtClientControl.readUInt();

  250.         CARLA_SAFE_ASSERT_INT2(shmNonRtServerDataSize == sizeof(BridgeNonRtServerData), shmNonRtServerDataSize, sizeof(BridgeNonRtServerData));

  251. 

  252.         if (shmRtClientDataSize != sizeof(BridgeRtClientData) || shmNonRtClientDataSize != sizeof(BridgeNonRtClientData) || shmNonRtServerDataSize != sizeof(BridgeNonRtServerData))

  253.         {

  254.             carla_stderr2("CarlaJackClient: data size mismatch");

  255.             return false;

  256.         }

  257. 

  258.         opcode = fShmNonRtClientControl.readOpcode();

  259.         CARLA_SAFE_ASSERT_INT(opcode == kPluginBridgeNonRtClientSetBufferSize, opcode);

  260.         fState.bufferSize = fShmNonRtClientControl.readUInt();

  261. 

  262.         opcode = fShmNonRtClientControl.readOpcode();

  263.         CARLA_SAFE_ASSERT_INT(opcode == kPluginBridgeNonRtClientSetSampleRate, opcode);

  264.         fState.sampleRate = fShmNonRtClientControl.readDouble();

  265. 

  266.         if (fState.bufferSize == 0 || carla_isZero(fState.sampleRate))

  267.         {

  268.             carla_stderr2("CarlaJackClient: invalid empty state");

  269.             return false;

  270.         }

  271. 

  272.         fState.name = strdup(clientName);

  273. 

  274.         // tell backend we're live

  275.         {

  276.             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  277. 

  278.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPong);

  279.             fShmNonRtServerControl.commitWrite();

  280.         }

  281. 

  282.         startThread(10);

  283. 

  284.         return true;

  285.     }

  286. 

  287.     bool close()

  288.     {

  289.         carla_debug("CarlaEnginePlugin::close()");

  290.         fLastPingTime = -1;

  291. 

  292.         stopThread(5000);

  293.         clear();

  294. 

  295.         for (LinkedList<JackPortState*>::Itenerator it = fState.audioIns.begin2(); it.valid(); it.next())

  296.         {

  297.             if (JackPortState* const jport = it.getValue(nullptr))

  298.                 delete jport;

  299.         }

  300. 

  301.         for (LinkedList<JackPortState*>::Itenerator it = fState.audioOuts.begin2(); it.valid(); it.next())

  302.         {

  303.             if (JackPortState* const jport = it.getValue(nullptr))

  304.                 delete jport;

  305.         }

  306. 

  307.         fState.audioIns.clear();

  308.         fState.audioOuts.clear();

  309. 

  310.         return true;

  311.     }

  312. 

  313.     void clear() noexcept

  314.     {

  315.         fShmAudioPool.clear();

  316.         fShmRtClientControl.clear();

  317.         fShmNonRtClientControl.clear();

  318.         fShmNonRtServerControl.clear();

  319.     }

  320. 

  321.     void activate()

  322.     {

  323.         const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  324.         const bool wasFirstIdle(fFirstIdle);

  325. 

  326.         if (wasFirstIdle)

  327.         {

  328.             fFirstIdle = false;

  329.             fLastPingTime = Time::currentTimeMillis();

  330.             CARLA_SAFE_ASSERT(fLastPingTime > 0);

  331. 

  332.             if (fState.audioIns.count() == 0 && fState.audioOuts.count() == 0)

  333.             {

  334.                 carla_stderr("Create 2 ins, 2 outs prematurely for the client");

  335.                 fState.audioIns.append(new JackPortState(fState.name, "in_1", 0, JackPortIsOutput, false));

  336.                 fState.audioIns.append(new JackPortState(fState.name, "in_2", 1, JackPortIsOutput, false));

  337.                 fState.fakeIns = 2;

  338. 

  339.                 fState.audioOuts.append(new JackPortState(fState.name, "out_1", 0, JackPortIsInput, false));

  340.                 fState.audioOuts.append(new JackPortState(fState.name, "out_2", 1, JackPortIsInput, false));

  341.                 fState.fakeOuts = 2;

  342. 

  343.                 fState.prematurelyActivated = true;

  344.             }

  345. 

  346.             char bufStr[STR_MAX+1];

  347.             uint32_t bufStrSize;

  348. 

  349.             // kPluginBridgeNonRtServerPluginInfo1

  350.             {

  351.                 // uint/category, uint/hints, uint/optionsAvailable, uint/optionsEnabled, long/uniqueId

  352.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPluginInfo1);

  353.                 fShmNonRtServerControl.writeUInt(PLUGIN_CATEGORY_NONE);

  354.                 fShmNonRtServerControl.writeUInt(0x0);

  355.                 fShmNonRtServerControl.writeUInt(0x0);

  356.                 fShmNonRtServerControl.writeUInt(0x0);

  357.                 fShmNonRtServerControl.writeLong(0);

  358.                 fShmNonRtServerControl.commitWrite();

  359.             }

  360. 

  361.             // kPluginBridgeNonRtServerPluginInfo2

  362.             {

  363.                 // uint/size, str[] (realName), uint/size, str[] (label), uint/size, str[] (maker), uint/size, str[] (copyright)

  364.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPluginInfo2);

  365. 

  366.                 carla_zeroChars(bufStr, STR_MAX);

  367.                 std::strncpy(bufStr, fState.name, 64);

  368.                 bufStrSize = carla_fixedValue(1U, 64U, static_cast<uint32_t>(std::strlen(bufStr)));

  369.                 fShmNonRtServerControl.writeUInt(bufStrSize);

  370.                 fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  371. 

  372.                 carla_zeroChars(bufStr, STR_MAX);

  373. 

  374.                 bufStrSize = 1;

  375.                 fShmNonRtServerControl.writeUInt(bufStrSize);

  376.                 fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  377. 

  378.                 fShmNonRtServerControl.writeUInt(bufStrSize);

  379.                 fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  380. 

  381.                 fShmNonRtServerControl.writeUInt(bufStrSize);

  382.                 fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);

  383. 

  384.                 fShmNonRtServerControl.commitWrite();

  385.             }

  386. 

  387.             // kPluginBridgeNonRtServerAudioCount

  388.             {

  389.                 const uint32_t aIns  = fState.audioIns.count();

  390.                 const uint32_t aOuts = fState.audioOuts.count();

  391. 

  392.                 // uint/ins, uint/outs

  393.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerAudioCount);

  394.                 fShmNonRtServerControl.writeUInt(aIns);

  395.                 fShmNonRtServerControl.writeUInt(aOuts);

  396.                 fShmNonRtServerControl.commitWrite();

  397. 

  398.                 // kPluginBridgeNonRtServerPortName

  399.                 for (uint32_t i=0; i<aIns; ++i)

  400.                 {

  401.                     const JackPortState* const jport(fState.audioIns.getAt(i, nullptr));

  402.                     CARLA_SAFE_ASSERT_CONTINUE(jport != nullptr);

  403. 

  404.                     const char* const portName(jport->name);

  405.                     CARLA_SAFE_ASSERT_CONTINUE(portName != nullptr && portName[0] != '\0');

  406. 

  407.                     // byte/type, uint/index, uint/size, str[] (name)

  408.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPortName);

  409.                     fShmNonRtServerControl.writeByte(kPluginBridgePortAudioInput);

  410.                     fShmNonRtServerControl.writeUInt(i);

  411. 

  412.                     bufStrSize = static_cast<uint32_t>(std::strlen(portName));

  413.                     fShmNonRtServerControl.writeUInt(bufStrSize);

  414.                     fShmNonRtServerControl.writeCustomData(portName, bufStrSize);

  415.                 }

  416. 

  417.                 // kPluginBridgeNonRtServerPortName

  418.                 for (uint32_t i=0; i<aOuts; ++i)

  419.                 {

  420.                     const JackPortState* const jport(fState.audioOuts.getAt(i, nullptr));

  421.                     CARLA_SAFE_ASSERT_CONTINUE(jport != nullptr);

  422. 

  423.                     const char* const portName(jport->name);

  424.                     CARLA_SAFE_ASSERT_CONTINUE(portName != nullptr && portName[0] != '\0');

  425. 

  426.                     // byte/type, uint/index, uint/size, str[] (name)

  427.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPortName);

  428.                     fShmNonRtServerControl.writeByte(kPluginBridgePortAudioOutput);

  429.                     fShmNonRtServerControl.writeUInt(i);

  430. 

  431.                     bufStrSize = static_cast<uint32_t>(std::strlen(portName));

  432.                     fShmNonRtServerControl.writeUInt(bufStrSize);

  433.                     fShmNonRtServerControl.writeCustomData(portName, bufStrSize);

  434.                 }

  435.             }

  436. 

  437.             fShmNonRtServerControl.waitIfDataIsReachingLimit();

  438. 

  439.             // kPluginBridgeNonRtServerMidiCount

  440.             {

  441.                 const uint32_t mIns  = fState.midiIns.count();

  442.                 const uint32_t mOuts = fState.midiOuts.count();

  443. 

  444.                 // uint/ins, uint/outs

  445.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerMidiCount);

  446.                 fShmNonRtServerControl.writeUInt(mIns);

  447.                 fShmNonRtServerControl.writeUInt(mOuts);

  448.                 fShmNonRtServerControl.commitWrite();

  449.             }

  450. 

  451.             fShmNonRtServerControl.waitIfDataIsReachingLimit();

  452. 

  453.             // ready!

  454.             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerReady);

  455.             fShmNonRtServerControl.commitWrite();

  456.             fShmNonRtServerControl.waitIfDataIsReachingLimit();

  457. 

  458.             // must be static

  459.             fAudioIns = fState.audioIns.count();

  460.             fAudioOuts = fState.audioOuts.count();

  461. 

  462.             carla_stdout("Carla Jack Client Ready!");

  463.             fLastPingTime = Time::currentTimeMillis();

  464.         }

  465. 

  466.         fState.activated = true;

  467.     }

  468. 

  469.     void deactivate()

  470.     {

  471.         const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  472. 

  473.         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerUiClosed);

  474.         fShmNonRtServerControl.commitWrite();

  475. 

  476.         fState.activated = false;

  477.         fState.prematurelyActivated = false;

  478. 

  479.         for (LinkedList<JackPortState*>::Itenerator it = fState.audioIns.begin2(); it.valid(); it.next())

  480.         {

  481.             if (JackPortState* const jport = it.getValue(nullptr))

  482.                 delete jport;

  483.         }

  484. 

  485.         for (LinkedList<JackPortState*>::Itenerator it = fState.audioOuts.begin2(); it.valid(); it.next())

  486.         {

  487.             if (JackPortState* const jport = it.getValue(nullptr))

  488.                 delete jport;

  489.         }

  490. 

  491.         fState.audioIns.clear();

  492.         fState.audioOuts.clear();

  493.     }

  494. 

  495.     void handleNonRtData()

  496.     {

  497.         for (; fShmNonRtClientControl.isDataAvailableForReading();)

  498.         {

  499.             const PluginBridgeNonRtClientOpcode opcode(fShmNonRtClientControl.readOpcode());

  500. 

  501. // #ifdef DEBUG

  502.             if (opcode != kPluginBridgeNonRtClientPing)

  503.             {

  504.                 static int shownNull = 0;

  505.                 if (opcode == kPluginBridgeNonRtClientNull)

  506.                 {

  507.                     if (shownNull > 5)

  508.                         continue;

  509.                     ++shownNull;

  510.                 }

  511.                 carla_stdout("CarlaJackClient::handleNonRtData() - got opcode: %s", PluginBridgeNonRtClientOpcode2str(opcode));

  512.             }

  513. // #endif

  514. 

  515.             if (opcode != kPluginBridgeNonRtClientNull && opcode != kPluginBridgeNonRtClientPingOnOff && fLastPingTime > 0)

  516.                 fLastPingTime = Time::currentTimeMillis();

  517. 

  518.             switch (opcode)

  519.             {

  520.             case kPluginBridgeNonRtClientNull:

  521.                 break;

  522. 

  523.             case kPluginBridgeNonRtClientPing: {

  524.                 const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  525. 

  526.                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPong);

  527.                 fShmNonRtServerControl.commitWrite();

  528.             }   break;

  529. 

  530.             case kPluginBridgeNonRtClientPingOnOff: {

  531.                 const uint32_t onOff(fShmNonRtClientControl.readBool());

  532. 

  533.                 fLastPingTime = onOff ? Time::currentTimeMillis() : -1;

  534.             }   break;

  535. 

  536.             case kPluginBridgeNonRtClientActivate:

  537.             case kPluginBridgeNonRtClientDeactivate:

  538.                 break;

  539. 

  540.             case kPluginBridgeNonRtClientSetBufferSize:

  541.                 fShmNonRtClientControl.readUInt();

  542.                 //bufferSizeChanged();

  543.                 break;

  544. 

  545.             case kPluginBridgeNonRtClientSetSampleRate:

  546.                 fShmNonRtClientControl.readDouble();

  547.                 //sampleRateChanged();

  548.                 break;

  549. 

  550.             case kPluginBridgeNonRtClientSetOffline:

  551.                 fIsOffline = true;

  552.                 //offlineModeChanged(true);

  553.                 break;

  554. 

  555.             case kPluginBridgeNonRtClientSetOnline:

  556.                 fIsOffline = false;

  557.                 //offlineModeChanged(false);

  558.                 break;

  559. 

  560.             case kPluginBridgeNonRtClientSetParameterValue:

  561.             case kPluginBridgeNonRtClientSetParameterMidiChannel:

  562.             case kPluginBridgeNonRtClientSetParameterMidiCC:

  563.             case kPluginBridgeNonRtClientSetProgram:

  564.             case kPluginBridgeNonRtClientSetMidiProgram:

  565.             case kPluginBridgeNonRtClientSetCustomData:

  566.             case kPluginBridgeNonRtClientSetChunkDataFile:

  567.                 break;

  568. 

  569.             case kPluginBridgeNonRtClientSetOption:

  570.                 fShmNonRtClientControl.readUInt();

  571.                 fShmNonRtClientControl.readBool();

  572.                 break;

  573. 

  574.             case kPluginBridgeNonRtClientSetCtrlChannel:

  575.                 fShmNonRtClientControl.readShort();

  576.                 break;

  577. 

  578.             case kPluginBridgeNonRtClientPrepareForSave:

  579.                 {

  580.                     const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  581. 

  582.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSaved);

  583.                     fShmNonRtServerControl.commitWrite();

  584.                 }

  585.                 break;

  586. 

  587.             case kPluginBridgeNonRtClientShowUI:

  588.             case kPluginBridgeNonRtClientHideUI:

  589.             case kPluginBridgeNonRtClientUiParameterChange:

  590.             case kPluginBridgeNonRtClientUiProgramChange:

  591.             case kPluginBridgeNonRtClientUiMidiProgramChange:

  592.             case kPluginBridgeNonRtClientUiNoteOn:

  593.             case kPluginBridgeNonRtClientUiNoteOff:

  594.                 break;

  595. 

  596.             case kPluginBridgeNonRtClientQuit:

  597.                 signalThreadShouldExit();

  598.                 break;

  599.             }

  600.         }

  601.     }

  602. 

  603.     // -------------------------------------------------------------------

  604. 

  605. protected:

  606.     void run() override

  607.     {

  608.         carla_stderr("CarlaJackClient run START");

  609. 

  610. #ifdef __SSE2_MATH__

  611.         // Set FTZ and DAZ flags

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

  613. #endif

  614. 

  615.         bool quitReceived = false;

  616. 

  617.         for (; ! quitReceived && ! threadShouldExit();)

  618.         {

  619.             handleNonRtData();

  620. 

  621.             const BridgeRtClientControl::WaitHelper helper(fShmRtClientControl);

  622. 

  623.             if (! helper.ok)

  624.                 continue;

  625. 

  626.             for (; fShmRtClientControl.isDataAvailableForReading();)

  627.             {

  628.                 const PluginBridgeRtClientOpcode opcode(fShmRtClientControl.readOpcode());

  629. //#ifdef DEBUG

  630.                 if (opcode != kPluginBridgeRtClientProcess && opcode != kPluginBridgeRtClientMidiEvent)

  631.                 {

  632.                     carla_stdout("CarlaJackClientRtThread::run() - got opcode: %s", PluginBridgeRtClientOpcode2str(opcode));

  633.                 }

  634. //#endif

  635. 

  636.                 switch (opcode)

  637.                 {

  638.                 case kPluginBridgeRtClientNull:

  639.                     break;

  640. 

  641.                 case kPluginBridgeRtClientSetAudioPool: {

  642.                     if (fShmAudioPool.data != nullptr)

  643.                     {

  644.                         jackbridge_shm_unmap(fShmAudioPool.shm, fShmAudioPool.data);

  645.                         fShmAudioPool.data = nullptr;

  646.                     }

  647.                     const uint64_t poolSize(fShmRtClientControl.readULong());

  648.                     CARLA_SAFE_ASSERT_BREAK(poolSize > 0);

  649.                     fShmAudioPool.data = (float*)jackbridge_shm_map(fShmAudioPool.shm, static_cast<size_t>(poolSize));

  650.                     break;

  651.                 }

  652. 

  653.                 case kPluginBridgeRtClientControlEventParameter:

  654.                 case kPluginBridgeRtClientControlEventMidiBank:

  655.                 case kPluginBridgeRtClientControlEventMidiProgram:

  656.                 case kPluginBridgeRtClientControlEventAllSoundOff:

  657.                 case kPluginBridgeRtClientControlEventAllNotesOff:

  658.                 case kPluginBridgeRtClientMidiEvent:

  659.                     break;

  660. 

  661.                 case kPluginBridgeRtClientProcess: {

  662.                     CARLA_SAFE_ASSERT_BREAK(fShmAudioPool.data != nullptr);

  663. 

  664.                     const CarlaMutexTryLocker cmtl(fRealtimeThreadMutex);

  665. 

  666.                     if (cmtl.wasLocked())

  667.                     {

  668.                         float* fdata = fShmAudioPool.data;

  669. 

  670.                         if (fState.process == nullptr || ! fState.activated)

  671.                         {

  672.                             for (uint32_t i=0; i<fAudioIns; ++i)

  673.                                 fdata += fState.bufferSize*fAudioIns;

  674. 

  675.                             if (fAudioOuts > 0)

  676.                                 carla_zeroFloats(fdata, fState.bufferSize*fAudioOuts);

  677. 

  678.                             if (! fState.activated)

  679.                             {

  680.                                 fShmRtClientControl.data->procFlags = 1;

  681.                             }

  682.                         }

  683.                         else

  684.                         {

  685.                             const BridgeTimeInfo& bridgeTimeInfo(fShmRtClientControl.data->timeInfo);

  686. 

  687.                             uint32_t i = 0;

  688.                             for (LinkedList<JackPortState*>::Itenerator it = fState.audioIns.begin2(); it.valid(); it.next())

  689.                             {

  690.                                 CARLA_SAFE_ASSERT_BREAK(i++ < fAudioIns);

  691.                                 if (JackPortState* const jport = it.getValue(nullptr))

  692.                                     jport->buffer = fdata;

  693.                                 fdata += fState.bufferSize;

  694.                             }

  695. 

  696.                             i=0;

  697.                             for (LinkedList<JackPortState*>::Itenerator it = fState.audioOuts.begin2(); it.valid(); it.next())

  698.                             {

  699.                                 CARLA_SAFE_ASSERT_BREAK(i++ < fAudioOuts);

  700.                                 if (JackPortState* const jport = it.getValue(nullptr))

  701.                                     jport->buffer = fdata;

  702.                                 fdata += fState.bufferSize;

  703.                             }

  704. 

  705.                             fState.playing        = bridgeTimeInfo.playing;

  706.                             fState.position.frame = bridgeTimeInfo.frame;

  707.                             fState.position.usecs = bridgeTimeInfo.usecs;

  708. 

  709.                             if (bridgeTimeInfo.valid & 0x1 /* kValidBBT */)

  710.                             {

  711.                                 fState.position.valid = JackPositionBBT;

  712. 

  713.                                 fState.position.bar  = bridgeTimeInfo.bar;

  714.                                 fState.position.beat = bridgeTimeInfo.beat;

  715.                                 fState.position.tick = bridgeTimeInfo.tick;

  716. 

  717.                                 fState.position.beats_per_bar = bridgeTimeInfo.beatsPerBar;

  718.                                 fState.position.beat_type     = bridgeTimeInfo.beatType;

  719. 

  720.                                 fState.position.ticks_per_beat   = bridgeTimeInfo.ticksPerBeat;

  721.                                 fState.position.beats_per_minute = bridgeTimeInfo.beatsPerMinute;

  722.                                 fState.position.bar_start_tick   = bridgeTimeInfo.barStartTick;

  723.                             }

  724.                             else

  725.                             {

  726.                                 fState.position.valid = static_cast<jack_position_bits_t>(0);

  727.                             }

  728. 

  729.                             fState.process(fState.bufferSize, fState.processPtr);

  730.                         }

  731.                     }

  732.                     else

  733.                     {

  734.                         carla_stderr2("CarlaJackClient: fRealtimeThreadMutex tryLock failed");

  735.                     }

  736. 

  737.                     carla_zeroBytes(fShmRtClientControl.data->midiOut, kBridgeRtClientDataMidiOutSize);

  738.                     break;

  739.                 }

  740. 

  741.                 case kPluginBridgeRtClientQuit:

  742.                     quitReceived = true;

  743.                     signalThreadShouldExit();

  744.                     break;

  745.                 }

  746.             }

  747.         }

  748. 

  749.         //callback(ENGINE_CALLBACK_ENGINE_STOPPED, 0, 0, 0, 0.0f, nullptr);

  750. 

  751.         if (quitReceived)

  752.         {

  753.             carla_stderr("CarlaJackClient run END - quit by carla");

  754. 

  755.             ::kill(::getpid(), SIGTERM);

  756.         }

  757.         else

  758.         {

  759.             const char* const message("Plugin bridge error, process thread has stopped");

  760.             const std::size_t messageSize(std::strlen(message));

  761. 

  762.             bool activated;

  763. 

  764.             {

  765.                 const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);

  766.                 activated = fState.activated;

  767. 

  768.                 if (activated)

  769.                 {

  770.                     carla_stderr("CarlaJackClient run END - quit error");

  771. 

  772.                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerError);

  773.                     fShmNonRtServerControl.writeUInt(messageSize);

  774.                     fShmNonRtServerControl.writeCustomData(message, messageSize);

  775.                     fShmNonRtServerControl.commitWrite();

  776.                 }

  777.                 else

  778.                 {

  779.                     carla_stderr("CarlaJackClient run END - quit itself");

  780.                 }

  781.             }

  782. 

  783.             if (activated && fState.shutdown != nullptr)

  784.                 fState.shutdown(fState.shutdownPtr);

  785.         }

  786.     }

  787. 

  788. private:

  789.     BridgeAudioPool          fShmAudioPool;

  790.     BridgeRtClientControl    fShmRtClientControl;

  791.     BridgeNonRtClientControl fShmNonRtClientControl;

  792.     BridgeNonRtServerControl fShmNonRtServerControl;

  793. 

  794.     CarlaString fBaseNameAudioPool;

  795.     CarlaString fBaseNameRtClientControl;

  796.     CarlaString fBaseNameNonRtClientControl;

  797.     CarlaString fBaseNameNonRtServerControl;

  798. 

  799.     bool fIsOffline;

  800.     bool fFirstIdle;

  801.     int64_t fLastPingTime;

  802. 

  803.     uint32_t fAudioIns;

  804.     uint32_t fAudioOuts;

  805. 

  806.     CarlaMutex fRealtimeThreadMutex;

  807. 

  808.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaJackClient)

  809. };

  810. 

  811. CARLA_BACKEND_END_NAMESPACE

  812. 

  813. // --------------------------------------------------------------------------------------------------------------------

  814. 

  815. CARLA_BACKEND_USE_NAMESPACE

  816. 

  817. static CarlaJackClient* gClient         = nullptr;

  818. static int              gClientRefCount = 0;

  819. 

  820. CARLA_EXPORT

  821. jack_client_t* jack_client_open(const char* client_name, jack_options_t /*options*/, jack_status_t* status, ...)

  822. {

  823.     carla_stdout("CarlaJackClient :: %s", __FUNCTION__);

  824. 

  825.     if (gClient != nullptr)

  826.     {

  827.         ++gClientRefCount;

  828.         return (jack_client_t*)gClient;

  829.     }

  830. 

  831.     const char* const shmIds(std::getenv("CARLA_SHM_IDS"));

  832. 

  833.     if (shmIds == nullptr || std::strlen(shmIds) != 6*4)

  834.     {

  835.         if (status != nullptr)

  836.             *status = JackFailure;

  837.         return nullptr;

  838.     }

  839. 

  840.     char audioPoolBaseName[6+1];

  841.     char rtClientBaseName[6+1];

  842.     char nonRtClientBaseName[6+1];

  843.     char nonRtServerBaseName[6+1];

  844. 

  845.     std::memcpy(audioPoolBaseName,   shmIds+6*0, 6);

  846.     std::memcpy(rtClientBaseName,    shmIds+6*1, 6);

  847.     std::memcpy(nonRtClientBaseName, shmIds+6*2, 6);

  848.     std::memcpy(nonRtServerBaseName, shmIds+6*3, 6);

  849. 

  850.     audioPoolBaseName[6]   = '\0';

  851.     rtClientBaseName[6]    = '\0';

  852.     nonRtClientBaseName[6] = '\0';

  853.     nonRtServerBaseName[6] = '\0';

  854. 

  855.     CarlaJackClient* const client = new CarlaJackClient(audioPoolBaseName, rtClientBaseName,

  856.                                                         nonRtClientBaseName, nonRtServerBaseName);

  857. 

  858.     if (! client->init(client_name))

  859.     {

  860.         if (status != nullptr)

  861.             *status = JackServerError;

  862.         return nullptr;

  863.     }

  864. 

  865.     gClient = client;

  866.     ++gClientRefCount;

  867.     return (jack_client_t*)client;

  868. }

  869. 

  870. CARLA_EXPORT

  871. jack_client_t* jack_client_new(const char* client_name)

  872. {

  873.     return jack_client_open(client_name, JackNullOption, nullptr);

  874. }

  875. 

  876. CARLA_EXPORT

  877. int jack_client_close(jack_client_t* client)

  878. {

  879.     carla_stdout("CarlaJackClient :: %s", __FUNCTION__);

  880. 

  881.     CarlaJackClient* const jclient = (CarlaJackClient*)client;

  882.     CARLA_SAFE_ASSERT_RETURN(jclient != nullptr, 1);

  883. 

  884.     JackClientState& jstate(jclient->fState);

  885. 

  886.     if (jstate.activated)

  887.         jclient->deactivate();

  888. 

  889.     if (--gClientRefCount == 0)

  890.     {

  891. #if 0

  892.         static bool ignoreFirstClientClose = true;

  893.         if (ignoreFirstClientClose)

  894.         {

  895.             ignoreFirstClientClose = false;

  896.             return 0;

  897.         }

  898. #endif

  899.         jclient->close();

  900.         delete jclient;

  901.         gClient = nullptr;

  902.     }

  903. 

  904.     return 0;

  905. }

  906. 

  907. CARLA_EXPORT

  908. jack_port_t* jack_port_register(jack_client_t* client, const char* port_name, const char* port_type,

  909.                                 unsigned long flags, unsigned long /*buffer_size*/)

  910. {

  911.     carla_stdout("CarlaJackClient :: %s | %s %s %lu", __FUNCTION__, port_name, port_type, flags);

  912. 

  913.     CarlaJackClient* const jclient = (CarlaJackClient*)client;

  914.     CARLA_SAFE_ASSERT_RETURN(jclient != nullptr, nullptr);

  915. 

  916.     JackClientState& jstate(jclient->fState);

  917. 

  918.     CARLA_SAFE_ASSERT_RETURN(port_name != nullptr && port_name[0] != '\0', nullptr);

  919.     CARLA_SAFE_ASSERT_RETURN(port_type != nullptr && port_type[0] != '\0', nullptr);

  920. 

  921.     if (std::strcmp(port_type, JACK_DEFAULT_AUDIO_TYPE) == 0)

  922.     {

  923.         uint32_t index;

  924. 

  925.         /**/ if (flags & JackPortIsInput)

  926.         {

  927.             if (jstate.prematurelyActivated)

  928.             {

  929.                 CARLA_SAFE_ASSERT_RETURN(jstate.fakeIns > 0, nullptr);

  930.                 jstate.fakeIns -= 1;

  931.                 index = jstate.audioIns.count() - jstate.fakeIns - 1;

  932.             }

  933.             else

  934.             {

  935.                 index = jstate.audioIns.count();

  936.                 jstate.audioIns.append(new JackPortState(jstate.name, port_name, index, flags, false));

  937.             }

  938. 

  939.             return (jack_port_t*)jstate.audioIns.getAt(index, nullptr);

  940.         }

  941.         else if (flags & JackPortIsOutput)

  942.         {

  943.             if (jstate.prematurelyActivated)

  944.             {

  945.                 CARLA_SAFE_ASSERT_RETURN(jstate.fakeOuts > 0, nullptr);

  946.                 jstate.fakeOuts -= 1;

  947.                 index = jstate.audioOuts.count() - jstate.fakeOuts - 1;

  948.             }

  949.             else

  950.             {

  951.                 index = jstate.audioOuts.count();

  952.                 jstate.audioOuts.append(new JackPortState(jstate.name, port_name, index, flags, false));

  953.             }

  954. 

  955.             return (jack_port_t*)jstate.audioOuts.getAt(index, nullptr);

  956.         }

  957. 

  958.         carla_stderr2("Invalid port flags '%x'", flags);

  959.         return nullptr;

  960.     }

  961. 

  962.     carla_stderr2("Invalid port type '%s'", port_type);

  963.     return nullptr;

  964. }

  965. 

  966. CARLA_EXPORT

  967. int jack_port_unregister(jack_client_t* client, jack_port_t* port)

  968. {

  969.     carla_stdout("CarlaJackClient :: %s", __FUNCTION__);

  970. 

  971.     CarlaJackClient* const jclient = (CarlaJackClient*)client;

  972.     CARLA_SAFE_ASSERT_RETURN(jclient != nullptr, 1);

  973. 

  974.     JackPortState* const jport = (JackPortState*)port;

  975.     CARLA_SAFE_ASSERT_RETURN(jport != nullptr, 1);

  976.     CARLA_SAFE_ASSERT_RETURN(! jport->isSystem, 1);

  977. 

  978.     JackClientState& jstate(jclient->fState);

  979.     //CARLA_SAFE_ASSERT_RETURN(! jstate.activated, 1);

  980. 

  981.     if (jport->flags & JackPortIsOutput)

  982.     {

  983.         if (jstate.prematurelyActivated)

  984.         {

  985.             CARLA_SAFE_ASSERT_RETURN(jstate.fakeIns < 2, 1);

  986.             jstate.fakeIns += 1;

  987.         }

  988.         else

  989.         {

  990.             CARLA_SAFE_ASSERT_RETURN(jstate.audioIns.removeOne(jport), 1);

  991.         }

  992.     }

  993.     else

  994.     {

  995.         if (jstate.prematurelyActivated)

  996.         {

  997.             CARLA_SAFE_ASSERT_RETURN(jstate.fakeOuts < 2, 1);

  998.             jstate.fakeOuts += 1;

  999.         }

  1000.         else

  1001.         {

  1002.             CARLA_SAFE_ASSERT_RETURN(jstate.audioOuts.removeOne(jport), 1);

  1003.         }

  1004.     }

  1005. 

  1006.     return 0;

  1007. }

  1008. 

  1009. CARLA_EXPORT

  1010. void* jack_port_get_buffer(jack_port_t* port, jack_nframes_t)

  1011. {

  1012.     JackPortState* const jport = (JackPortState*)port;

  1013.     CARLA_SAFE_ASSERT_RETURN(jport != nullptr, nullptr);

  1014. 

  1015.     return jport->buffer;

  1016. }

  1017. 

  1018. CARLA_EXPORT

  1019. int jack_set_process_callback(jack_client_t* client, JackProcessCallback callback, void* arg)

  1020. {

  1021.     carla_stdout("CarlaJackClient :: %s", __FUNCTION__);

  1022. 

  1023.     CarlaJackClient* const jclient = (CarlaJackClient*)client;

  1024.     CARLA_SAFE_ASSERT_RETURN(jclient != nullptr, 1);

  1025. 

  1026.     JackClientState& jstate(jclient->fState);

  1027.     CARLA_SAFE_ASSERT_RETURN(! jstate.activated, 1);

  1028. 

  1029.     jstate.process = callback;

  1030.     jstate.processPtr = arg;

  1031. 

  1032.     return 0;

  1033. }

  1034. 

  1035. CARLA_EXPORT

  1036. void jack_on_shutdown(jack_client_t* client, JackShutdownCallback callback, void* arg)

  1037. {

  1038.     carla_stdout("CarlaJackClient :: %s", __FUNCTION__);

  1039. 

  1040.     CarlaJackClient* const jclient = (CarlaJackClient*)client;

  1041.     CARLA_SAFE_ASSERT_RETURN(jclient != nullptr,);

  1042. 

  1043.     JackClientState& jstate(jclient->fState);

  1044.     CARLA_SAFE_ASSERT_RETURN(! jstate.activated,);

  1045. 

  1046.     jstate.shutdown = callback;

  1047.     jstate.shutdownPtr = arg;

  1048. }

  1049. 

  1050. CARLA_EXPORT

  1051. int jack_activate(jack_client_t* client)

  1052. {

  1053.     carla_stdout("CarlaJackClient :: %s", __FUNCTION__);

  1054. 

  1055.     CarlaJackClient* const jclient = (CarlaJackClient*)client;

  1056.     CARLA_SAFE_ASSERT_RETURN(jclient != nullptr, 1);

  1057. 

  1058.     const JackClientState& jstate(jclient->fState);

  1059.     CARLA_SAFE_ASSERT_RETURN(! jstate.activated, 1);

  1060. 

  1061. #if 0

  1062.     // needed for pulseaudio

  1063.     static bool skipFirstActivate = true;

  1064.     if (skipFirstActivate) {

  1065.         skipFirstActivate = false;

  1066.         return 0;

  1067.     }

  1068. #endif

  1069. 

  1070.     jclient->activate();

  1071.     return 0;

  1072. }

  1073. 

  1074. CARLA_EXPORT

  1075. int jack_deactivate(jack_client_t* /*client*/)

  1076. {

  1077.     carla_stdout("CarlaJackClient :: %s", __FUNCTION__);

  1078. 

  1079.     //CarlaJackClient* const jclient = (CarlaJackClient*)client;

  1080.     //CARLA_SAFE_ASSERT_RETURN(jclient != nullptr, 1);

  1081. 

  1082.     //JackClientState& jstate(jclient->fState);

  1083.     //CARLA_SAFE_ASSERT_RETURN(jstate.activated, 1);

  1084. 

  1085.     //jclient->deactivate();

  1086.     return 0;

  1087. }

  1088. 

  1089. CARLA_EXPORT

  1090. char* jack_get_client_name(jack_client_t* client)

  1091. {

  1092.     carla_stdout("CarlaJackClient :: %s", __FUNCTION__);

  1093. 

  1094.     CarlaJackClient* const jclient = (CarlaJackClient*)client;

  1095.     CARLA_SAFE_ASSERT_RETURN(jclient != nullptr, nullptr);

  1096. 

  1097.     const JackClientState& jstate(jclient->fState);

  1098. 

  1099.     return jstate.name;

  1100. }

  1101. 

  1102. CARLA_EXPORT

  1103. jack_nframes_t jack_get_buffer_size(jack_client_t* client)

  1104. {

  1105.     carla_stdout("CarlaJackClient :: %s", __FUNCTION__);

  1106. 

  1107.     CarlaJackClient* const jclient = (CarlaJackClient*)client;

  1108.     CARLA_SAFE_ASSERT_RETURN(jclient != nullptr, 0);

  1109. 

  1110.     const JackClientState& jstate(jclient->fState);

  1111. 

  1112.     return jstate.bufferSize;

  1113. }

  1114. 

  1115. CARLA_EXPORT

  1116. jack_nframes_t jack_get_sample_rate(jack_client_t* client)

  1117. {

  1118.     carla_debug("CarlaJackClient :: %s", __FUNCTION__);

  1119. 

  1120.     CarlaJackClient* const jclient = (CarlaJackClient*)client;

  1121.     CARLA_SAFE_ASSERT_RETURN(jclient != nullptr, 0);

  1122. 

  1123.     const JackClientState& jstate(jclient->fState);

  1124. 

  1125.     return jstate.sampleRate;

  1126. }

  1127. 

  1128. // --------------------------------------------------------------------------------------------------------------------

  1129. 

  1130. CARLA_EXPORT

  1131. void jack_set_error_function(void (*func)(const char *))

  1132. {

  1133.     carla_stdout("CarlaJackClient :: %s", __FUNCTION__);

  1134. 

  1135.     (void)func;

  1136. }

  1137. 

  1138. CARLA_EXPORT

  1139. int jack_set_sync_callback(jack_client_t* client, JackSyncCallback /*callback*/, void* /*arg*/)

  1140. {

  1141.     carla_stdout("CarlaJackClient :: %s", __FUNCTION__);

  1142. 

  1143.     CarlaJackClient* const jclient = (CarlaJackClient*)client;

  1144.     CARLA_SAFE_ASSERT_RETURN(jclient != nullptr, 1);

  1145. 

  1146.     const JackClientState& jstate(jclient->fState);

  1147.     CARLA_SAFE_ASSERT_RETURN(! jstate.activated, 1);

  1148. 

  1149.     // TODO

  1150. 

  1151.     return 0;

  1152. }

  1153. 

  1154. CARLA_EXPORT

  1155. int jack_set_timebase_callback(jack_client_t* client, int, JackTimebaseCallback, void*)

  1156. {

  1157.     carla_stdout("CarlaJackClient :: %s", __FUNCTION__);

  1158. 

  1159.     CarlaJackClient* const jclient = (CarlaJackClient*)client;

  1160.     CARLA_SAFE_ASSERT_RETURN(jclient != nullptr, 1);

  1161. 

  1162.     const JackClientState& jstate(jclient->fState);

  1163.     CARLA_SAFE_ASSERT_RETURN(! jstate.activated, 1);

  1164. 

  1165.     // TODO

  1166. 

  1167.     return EBUSY;

  1168. }

  1169. 

  1170. CARLA_EXPORT

  1171. int jack_set_buffer_size_callback(jack_client_t* client, JackBufferSizeCallback /*callback*/, void* /*arg*/)

  1172. {

  1173.     carla_stdout("CarlaJackClient :: %s", __FUNCTION__);

  1174. 

  1175.     CarlaJackClient* const jclient = (CarlaJackClient*)client;

  1176.     CARLA_SAFE_ASSERT_RETURN(jclient != nullptr, 1);

  1177. 

  1178.     const JackClientState& jstate(jclient->fState);

  1179.     CARLA_SAFE_ASSERT_RETURN(! jstate.activated, 1);

  1180. 

  1181.     // TODO

  1182. 

  1183.     return 0;

  1184. }

  1185. 

  1186. CARLA_EXPORT

  1187. int jack_set_sample_rate_callback(jack_client_t* client, JackSampleRateCallback /*callback*/, void* /*arg*/)

  1188. {

  1189.     carla_stdout("CarlaJackClient :: %s", __FUNCTION__);

  1190. 

  1191.     CarlaJackClient* const jclient = (CarlaJackClient*)client;

  1192.     CARLA_SAFE_ASSERT_RETURN(jclient != nullptr, 1);

  1193. 

  1194.     const JackClientState& jstate(jclient->fState);

  1195.     CARLA_SAFE_ASSERT_RETURN(! jstate.activated, 1);

  1196. 

  1197.     // TODO

  1198. 

  1199.     return 0;

  1200. }

  1201. 

  1202. CARLA_EXPORT

  1203. int jack_set_client_registration_callback(jack_client_t* client, JackClientRegistrationCallback, void*)

  1204. {

  1205.     carla_stdout("CarlaJackClient :: %s", __FUNCTION__);

  1206. 

  1207.     CarlaJackClient* const jclient = (CarlaJackClient*)client;

  1208.     CARLA_SAFE_ASSERT_RETURN(jclient != nullptr, 1);

  1209. 

  1210.     const JackClientState& jstate(jclient->fState);

  1211.     CARLA_SAFE_ASSERT_RETURN(! jstate.activated, 1);

  1212.     carla_stdout("CarlaJackClient :: %s", __FUNCTION__);

  1213. 

  1214. 

  1215.     return 0;

  1216. }

  1217. 

  1218. CARLA_EXPORT

  1219. int jack_set_port_registration_callback(jack_client_t* client, JackPortRegistrationCallback, void*)

  1220. {

  1221.     carla_stdout("CarlaJackClient :: %s", __FUNCTION__);

  1222. 

  1223.     CarlaJackClient* const jclient = (CarlaJackClient*)client;

  1224.     CARLA_SAFE_ASSERT_RETURN(jclient != nullptr, 1);

  1225. 

  1226.     const JackClientState& jstate(jclient->fState);

  1227.     CARLA_SAFE_ASSERT_RETURN(! jstate.activated, 1);

  1228. 

  1229.     return 0;

  1230. }

  1231. 

  1232. CARLA_EXPORT

  1233. int jack_set_port_connect_callback(jack_client_t* client, JackPortConnectCallback, void*)

  1234. {

  1235.     carla_stdout("CarlaJackClient :: %s", __FUNCTION__);

  1236. 

  1237.     CarlaJackClient* const jclient = (CarlaJackClient*)client;

  1238.     CARLA_SAFE_ASSERT_RETURN(jclient != nullptr, 1);

  1239. 

  1240.     const JackClientState& jstate(jclient->fState);

  1241.     CARLA_SAFE_ASSERT_RETURN(! jstate.activated, 1);

  1242. 

  1243.     return 0;

  1244. }

  1245. 

  1246. CARLA_EXPORT

  1247. int jack_set_graph_order_callback(jack_client_t* client, JackGraphOrderCallback, void*)

  1248. {

  1249.     carla_stdout("CarlaJackClient :: %s", __FUNCTION__);

  1250. 

  1251.     CarlaJackClient* const jclient = (CarlaJackClient*)client;

  1252.     CARLA_SAFE_ASSERT_RETURN(jclient != nullptr, 1);

  1253. 

  1254.     const JackClientState& jstate(jclient->fState);

  1255.     CARLA_SAFE_ASSERT_RETURN(! jstate.activated, 1);

  1256. 

  1257.     return 0;

  1258. }

  1259. 

  1260. CARLA_EXPORT

  1261. int jack_is_realtime(jack_client_t*)

  1262. {

  1263.     carla_stdout("CarlaJackClient :: %s", __FUNCTION__);

  1264. 

  1265.     return 0;

  1266. }

  1267. 

  1268. CARLA_EXPORT

  1269. int jack_transport_locate(jack_client_t*, jack_nframes_t)

  1270. {

  1271.     carla_stdout("CarlaJackClient :: %s", __FUNCTION__);

  1272. 

  1273.     return 1;

  1274. }

  1275. 

  1276. CARLA_EXPORT

  1277. jack_transport_state_t jack_transport_query(const jack_client_t* client, jack_position_t* pos)

  1278. {

  1279.     carla_debug("CarlaJackClient :: %s", __FUNCTION__);

  1280. 

  1281.     CarlaJackClient* const jclient = (CarlaJackClient*)client;

  1282.     CARLA_SAFE_ASSERT_RETURN(jclient != nullptr, JackTransportStopped);

  1283. 

  1284.     const JackClientState& jstate(jclient->fState);

  1285.     CARLA_SAFE_ASSERT_RETURN(jstate.activated, JackTransportStopped);

  1286. 

  1287.     if (pos != nullptr)

  1288.         std::memcpy(pos, &jstate.position, sizeof(jack_position_t));

  1289. 

  1290.     return jstate.playing ? JackTransportRolling : JackTransportStopped;

  1291. }

  1292. 

  1293. CARLA_EXPORT

  1294. int jack_transport_reposition(jack_client_t*, const jack_position_t*)

  1295. {

  1296.     carla_stdout("CarlaJackClient :: %s", __FUNCTION__);

  1297. 

  1298.     return EINVAL;

  1299. }

  1300. 

  1301. CARLA_EXPORT

  1302. void jack_transport_start(jack_client_t*)

  1303. {

  1304.     carla_stdout("CarlaJackClient :: %s", __FUNCTION__);

  1305. 

  1306. }

  1307. 

  1308. CARLA_EXPORT

  1309. void jack_transport_stop (jack_client_t*)

  1310. {

  1311.     carla_stdout("CarlaJackClient :: %s", __FUNCTION__);

  1312. 

  1313. }

  1314. 

  1315. CARLA_EXPORT

  1316. pthread_t jack_client_thread_id(jack_client_t* client)

  1317. {

  1318.     carla_stdout("CarlaJackClient :: %s", __FUNCTION__);

  1319. 

  1320.     CarlaJackClient* const jclient = (CarlaJackClient*)client;

  1321.     CARLA_SAFE_ASSERT_RETURN(jclient != nullptr, 0);

  1322. 

  1323.     const JackClientState& jstate(jclient->fState);

  1324.     CARLA_SAFE_ASSERT_RETURN(jstate.activated, 0);

  1325. 

  1326.     return (pthread_t)jclient->getThreadId();

  1327. }

  1328. 

  1329. CARLA_EXPORT

  1330. jack_nframes_t jack_frame_time(const jack_client_t* client)

  1331. {

  1332.     carla_debug("CarlaJackClient :: %s", __FUNCTION__);

  1333. 

  1334.     CarlaJackClient* const jclient = (CarlaJackClient*)client;

  1335.     CARLA_SAFE_ASSERT_RETURN(jclient != nullptr, 0);

  1336. 

  1337.     const JackClientState& jstate(jclient->fState);

  1338.     CARLA_SAFE_ASSERT_RETURN(jstate.activated, 0);

  1339. 

  1340.     return jstate.position.usecs;

  1341. }

  1342. 

  1343. CARLA_EXPORT

  1344. void jack_free(void* ptr)

  1345. {

  1346.     carla_stdout("CarlaJackClient :: %s", __FUNCTION__);

  1347. 

  1348.     free(ptr);

  1349. }

  1350. 

  1351. CARLA_EXPORT

  1352. jack_nframes_t jack_midi_get_event_count(void*)

  1353. {

  1354.     carla_stdout("CarlaJackClient :: %s", __FUNCTION__);

  1355. 

  1356.     return 0;

  1357. }

  1358. 

  1359. 

  1360. CARLA_EXPORT

  1361. int jack_midi_event_get(jack_midi_event_t*, void*, uint32_t)

  1362. {

  1363.     carla_stdout("CarlaJackClient :: %s", __FUNCTION__);

  1364. 

  1365.     return ENODATA;

  1366. }

  1367. 

  1368. CARLA_EXPORT

  1369. const char* jack_port_short_name(const jack_port_t* port)

  1370. {

  1371.     carla_stdout("CarlaJackClient :: %s", __FUNCTION__);

  1372. 

  1373.     JackPortState* const jport = (JackPortState*)port;

  1374.     CARLA_SAFE_ASSERT_RETURN(jport != nullptr, nullptr);

  1375. 

  1376.     return jport->name;

  1377. }

  1378. 

  1379. CARLA_EXPORT

  1380. const char* jack_port_name(const jack_port_t* port)

  1381. {

  1382.     carla_stdout("CarlaJackClient :: %s", __FUNCTION__);

  1383. 

  1384.     JackPortState* const jport = (JackPortState*)port;

  1385.     CARLA_SAFE_ASSERT_RETURN(jport != nullptr, nullptr);

  1386. 

  1387.     return jport->fullname;

  1388. }

  1389. 

  1390. CARLA_EXPORT

  1391. int jack_port_flags(const jack_port_t* port)

  1392. {

  1393.     carla_stdout("CarlaJackClient :: %s", __FUNCTION__);

  1394. 

  1395.     JackPortState* const jport = (JackPortState*)port;

  1396.     CARLA_SAFE_ASSERT_RETURN(jport != nullptr, 0);

  1397. 

  1398.     return jport->flags;

  1399. }

  1400. 

  1401. CARLA_EXPORT

  1402. const char* jack_port_type(const jack_port_t* port)

  1403. {

  1404.     carla_stdout("CarlaJackClient :: %s", __FUNCTION__);

  1405. 

  1406.     JackPortState* const jport = (JackPortState*)port;

  1407.     CARLA_SAFE_ASSERT_RETURN(jport != nullptr, nullptr);

  1408. 

  1409.     // TODO

  1410. 

  1411.     return JACK_DEFAULT_AUDIO_TYPE;

  1412. }

  1413. 

  1414. CARLA_EXPORT

  1415. jack_uuid_t jack_port_uuid(const jack_port_t*)

  1416. {

  1417.     carla_stdout("CarlaJackClient :: %s", __FUNCTION__);

  1418. 

  1419.     return 0;

  1420. }

  1421. 

  1422. CARLA_EXPORT

  1423. int jack_client_real_time_priority(jack_client_t*)

  1424. {

  1425.     carla_stdout("CarlaJackClient :: %s", __FUNCTION__);

  1426. 

  1427.     return -1;

  1428. }

  1429. 

  1430. CARLA_EXPORT

  1431. int jack_connect(jack_client_t*, const char*, const char*)

  1432. {

  1433.     carla_stdout("CarlaJackClient :: %s", __FUNCTION__);

  1434. 

  1435.     return 0;

  1436. }

  1437. 

  1438. CARLA_EXPORT

  1439. int jack_disconnect(jack_client_t*, const char*, const char*)

  1440. {

  1441.     carla_stdout("CarlaJackClient :: %s", __FUNCTION__);

  1442. 

  1443.     return 0;

  1444. }

  1445. 

  1446. CARLA_EXPORT

  1447. int jack_port_disconnect(jack_client_t*, jack_port_t*)

  1448. {

  1449.     carla_stdout("CarlaJackClient :: %s", __FUNCTION__);

  1450. 

  1451.     return 0;

  1452. }

  1453. 

  1454. CARLA_EXPORT

  1455. const char** jack_get_ports(jack_client_t*, const char* a, const char* b, unsigned long flags)

  1456. {

  1457.     carla_stdout("CarlaJackClient :: %s | %s %s %li", __FUNCTION__, a, b, flags);

  1458. 

  1459.     static const char* capture_1  = "system:capture_1";

  1460.     static const char* capture_2  = "system:capture_2";

  1461.     static const char* playback_1 = "system:playback_1";

  1462.     static const char* playback_2 = "system:playback_2";

  1463. 

  1464.     if (flags == 0 || (flags & (JackPortIsInput|JackPortIsOutput)) == (JackPortIsInput|JackPortIsOutput))

  1465.     {

  1466.         if (const char** const ret = (const char**)calloc(5, sizeof(const char*)))

  1467.         {

  1468.             ret[0] = capture_1;

  1469.             ret[1] = capture_2;

  1470.             ret[2] = playback_1;

  1471.             ret[3] = playback_2;

  1472.             ret[4] = nullptr;

  1473.             return ret;

  1474.         }

  1475.     }

  1476. 

  1477.     if (flags & JackPortIsInput)

  1478.     {

  1479.         if (const char** const ret = (const char**)calloc(3, sizeof(const char*)))

  1480.         {

  1481.             ret[0] = playback_1;

  1482.             ret[1] = playback_2;

  1483.             ret[2] = nullptr;

  1484.             return ret;

  1485.         }

  1486.     }

  1487. 

  1488.     if (flags & JackPortIsOutput)

  1489.     {

  1490.         if (const char** const ret = (const char**)calloc(3, sizeof(const char*)))

  1491.         {

  1492.             ret[0] = capture_1;

  1493.             ret[1] = capture_2;

  1494.             ret[2] = nullptr;

  1495.             return ret;

  1496.         }

  1497.     }

  1498. 

  1499.     return nullptr;

  1500. }

  1501. 

  1502. CARLA_EXPORT

  1503. jack_port_t* jack_port_by_name(jack_client_t* /*client*/, const char* name)

  1504. {

  1505.     carla_stdout("CarlaJackClient :: %s | %s", __FUNCTION__, name);

  1506. 

  1507. //     CarlaJackClient* const jclient = (CarlaJackClient*)client;

  1508. //     CARLA_SAFE_ASSERT_RETURN(jclient != nullptr, 0);

  1509. 

  1510. //     const JackClientState& jstate(jclient->fState);

  1511.     //CARLA_SAFE_ASSERT_RETURN(jstate.activated, 0);

  1512. 

  1513.     static const JackPortState capturePorts[] = {

  1514.         JackPortState("system", "capture_1", 0, JackPortIsOutput|JackPortIsPhysical|JackPortIsTerminal, true),

  1515.         JackPortState("system", "capture_2", 1, JackPortIsOutput|JackPortIsPhysical|JackPortIsTerminal, true),

  1516.     };

  1517.     static const JackPortState playbackPorts[] = {

  1518.         JackPortState("system", "playback_1", 3, JackPortIsInput|JackPortIsPhysical|JackPortIsTerminal, true),

  1519.         JackPortState("system", "playback_2", 4, JackPortIsInput|JackPortIsPhysical|JackPortIsTerminal, true),

  1520.     };

  1521. 

  1522.     if (std::strncmp(name, "system:", 7) == 0)

  1523.     {

  1524.         name += 7;

  1525. 

  1526.         /**/ if (std::strncmp(name, "capture_", 8) == 0)

  1527.         {

  1528.             name += 8;

  1529. 

  1530.             const int index = std::atoi(name);

  1531.             CARLA_SAFE_ASSERT_RETURN(index >= 0 && index < 2, nullptr);

  1532. 

  1533.             return (jack_port_t*)&capturePorts[index];

  1534.         }

  1535.         else if (std::strncmp(name, "playback_", 9) == 0)

  1536.         {

  1537.             name += 9;

  1538. 

  1539.             const int index = std::atoi(name);

  1540.             CARLA_SAFE_ASSERT_RETURN(index >= 0, nullptr);

  1541. 

  1542.             return (jack_port_t*)&playbackPorts[index];

  1543.         }

  1544.         else

  1545.         {

  1546.             carla_stderr2("Invalid port short name: '%s'", name);

  1547.             return nullptr;

  1548.         }

  1549.     }

  1550. 

  1551.     carla_stderr2("Invalid port name: '%s'", name);

  1552.     return nullptr;

  1553. }

  1554. 

  1555. CARLA_EXPORT

  1556. jack_port_t* jack_port_by_id(jack_client_t*, jack_port_id_t)

  1557. {

  1558.     carla_stdout("CarlaJackClient :: %s", __FUNCTION__);

  1559. 

  1560.     return nullptr;

  1561. }

  1562. 

  1563. CARLA_EXPORT

  1564. void jack_set_info_function(void (*func)(const char *))

  1565. {

  1566.     carla_stdout("CarlaJackClient :: %s", __FUNCTION__);

  1567. 

  1568.     (void)func;

  1569. }

  1570. 

  1571. CARLA_EXPORT

  1572. int jack_set_freewheel(jack_client_t*, int)

  1573. {

  1574.     carla_stdout("CarlaJackClient :: %s", __FUNCTION__);

  1575. 

  1576.     return 1;

  1577. }

  1578. 

  1579. CARLA_EXPORT

  1580. int jack_set_buffer_size(jack_client_t*, jack_nframes_t)

  1581. {

  1582.     carla_stdout("CarlaJackClient :: %s", __FUNCTION__);

  1583. 

  1584.     return 1;

  1585. }

  1586. 

  1587. CARLA_EXPORT

  1588. int jack_engine_takeover_timebase(jack_client_t*)

  1589. {

  1590.     carla_stdout("CarlaJackClient :: %s", __FUNCTION__);

  1591. 

  1592.     return ENOSYS;

  1593. }

  1594. 

  1595. CARLA_EXPORT

  1596. float jack_cpu_load(jack_client_t*)

  1597. {

  1598.     return 0.0f;

  1599. }

  1600. 

  1601. CARLA_EXPORT

  1602. int jack_client_name_size(void)

  1603. {

  1604.     return STR_MAX;

  1605. }

  1606. 

  1607. CARLA_EXPORT

  1608. void jack_port_get_latency_range(jack_port_t*, jack_latency_callback_mode_t, jack_latency_range_t* range)

  1609. {

  1610.     range->min = range->max = 0;

  1611. }

  1612. 

  1613. CARLA_EXPORT

  1614. jack_nframes_t jack_port_get_latency(jack_port_t*)

  1615. {

  1616.     return 0;

  1617. }

  1618. 

  1619. CARLA_EXPORT

  1620. int jack_set_xrun_callback(jack_client_t*, JackXRunCallback, void*)

  1621. {

  1622.     return 0;

  1623. }

  1624. 

  1625. CARLA_EXPORT

  1626. int jack_set_thread_init_callback(jack_client_t*, JackThreadInitCallback, void*)

  1627. {

  1628.     return 0;

  1629. }

  1630. 

  1631. CARLA_EXPORT

  1632. int jack_port_name_size(void)

  1633. {

  1634.     return STR_MAX;

  1635. }

  1636. 

  1637. CARLA_EXPORT

  1638. int jack_port_connected(const jack_port_t*)

  1639. {

  1640.     carla_stdout("CarlaJackClient :: %s", __FUNCTION__);

  1641. 

  1642.     return 1;

  1643. }

  1644. 

  1645. CARLA_EXPORT

  1646. const char* JACK_METADATA_PRETTY_NAME;

  1647. const char* JACK_METADATA_PRETTY_NAME = "http://jackaudio.org/metadata/pretty-name";

  1648. 

  1649. // jack_ringbuffer_create

  1650. // jack_port_is_mine

  1651. // jack_port_set_name

  1652. // jack_port_get_all_connections

  1653. // jack_port_uuid

  1654. 

  1655. // --------------------------------------------------------------------------------------------------------------------

  1656. 

  1657. #include "jackbridge/JackBridge2.cpp"

  1658. #include "CarlaBridgeUtils.cpp"

  1659. 

  1660. // --------------------------------------------------------------------------------------------------------------------