source/libjack/libjack.cpp

   1 /*
   2  * Carla JACK API for external applications
   3  * Copyright (C) 2016-2022 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 #include "libjack.hpp"
  19
  20 #include "CarlaThread.hpp"
  21 #include "CarlaJuceUtils.hpp"
  22
  23 #include <signal.h>
  24 #include <sys/time.h>
  25
  26 // ---------------------------------------------------------------------------------------------------------------------
  27
  28 CARLA_BACKEND_START_NAMESPACE
  29
  30 // ---------------------------------------------------------------------------------------------------------------------
  31
  32 static int64_t getCurrentTimeMilliseconds() noexcept
  33 {
  34     struct timeval tv;
  35     gettimeofday (&tv, nullptr);
  36     return ((int64_t) tv.tv_sec) * 1000 + tv.tv_usec / 1000;
  37 }
  38
  39 static int carla_interposed_callback(int, void*);
  40
  41 // ---------------------------------------------------------------------------------------------------------------------
  42
  43 class CarlaJackRealtimeThread : public CarlaThread
  44 {
  45 public:
  46     struct Callback {
  47         Callback() {}
  48         virtual ~Callback() {};
  49         virtual void runRealtimeThread() = 0;
  50     };
  51
  52     CarlaJackRealtimeThread(Callback* const callback)
  53         : CarlaThread("CarlaJackRealtimeThread"),
  54           fCallback(callback) {}
  55
  56 protected:
  57     void run() override
  58     {
  59         fCallback->runRealtimeThread();
  60     }
  61
  62 private:
  63     Callback* const fCallback;
  64
  65     CARLA_DECLARE_NON_COPYABLE(CarlaJackRealtimeThread)
  66 };
  67
  68 // --------------------------------------------------------------------------------------------------------------------
  69
  70 class CarlaJackNonRealtimeThread : public CarlaThread
  71 {
  72 public:
  73     struct Callback {
  74         Callback() {}
  75         virtual ~Callback() {};
  76         virtual void runNonRealtimeThread() = 0;
  77     };
  78
  79     CarlaJackNonRealtimeThread(Callback* const callback)
  80         : CarlaThread("CarlaJackNonRealtimeThread"),
  81           fCallback(callback) {}
  82
  83 protected:
  84     void run() override
  85     {
  86         fCallback->runNonRealtimeThread();
  87     }
  88
  89 private:
  90     Callback* const fCallback;
  91
  92     CARLA_DECLARE_NON_COPYABLE(CarlaJackNonRealtimeThread)
  93 };
  94
  95 // ---------------------------------------------------------------------------------------------------------------------
  96
  97 class CarlaJackAppClient : public CarlaJackRealtimeThread::Callback,
  98                            public CarlaJackNonRealtimeThread::Callback
  99 {
 100 public:
 101     JackServerState fServer;
 102     LinkedList<JackClientState*> fClients;
 103     LinkedList<JackClientState*> fNewClients;
 104
 105     CarlaJackAppClient()
 106         : fServer(this),
 107           fClients(),
 108           fNewClients(),
 109           fShmAudioPool(),
 110           fShmRtClientControl(),
 111           fShmNonRtClientControl(),
 112           fShmNonRtServerControl(),
 113           fAudioPoolCopy(nullptr),
 114           fAudioTmpBuf(nullptr),
 115           fDummyMidiInBuffer(true),
 116           fDummyMidiOutBuffer(false),
 117           fMidiInBuffers(nullptr),
 118           fMidiOutBuffers(nullptr),
 119           fInitialized(false),
 120           fIsOffline(false),
 121           fIsReady(false),
 122           fLastPingTime(-1),
 123           fSessionManager(0),
 124           fSetupHints(0),
 125           fRealtimeThread(this),
 126           fNonRealtimeThread(this),
 127           fRealtimeThreadMutex()
 128 #ifdef DEBUG
 129           ,leakDetector_CarlaJackAppClient()
 130 #endif
 131     {
 132         carla_debug("CarlaJackAppClient::CarlaJackAppClient() START");
 133
 134         const char* const shmIds(std::getenv("CARLA_SHM_IDS"));
 135         CARLA_SAFE_ASSERT_INT2_RETURN(shmIds != nullptr && std::strlen(shmIds) == 6*4,
 136                                       shmIds != nullptr ? static_cast<int>(std::strlen(shmIds)) : -1, 6*4,);
 137
 138         const char* const libjackSetup(std::getenv("CARLA_LIBJACK_SETUP"));
 139         CARLA_SAFE_ASSERT_INT_RETURN(libjackSetup != nullptr && std::strlen(libjackSetup) >= 6,
 140                                      libjackSetup != nullptr ? static_cast<int>(std::strlen(libjackSetup)) : -1,);
 141
 142         // make sure we don't get loaded again
 143         carla_unsetenv("CARLA_SHM_IDS");
 144
 145         // kill ourselves if main carla dies
 146         carla_terminateProcessOnParentExit(true);
 147
 148         for (int i=4; --i >= 0;) {
 149             CARLA_SAFE_ASSERT_RETURN(libjackSetup[i] >= '0' && libjackSetup[i] <= '0'+64,);
 150         }
 151         CARLA_SAFE_ASSERT_RETURN(libjackSetup[4] >= '0' && libjackSetup[4] <= '0' + LIBJACK_SESSION_MANAGER_NSM,);
 152         CARLA_SAFE_ASSERT_RETURN(libjackSetup[5] >= '0' && libjackSetup[5] < '0'+0x4f,);
 153
 154         std::memcpy(fBaseNameAudioPool,          shmIds+6*0, 6);
 155         std::memcpy(fBaseNameRtClientControl,    shmIds+6*1, 6);
 156         std::memcpy(fBaseNameNonRtClientControl, shmIds+6*2, 6);
 157         std::memcpy(fBaseNameNonRtServerControl, shmIds+6*3, 6);
 158
 159         fBaseNameAudioPool[6]          = '\0';
 160         fBaseNameRtClientControl[6]    = '\0';
 161         fBaseNameNonRtClientControl[6] = '\0';
 162         fBaseNameNonRtServerControl[6] = '\0';
 163
 164         fServer.numAudioIns  = static_cast<uint8_t>(libjackSetup[0] - '0');
 165         fServer.numAudioOuts = static_cast<uint8_t>(libjackSetup[1] - '0');
 166         fServer.numMidiIns   = static_cast<uint8_t>(libjackSetup[2] - '0');
 167         fServer.numMidiOuts  = static_cast<uint8_t>(libjackSetup[3] - '0');
 168
 169         fSessionManager = static_cast<uint>(libjackSetup[4] - '0');
 170         fSetupHints     = static_cast<uint>(libjackSetup[5] - '0');
 171
 172         if (fSetupHints & LIBJACK_FLAG_MIDI_OUTPUT_CHANNEL_MIXDOWN)
 173             fServer.numMidiOuts = 16;
 174
 175         jack_carla_interposed_action(LIBJACK_INTERPOSER_ACTION_SET_HINTS_AND_CALLBACK,
 176                                      fSetupHints,
 177                                      (void*)carla_interposed_callback);
 178
 179         jack_carla_interposed_action(LIBJACK_INTERPOSER_ACTION_SET_SESSION_MANAGER,
 180                                      fSessionManager,
 181                                      nullptr);
 182
 183         fNonRealtimeThread.startThread(false);
 184
 185         fInitialized = true;
 186         carla_debug("CarlaJackAppClient::CarlaJackAppClient() DONE");
 187     }
 188
 189     ~CarlaJackAppClient() noexcept override
 190     {
 191         carla_debug("CarlaJackAppClient::~CarlaJackAppClient() START");
 192
 193         fLastPingTime = -1;
 194
 195         fNonRealtimeThread.stopThread(5000);
 196
 197         {
 198             const CarlaMutexLocker cms(fRealtimeThreadMutex);
 199
 200             for (LinkedList<JackClientState*>::Itenerator it = fClients.begin2(); it.valid(); it.next())
 201             {
 202                 JackClientState* const jclient(it.getValue(nullptr));
 203                 CARLA_SAFE_ASSERT_CONTINUE(jclient != nullptr);
 204
 205                 delete jclient;
 206             }
 207
 208             fClients.clear();
 209             fNewClients.clear();
 210         }
 211
 212         clearSharedMemory();
 213
 214         carla_debug("CarlaJackAppClient::~CarlaJackAppClient() DONE");
 215     }
 216
 217     JackClientState* createClient(const char* const name)
 218     {
 219         if (! fInitialized)
 220             return nullptr;
 221
 222         while (fNonRealtimeThread.isThreadRunning() && ! fIsReady)
 223             carla_sleep(1);
 224
 225         return new JackClientState(fServer, name);
 226     }
 227
 228     void destroyClient(JackClientState* const jclient)
 229     {
 230         {
 231             const CarlaMutexLocker cms(fRealtimeThreadMutex);
 232             fClients.removeOne(jclient);
 233         }
 234
 235         delete jclient;
 236     }
 237
 238     bool activateClient(JackClientState* const jclient)
 239     {
 240         const CarlaMutexLocker cms(fRealtimeThreadMutex);
 241
 242         if (! fClients.append(jclient))
 243             return false;
 244         if (! fNewClients.append(jclient))
 245         {
 246             fClients.removeOne(jclient);
 247             return false;
 248         }
 249
 250         jclient->activated = true;
 251         jclient->deactivated = false;
 252         return true;
 253     }
 254
 255     bool deactivateClient(JackClientState* const jclient)
 256     {
 257         const CarlaMutexLocker cms(fRealtimeThreadMutex);
 258
 259         if (! fClients.removeOne(jclient))
 260             return false;
 261
 262         jclient->activated = false;
 263         jclient->deactivated = true;
 264         return true;
 265     }
 266
 267     const char* getClientNameFromUUID(const jack_uuid_t uuid) const noexcept
 268     {
 269         for (LinkedList<JackClientState*>::Itenerator it = fClients.begin2(); it.valid(); it.next())
 270         {
 271             JackClientState* const jclient(it.getValue(nullptr));
 272             CARLA_SAFE_ASSERT_CONTINUE(jclient != nullptr);
 273
 274             if (jclient->uuid == uuid)
 275                 return jclient->name;
 276         }
 277
 278         return nullptr;
 279     }
 280
 281     jack_uuid_t getUUIDForClientName(const char* const name) const noexcept
 282     {
 283         for (LinkedList<JackClientState*>::Itenerator it = fClients.begin2(); it.valid(); it.next())
 284         {
 285             JackClientState* const jclient(it.getValue(nullptr));
 286             CARLA_SAFE_ASSERT_CONTINUE(jclient != nullptr);
 287
 288             if (std::strcmp(jclient->name, name) == 0)
 289                 return jclient->uuid;
 290         }
 291
 292         return JACK_UUID_EMPTY_INITIALIZER;
 293     }
 294
 295     pthread_t getRealtimeThreadId() const noexcept
 296     {
 297         return (pthread_t)fRealtimeThread.getThreadId();
 298     }
 299
 300     int handleInterposerCallback(const int cb_action, void* const ptr)
 301     {
 302         carla_debug("handleInterposerCallback(%o, %p)", cb_action, ptr);
 303
 304         switch (cb_action)
 305         {
 306         case LIBJACK_INTERPOSER_CALLBACK_UI_HIDE: {
 307             const CarlaMutexLocker cml(fShmNonRtServerControl.mutex);
 308             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerUiClosed);
 309             fShmNonRtServerControl.commitWrite();
 310             break;
 311         }
 312         }
 313
 314         return 0;
 315
 316         // maybe unused
 317         (void)ptr;
 318     }
 319
 320     // -------------------------------------------------------------------
 321
 322 protected:
 323     void runRealtimeThread() override;
 324     void runNonRealtimeThread() override;
 325
 326 private:
 327     bool initSharedMemmory();
 328     void clearSharedMemory() noexcept;
 329
 330     bool handleRtData();
 331     bool handleNonRtData();
 332
 333     BridgeAudioPool          fShmAudioPool;
 334     BridgeRtClientControl    fShmRtClientControl;
 335     BridgeNonRtClientControl fShmNonRtClientControl;
 336     BridgeNonRtServerControl fShmNonRtServerControl;
 337
 338     float* fAudioPoolCopy;
 339     float* fAudioTmpBuf;
 340
 341     JackMidiPortBufferDummy fDummyMidiInBuffer;
 342     JackMidiPortBufferDummy fDummyMidiOutBuffer;
 343     JackMidiPortBufferOnStack* fMidiInBuffers;
 344     JackMidiPortBufferOnStack* fMidiOutBuffers;
 345
 346     char fBaseNameAudioPool[6+1];
 347     char fBaseNameRtClientControl[6+1];
 348     char fBaseNameNonRtClientControl[6+1];
 349     char fBaseNameNonRtServerControl[6+1];
 350
 351     bool fInitialized;
 352     bool fIsOffline;
 353     volatile bool fIsReady;
 354     int64_t fLastPingTime;
 355
 356     uint fSessionManager;
 357     uint fSetupHints;
 358
 359     CarlaJackRealtimeThread    fRealtimeThread;
 360     CarlaJackNonRealtimeThread fNonRealtimeThread;
 361
 362     CarlaMutex fRealtimeThreadMutex;
 363
 364     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaJackAppClient)
 365 };
 366
 367 // ---------------------------------------------------------------------------------------------------------------------
 368
 369 bool CarlaJackAppClient::initSharedMemmory()
 370 {
 371     if (! fShmAudioPool.attachClient(fBaseNameAudioPool))
 372     {
 373         carla_stderr("Failed to attach to audio pool shared memory");
 374         return false;
 375     }
 376
 377     if (! fShmRtClientControl.attachClient(fBaseNameRtClientControl))
 378     {
 379         clearSharedMemory();
 380         carla_stderr("Failed to attach to rt client control shared memory");
 381         return false;
 382     }
 383
 384     if (! fShmRtClientControl.mapData())
 385     {
 386         clearSharedMemory();
 387         carla_stderr("Failed to map rt client control shared memory");
 388         return false;
 389     }
 390
 391     if (! fShmNonRtClientControl.attachClient(fBaseNameNonRtClientControl))
 392     {
 393         clearSharedMemory();
 394         carla_stderr("Failed to attach to non-rt client control shared memory");
 395         return false;
 396     }
 397
 398     if (! fShmNonRtClientControl.mapData())
 399     {
 400         clearSharedMemory();
 401         carla_stderr("Failed to map non-rt control client shared memory");
 402         return false;
 403     }
 404
 405     if (! fShmNonRtServerControl.attachClient(fBaseNameNonRtServerControl))
 406     {
 407         clearSharedMemory();
 408         carla_stderr("Failed to attach to non-rt server control shared memory");
 409         return false;
 410     }
 411
 412     if (! fShmNonRtServerControl.mapData())
 413     {
 414         clearSharedMemory();
 415         carla_stderr("Failed to map non-rt control server shared memory");
 416         return false;
 417     }
 418
 419     PluginBridgeNonRtClientOpcode opcode;
 420
 421     opcode = fShmNonRtClientControl.readOpcode();
 422     CARLA_SAFE_ASSERT_RETURN(opcode == kPluginBridgeNonRtClientVersion, false);
 423
 424     const uint32_t apiVersion = fShmNonRtClientControl.readUInt();
 425     CARLA_SAFE_ASSERT_RETURN(apiVersion == CARLA_PLUGIN_BRIDGE_API_VERSION_CURRENT, false);
 426
 427     const uint32_t shmRtClientDataSize = fShmNonRtClientControl.readUInt();
 428     CARLA_SAFE_ASSERT_INT2(shmRtClientDataSize == sizeof(BridgeRtClientData), shmRtClientDataSize, sizeof(BridgeRtClientData));
 429
 430     const uint32_t shmNonRtClientDataSize = fShmNonRtClientControl.readUInt();
 431     CARLA_SAFE_ASSERT_INT2(shmNonRtClientDataSize == sizeof(BridgeNonRtClientData), shmNonRtClientDataSize, sizeof(BridgeNonRtClientData));
 432
 433     const uint32_t shmNonRtServerDataSize = fShmNonRtClientControl.readUInt();
 434     CARLA_SAFE_ASSERT_INT2(shmNonRtServerDataSize == sizeof(BridgeNonRtServerData), shmNonRtServerDataSize, sizeof(BridgeNonRtServerData));
 435
 436     if (shmRtClientDataSize != sizeof(BridgeRtClientData) ||
 437         shmNonRtClientDataSize != sizeof(BridgeNonRtClientData) ||
 438         shmNonRtServerDataSize != sizeof(BridgeNonRtServerData))
 439     {
 440         carla_stderr2("CarlaJackAppClient: data size mismatch");
 441         return false;
 442     }
 443
 444     opcode = fShmNonRtClientControl.readOpcode();
 445     CARLA_SAFE_ASSERT_RETURN(opcode == kPluginBridgeNonRtClientInitialSetup, false);
 446
 447     fServer.bufferSize = fShmNonRtClientControl.readUInt();
 448     fServer.sampleRate = fShmNonRtClientControl.readDouble();
 449
 450     if (fServer.bufferSize == 0 || carla_isZero(fServer.sampleRate))
 451     {
 452         carla_stderr2("CarlaJackAppClient: invalid empty state");
 453         return false;
 454     }
 455
 456     fAudioTmpBuf = new float[fServer.bufferSize];
 457     carla_zeroFloats(fAudioTmpBuf, fServer.bufferSize);
 458
 459     fLastPingTime = getCurrentTimeMilliseconds();
 460     CARLA_SAFE_ASSERT(fLastPingTime > 0);
 461
 462     {
 463         // tell backend we're live
 464         const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);
 465
 466         // ready!
 467         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerReady);
 468         fShmNonRtServerControl.commitWrite();
 469         fShmNonRtServerControl.waitIfDataIsReachingLimit();
 470     }
 471
 472     fIsReady = true;
 473     return true;
 474 }
 475
 476 void CarlaJackAppClient::clearSharedMemory() noexcept
 477 {
 478     const CarlaMutexLocker cml(fRealtimeThreadMutex);
 479
 480     if (fAudioPoolCopy != nullptr)
 481     {
 482         delete[] fAudioPoolCopy;
 483         fAudioPoolCopy = nullptr;
 484     }
 485
 486     if (fAudioTmpBuf != nullptr)
 487     {
 488         delete[] fAudioTmpBuf;
 489         fAudioTmpBuf = nullptr;
 490     }
 491
 492     if (fMidiInBuffers != nullptr)
 493     {
 494         delete[] fMidiInBuffers;
 495         fMidiInBuffers = nullptr;
 496     }
 497
 498     if (fMidiOutBuffers != nullptr)
 499     {
 500         delete[] fMidiOutBuffers;
 501         fMidiOutBuffers = nullptr;
 502     }
 503
 504     fShmAudioPool.clear();
 505     fShmRtClientControl.clear();
 506     fShmNonRtClientControl.clear();
 507     fShmNonRtServerControl.clear();
 508 }
 509
 510 bool CarlaJackAppClient::handleRtData()
 511 {
 512     if (fNewClients.count() != 0)
 513     {
 514         for (LinkedList<JackClientState*>::Itenerator it = fNewClients.begin2(); it.valid(); it.next())
 515         {
 516             JackClientState* const jclient(it.getValue(nullptr));
 517             CARLA_SAFE_ASSERT_CONTINUE(jclient != nullptr);
 518
 519             if (jclient->threadInitCb != nullptr)
 520                 jclient->threadInitCb(jclient->threadInitCbPtr);
 521         }
 522
 523         fNewClients.clear();
 524     }
 525
 526     const BridgeRtClientControl::WaitHelper helper(fShmRtClientControl);
 527
 528     if (! helper.ok)
 529         return false;
 530
 531     bool ret = false;
 532
 533     for (; fShmRtClientControl.isDataAvailableForReading();)
 534     {
 535         const PluginBridgeRtClientOpcode opcode(fShmRtClientControl.readOpcode());
 536 #ifdef DEBUG
 537         if (opcode != kPluginBridgeRtClientProcess && opcode != kPluginBridgeRtClientMidiEvent) {
 538             carla_debug("CarlaJackAppClientRtThread::run() - got opcode: %s", PluginBridgeRtClientOpcode2str(opcode));
 539         }
 540 #endif
 541
 542         switch (opcode)
 543         {
 544         case kPluginBridgeRtClientNull:
 545             break;
 546
 547         case kPluginBridgeRtClientSetAudioPool: {
 548             const CarlaMutexLocker cml(fRealtimeThreadMutex);
 549
 550             if (fShmAudioPool.data != nullptr)
 551             {
 552                 jackbridge_shm_unmap(fShmAudioPool.shm, fShmAudioPool.data);
 553                 fShmAudioPool.data = nullptr;
 554             }
 555             if (fAudioPoolCopy != nullptr)
 556             {
 557                 delete[] fAudioPoolCopy;
 558                 fAudioPoolCopy = nullptr;
 559             }
 560             const uint64_t poolSize(fShmRtClientControl.readULong());
 561             CARLA_SAFE_ASSERT_BREAK(poolSize > 0);
 562             fShmAudioPool.data = (float*)jackbridge_shm_map(fShmAudioPool.shm, static_cast<size_t>(poolSize));
 563             fAudioPoolCopy = new float[poolSize];
 564             break;
 565         }
 566
 567         case kPluginBridgeRtClientSetBufferSize:
 568             if (const uint32_t newBufferSize = fShmRtClientControl.readUInt())
 569             {
 570                 if (fServer.bufferSize != newBufferSize)
 571                 {
 572                     const CarlaMutexLocker cml(fRealtimeThreadMutex);
 573
 574                     fServer.bufferSize = newBufferSize;
 575
 576                     for (LinkedList<JackClientState*>::Itenerator it = fClients.begin2(); it.valid(); it.next())
 577                     {
 578                         JackClientState* const jclient(it.getValue(nullptr));
 579                         CARLA_SAFE_ASSERT_CONTINUE(jclient != nullptr);
 580
 581                         if (jclient->bufferSizeCb != nullptr)
 582                             jclient->bufferSizeCb(fServer.bufferSize, jclient->bufferSizeCbPtr);
 583                     }
 584
 585                     delete[] fAudioTmpBuf;
 586                     fAudioTmpBuf = new float[fServer.bufferSize];
 587                     carla_zeroFloats(fAudioTmpBuf, fServer.bufferSize);
 588                 }
 589             }
 590             break;
 591
 592         case kPluginBridgeRtClientSetSampleRate: {
 593             const double newSampleRate = fShmRtClientControl.readDouble();
 594
 595             if (carla_isNotZero(newSampleRate) && carla_isNotEqual(fServer.sampleRate, newSampleRate))
 596             {
 597                 const CarlaMutexLocker cml(fRealtimeThreadMutex);
 598
 599                 fServer.sampleRate = newSampleRate;
 600
 601                 for (LinkedList<JackClientState*>::Itenerator it = fClients.begin2(); it.valid(); it.next())
 602                 {
 603                     JackClientState* const jclient(it.getValue(nullptr));
 604                     CARLA_SAFE_ASSERT_CONTINUE(jclient != nullptr);
 605
 606                     if (jclient->sampleRateCb != nullptr)
 607                         jclient->sampleRateCb(static_cast<uint32_t>(fServer.sampleRate), jclient->sampleRateCbPtr);
 608                 }
 609             }
 610         }   break;
 611
 612         case kPluginBridgeRtClientSetOnline: {
 613             const bool offline = fShmRtClientControl.readBool();
 614
 615             if (fIsOffline != offline)
 616             {
 617                 const CarlaMutexLocker cml(fRealtimeThreadMutex);
 618
 619                 fIsOffline = offline;
 620
 621                 for (LinkedList<JackClientState*>::Itenerator it = fClients.begin2(); it.valid(); it.next())
 622                 {
 623                     JackClientState* const jclient(it.getValue(nullptr));
 624                     CARLA_SAFE_ASSERT_CONTINUE(jclient != nullptr);
 625
 626                     if (jclient->freewheelCb != nullptr)
 627                         jclient->freewheelCb(offline ? 1 : 0, jclient->freewheelCbPtr);
 628                 }
 629             }
 630         }   break;
 631
 632         case kPluginBridgeRtClientControlEventParameter:
 633             break;
 634
 635         case kPluginBridgeRtClientControlEventMidiBank: {
 636             const uint32_t time    = fShmRtClientControl.readUInt();
 637             const uint8_t  channel = fShmRtClientControl.readByte();
 638             const uint16_t value   = fShmRtClientControl.readUShort();
 639
 640             if (fServer.numMidiIns > 0 && fRealtimeThreadMutex.tryLock())
 641             {
 642                 JackMidiPortBufferOnStack& midiPortBuf(fMidiInBuffers[0]);
 643
 644                 if (midiPortBuf.count+1U < JackMidiPortBufferBase::kMaxEventCount &&
 645                     midiPortBuf.bufferPoolPos + 6U < JackMidiPortBufferBase::kBufferPoolSize)
 646                 {
 647                     jack_midi_event_t& ev1(midiPortBuf.events[midiPortBuf.count++]);
 648                     ev1.time   = time;
 649                     ev1.size   = 3;
 650                     ev1.buffer = midiPortBuf.bufferPool + midiPortBuf.bufferPoolPos;
 651                     ev1.buffer[0] = jack_midi_data_t(MIDI_STATUS_CONTROL_CHANGE | (channel & MIDI_CHANNEL_BIT));
 652                     ev1.buffer[1] = MIDI_CONTROL_BANK_SELECT;
 653                     ev1.buffer[2] = 0;
 654                     midiPortBuf.bufferPoolPos += 3;
 655
 656                     jack_midi_event_t& ev2(midiPortBuf.events[midiPortBuf.count++]);
 657                     ev2.time   = time;
 658                     ev2.size   = 3;
 659                     ev2.buffer = midiPortBuf.bufferPool + midiPortBuf.bufferPoolPos;
 660                     ev2.buffer[0] = jack_midi_data_t(MIDI_STATUS_CONTROL_CHANGE | (channel & MIDI_CHANNEL_BIT));
 661                     ev2.buffer[1] = MIDI_CONTROL_BANK_SELECT__LSB;
 662                     ev2.buffer[2] = jack_midi_data_t(value);
 663                     midiPortBuf.bufferPoolPos += 3;
 664                 }
 665
 666                 fRealtimeThreadMutex.unlock(true);
 667             }
 668             break;
 669         }
 670
 671         case kPluginBridgeRtClientControlEventMidiProgram: {
 672             const uint32_t time    = fShmRtClientControl.readUInt();
 673             const uint8_t  channel = fShmRtClientControl.readByte();
 674             const uint16_t value   = fShmRtClientControl.readUShort();
 675
 676             if (fServer.numMidiIns > 0 && fRealtimeThreadMutex.tryLock())
 677             {
 678                 JackMidiPortBufferOnStack& midiPortBuf(fMidiInBuffers[0]);
 679
 680                 if (midiPortBuf.count < JackMidiPortBufferBase::kMaxEventCount &&
 681                     midiPortBuf.bufferPoolPos + 2U < JackMidiPortBufferBase::kBufferPoolSize)
 682                 {
 683                     jack_midi_event_t& ev(midiPortBuf.events[midiPortBuf.count++]);
 684
 685                     ev.time   = time;
 686                     ev.size   = 2;
 687                     ev.buffer = midiPortBuf.bufferPool + midiPortBuf.bufferPoolPos;
 688                     ev.buffer[0] = jack_midi_data_t(MIDI_STATUS_PROGRAM_CHANGE | (channel & MIDI_CHANNEL_BIT));
 689                     ev.buffer[1] = jack_midi_data_t(value);
 690                     midiPortBuf.bufferPoolPos += 2;
 691                 }
 692
 693                 fRealtimeThreadMutex.unlock(true);
 694             }
 695             break;
 696         }
 697
 698         case kPluginBridgeRtClientControlEventAllSoundOff: {
 699             const uint32_t time    = fShmRtClientControl.readUInt();
 700             const uint8_t  channel = fShmRtClientControl.readByte();
 701
 702             if (fServer.numMidiIns > 0 && fRealtimeThreadMutex.tryLock())
 703             {
 704                 JackMidiPortBufferOnStack& midiPortBuf(fMidiInBuffers[0]);
 705
 706                 if (midiPortBuf.count < JackMidiPortBufferBase::kMaxEventCount &&
 707                     midiPortBuf.bufferPoolPos + 3U < JackMidiPortBufferBase::kBufferPoolSize)
 708                 {
 709                     jack_midi_event_t& ev(midiPortBuf.events[midiPortBuf.count++]);
 710
 711                     ev.time   = time;
 712                     ev.size   = 3;
 713                     ev.buffer = midiPortBuf.bufferPool + midiPortBuf.bufferPoolPos;
 714                     ev.buffer[0] = jack_midi_data_t(MIDI_STATUS_CONTROL_CHANGE | (channel & MIDI_CHANNEL_BIT));
 715                     ev.buffer[1] = MIDI_CONTROL_ALL_SOUND_OFF;
 716                     ev.buffer[2] = 0;
 717                     midiPortBuf.bufferPoolPos += 3;
 718                 }
 719
 720                 fRealtimeThreadMutex.unlock(true);
 721             }
 722             break;
 723         }
 724
 725         case kPluginBridgeRtClientControlEventAllNotesOff: {
 726             const uint32_t time    = fShmRtClientControl.readUInt();
 727             const uint8_t  channel = fShmRtClientControl.readByte();
 728
 729             if (fServer.numMidiIns > 0 && fRealtimeThreadMutex.tryLock())
 730             {
 731                 JackMidiPortBufferOnStack& midiPortBuf(fMidiInBuffers[0]);
 732
 733                 if (midiPortBuf.count < JackMidiPortBufferBase::kMaxEventCount &&
 734                     midiPortBuf.bufferPoolPos + 3U < JackMidiPortBufferBase::kBufferPoolSize)
 735                 {
 736                     jack_midi_event_t& ev(midiPortBuf.events[midiPortBuf.count++]);
 737
 738                     ev.time   = time;
 739                     ev.size   = 3;
 740                     ev.buffer = midiPortBuf.bufferPool + midiPortBuf.bufferPoolPos;
 741                     ev.buffer[0] = jack_midi_data_t(MIDI_STATUS_CONTROL_CHANGE | (channel & MIDI_CHANNEL_BIT));
 742                     ev.buffer[1] = MIDI_CONTROL_ALL_NOTES_OFF;
 743                     ev.buffer[2] = 0;
 744                     midiPortBuf.bufferPoolPos += 3;
 745                 }
 746
 747                 fRealtimeThreadMutex.unlock(true);
 748             }
 749             break;
 750         }
 751
 752         case kPluginBridgeRtClientMidiEvent: {
 753             const uint32_t time = fShmRtClientControl.readUInt();
 754             const uint8_t  port = fShmRtClientControl.readByte();
 755             const uint8_t  size = fShmRtClientControl.readByte();
 756             CARLA_SAFE_ASSERT_BREAK(size > 0);
 757
 758             if (port >= fServer.numMidiIns || size > JackMidiPortBufferBase::kMaxEventSize || ! fRealtimeThreadMutex.tryLock())
 759             {
 760                 for (uint8_t i=0; i<size; ++i)
 761                     fShmRtClientControl.readByte();
 762                 break;
 763             }
 764
 765             JackMidiPortBufferOnStack& midiPortBuf(fMidiInBuffers[port]);
 766
 767             if (midiPortBuf.count < JackMidiPortBufferBase::kMaxEventCount &&
 768                 midiPortBuf.bufferPoolPos + size < JackMidiPortBufferBase::kBufferPoolSize)
 769             {
 770                 jack_midi_event_t& ev(midiPortBuf.events[midiPortBuf.count++]);
 771
 772                 ev.time   = time;
 773                 ev.size   = size;
 774                 ev.buffer = midiPortBuf.bufferPool + midiPortBuf.bufferPoolPos;
 775                 midiPortBuf.bufferPoolPos += size;
 776
 777                 for (uint8_t i=0; i<size; ++i)
 778                     ev.buffer[i] = fShmRtClientControl.readByte();
 779             }
 780
 781             fRealtimeThreadMutex.unlock(true);
 782             break;
 783         }
 784
 785         case kPluginBridgeRtClientProcess: {
 786             const uint32_t frames(fShmRtClientControl.readUInt());
 787             CARLA_SAFE_ASSERT_UINT2_BREAK(frames == fServer.bufferSize, frames, fServer.bufferSize);
 788
 789             // TODO tell client of xrun in case buffersize does not match
 790
 791             const CarlaMutexTryLocker cmtl(fRealtimeThreadMutex, fIsOffline);
 792
 793             if (cmtl.wasLocked())
 794             {
 795                 CARLA_SAFE_ASSERT_BREAK(fShmAudioPool.data != nullptr);
 796
 797                 // mixdown is default, do buffer addition (for multiple clients) if requested
 798                 const bool doBufferAddition  = fSetupHints & LIBJACK_FLAG_AUDIO_BUFFERS_ADDITION;
 799                 // mixdown midi outputs based on channel if requested
 800                 const bool doMidiChanMixdown = fSetupHints & LIBJACK_FLAG_MIDI_OUTPUT_CHANNEL_MIXDOWN;
 801
 802                 // location to start of audio outputs (shm buffer)
 803                 float* const fdataRealOuts = fShmAudioPool.data+(fServer.bufferSize*fServer.numAudioIns);
 804
 805                 if (doBufferAddition && fServer.numAudioOuts > 0)
 806                     carla_zeroFloats(fdataRealOuts, fServer.bufferSize*fServer.numAudioOuts);
 807
 808                 if (! fClients.isEmpty())
 809                 {
 810                     // save transport for all clients
 811                     const BridgeTimeInfo& bridgeTimeInfo(fShmRtClientControl.data->timeInfo);
 812
 813                     const bool transportChanged = fServer.playing != bridgeTimeInfo.playing ||
 814                                                   (bridgeTimeInfo.playing && fServer.position.frame + frames != bridgeTimeInfo.frame);
 815
 816                     fServer.playing        = bridgeTimeInfo.playing;
 817                     fServer.position.frame = static_cast<jack_nframes_t>(bridgeTimeInfo.frame);
 818                     fServer.position.usecs = bridgeTimeInfo.usecs;
 819
 820                     fServer.position.frame_rate = static_cast<jack_nframes_t>(fServer.sampleRate);
 821
 822                     if (bridgeTimeInfo.validFlags & kPluginBridgeTimeInfoValidBBT)
 823                     {
 824                         fServer.position.bar  = bridgeTimeInfo.bar;
 825                         fServer.position.beat = bridgeTimeInfo.beat;
 826                         fServer.position.tick = static_cast<int32_t>(bridgeTimeInfo.tick + 0.5);
 827
 828                         fServer.position.beats_per_bar = bridgeTimeInfo.beatsPerBar;
 829                         fServer.position.beat_type     = bridgeTimeInfo.beatType;
 830
 831                         fServer.position.ticks_per_beat   = bridgeTimeInfo.ticksPerBeat;
 832                         fServer.position.beats_per_minute = bridgeTimeInfo.beatsPerMinute;
 833                         fServer.position.bar_start_tick   = bridgeTimeInfo.barStartTick;
 834
 835 #ifdef JACK_TICK_DOUBLE
 836                         fServer.position.tick_double = bridgeTimeInfo.tick;
 837                         fServer.position.valid = static_cast<jack_position_bits_t>(JackPositionBBT|JackTickDouble);
 838 #else
 839                         fServer.position.valid = JackPositionBBT;
 840 #endif
 841                     }
 842                     else
 843                     {
 844                         fServer.position.valid = static_cast<jack_position_bits_t>(0x0);
 845                     }
 846
 847                     int numClientOutputsProcessed = 0;
 848
 849                     // now go through each client
 850                     for (LinkedList<JackClientState*>::Itenerator it = fClients.begin2(); it.valid(); it.next())
 851                     {
 852                         JackClientState* const jclient(it.getValue(nullptr));
 853                         CARLA_SAFE_ASSERT_CONTINUE(jclient != nullptr);
 854
 855                         const CarlaMutexTryLocker cmtl2(jclient->mutex, fIsOffline);
 856
 857                         // check if we can process
 858                         if (cmtl2.wasNotLocked() || jclient->processCb == nullptr || ! jclient->activated)
 859                         {
 860                             if (fServer.numAudioOuts > 0)
 861                                 carla_zeroFloats(fdataRealOuts, fServer.bufferSize*fServer.numAudioOuts);
 862
 863                             if (jclient->deactivated)
 864                                 fShmRtClientControl.data->procFlags = 1;
 865                         }
 866                         else
 867                         {
 868                             // report transport sync changes if needed
 869                             if (transportChanged && jclient->syncCb != nullptr)
 870                             {
 871                                 jclient->syncCb(fServer.playing ? JackTransportRolling : JackTransportStopped,
 872                                                 &fServer.position,
 873                                                 jclient->syncCbPtr);
 874                             }
 875
 876                             uint8_t i;
 877                             // direct access to shm buffer, used only for inputs
 878                             float* fdataReal = fShmAudioPool.data;
 879                             // safe temp location for output, mixed down to shm buffer later on
 880                             float* fdataCopy = fAudioPoolCopy;
 881                             // wherever we're using fAudioTmpBuf
 882                             bool needsTmpBufClear = false;
 883
 884                             // set audio inputs
 885                             i = 0;
 886                             for (LinkedList<JackPortState*>::Itenerator it2 = jclient->audioIns.begin2(); it2.valid(); it2.next())
 887                             {
 888                                 JackPortState* const jport = it2.getValue(nullptr);
 889                                 CARLA_SAFE_ASSERT_CONTINUE(jport != nullptr);
 890
 891                                 if (i++ < fServer.numAudioIns)
 892                                 {
 893                                     if (numClientOutputsProcessed == 0 || ! doBufferAddition)
 894                                         jport->buffer = fdataReal;
 895                                     else
 896                                         jport->buffer = fdataRealOuts + (i*fServer.bufferSize);
 897
 898                                     fdataReal += fServer.bufferSize;
 899                                     fdataCopy += fServer.bufferSize;
 900                                 }
 901                                 else
 902                                 {
 903                                     jport->buffer = fAudioTmpBuf;
 904                                     needsTmpBufClear = true;
 905                                 }
 906                             }
 907                             if (i < fServer.numAudioIns)
 908                             {
 909                                 const std::size_t remainingBufferSize = fServer.bufferSize * static_cast<uint8_t>(fServer.numAudioIns - i);
 910                                 //fdataReal += remainingBufferSize;
 911                                 fdataCopy += remainingBufferSize;
 912                             }
 913
 914                             // location to start of audio outputs
 915                             float* const fdataCopyOuts = fdataCopy;
 916
 917                             // set audio outputs
 918                             i = 0;
 919                             for (LinkedList<JackPortState*>::Itenerator it2 = jclient->audioOuts.begin2(); it2.valid(); it2.next())
 920                             {
 921                                 JackPortState* const jport = it2.getValue(nullptr);
 922                                 CARLA_SAFE_ASSERT_CONTINUE(jport != nullptr);
 923
 924                                 if (i++ < fServer.numAudioOuts)
 925                                 {
 926                                     jport->buffer = fdataCopy;
 927                                     fdataCopy += fServer.bufferSize;
 928                                 }
 929                                 else
 930                                 {
 931                                     jport->buffer = fAudioTmpBuf;
 932                                     needsTmpBufClear = true;
 933                                 }
 934                             }
 935                             if (i < fServer.numAudioOuts)
 936                             {
 937                                 const std::size_t remainingBufferSize = fServer.bufferSize * static_cast<uint8_t>(fServer.numAudioOuts - i);
 938                                 carla_zeroFloats(fdataCopy, remainingBufferSize);
 939                                 //fdataCopy += remainingBufferSize;
 940                             }
 941
 942                             // set midi inputs
 943                             i = 0;
 944                             for (LinkedList<JackPortState*>::Itenerator it2 = jclient->midiIns.begin2(); it2.valid(); it2.next())
 945                             {
 946                                 JackPortState* const jport = it2.getValue(nullptr);
 947                                 CARLA_SAFE_ASSERT_CONTINUE(jport != nullptr);
 948
 949                                 if (i++ < fServer.numMidiIns)
 950                                     jport->buffer = &fMidiInBuffers[i-1];
 951                                 else
 952                                     jport->buffer = &fDummyMidiInBuffer;
 953                             }
 954
 955                             // set midi outputs
 956                             i = 0;
 957                             for (LinkedList<JackPortState*>::Itenerator it2 = jclient->midiOuts.begin2(); it2.valid(); it2.next())
 958                             {
 959                                 JackPortState* const jport = it2.getValue(nullptr);
 960                                 CARLA_SAFE_ASSERT_CONTINUE(jport != nullptr);
 961
 962                                 if (i++ < fServer.numMidiOuts)
 963                                     jport->buffer = &fMidiOutBuffers[i-1];
 964                                 else
 965                                     jport->buffer = &fDummyMidiOutBuffer;
 966                             }
 967
 968                             if (needsTmpBufClear)
 969                                 carla_zeroFloats(fAudioTmpBuf, fServer.bufferSize);
 970
 971                             jclient->processCb(fServer.bufferSize, jclient->processCbPtr);
 972
 973                             if (fServer.numAudioOuts > 0)
 974                             {
 975                                 if (++numClientOutputsProcessed == 1)
 976                                 {
 977                                     // first client, we can copy stuff over
 978                                     carla_copyFloats(fdataRealOuts, fdataCopyOuts,
 979                                                      fServer.bufferSize*fServer.numAudioOuts);
 980                                 }
 981                                 else
 982                                 {
 983                                     // subsequent clients, add data (then divide by number of clients later on)
 984                                     carla_add(fdataRealOuts, fdataCopyOuts,
 985                                               fServer.bufferSize*fServer.numAudioOuts);
 986
 987                                     if (doBufferAddition)
 988                                     {
 989                                         // for more than 1 client addition, we need to divide buffers now
 990                                         carla_multiply(fdataRealOuts,
 991                                                        1.0f/static_cast<float>(numClientOutputsProcessed),
 992                                                        fServer.bufferSize*fServer.numAudioOuts);
 993                                     }
 994                                 }
 995
 996                                 if (jclient->audioOuts.count() == 1 && fServer.numAudioOuts > 1)
 997                                 {
 998                                     for (uint8_t j=1; j<fServer.numAudioOuts; ++j)
 999                                     {
1000                                         carla_copyFloats(fdataRealOuts+(fServer.bufferSize*j),
1001                                                          fdataCopyOuts,
1002                                                          fServer.bufferSize);
1003                                     }
1004                                 }
1005                             }
1006                         }
1007                     }
1008
1009                     if (numClientOutputsProcessed > 1 && ! doBufferAddition)
1010                     {
1011                         // more than 1 client active, need to divide buffers
1012                         carla_multiply(fdataRealOuts,
1013                                        1.0f/static_cast<float>(numClientOutputsProcessed),
1014                                        fServer.bufferSize*fServer.numAudioOuts);
1015                     }
1016                 }
1017                 // fClients.isEmpty()
1018                 else if (fServer.numAudioOuts > 0)
1019                 {
1020                     carla_zeroFloats(fdataRealOuts, fServer.bufferSize*fServer.numAudioOuts);
1021                 }
1022
1023                 for (uint8_t i=0; i<fServer.numMidiIns; ++i)
1024                 {
1025                     fMidiInBuffers[i].count = 0;
1026                     fMidiInBuffers[i].bufferPoolPos = 0;
1027                 }
1028
1029                 if (fServer.numMidiOuts > 0)
1030                 {
1031                     uint8_t* midiData = fShmRtClientControl.data->midiOut;
1032                     carla_zeroBytes(midiData, kBridgeBaseMidiOutHeaderSize);
1033                     std::size_t curMidiDataPos = 0;
1034
1035                     for (uint8_t i=0; i<fServer.numMidiOuts; ++i)
1036                     {
1037                         JackMidiPortBufferOnStack& midiPortBuf(fMidiOutBuffers[i]);
1038
1039                         for (uint16_t j=0; j<midiPortBuf.count; ++j)
1040                         {
1041                             jack_midi_event_t& jmevent(midiPortBuf.events[j]);
1042
1043                             if (curMidiDataPos + kBridgeBaseMidiOutHeaderSize + jmevent.size >= kBridgeRtClientDataMidiOutSize)
1044                                 break;
1045
1046                             if (doMidiChanMixdown && MIDI_IS_CHANNEL_MESSAGE(jmevent.buffer[0]))
1047                                 jmevent.buffer[0] = static_cast<jack_midi_data_t>(
1048                                                     (jmevent.buffer[0] & MIDI_STATUS_BIT) | (i & MIDI_CHANNEL_BIT));
1049
1050                             // set time
1051                             *(uint32_t*)midiData = jmevent.time;
1052                             midiData += 4;
1053
1054                             // set port
1055                             *midiData++ = doMidiChanMixdown ? 0 : i;
1056
1057                             // set size
1058                             *midiData++ = static_cast<uint8_t>(jmevent.size);
1059
1060                             // set data
1061                             std::memcpy(midiData, jmevent.buffer, jmevent.size);
1062                             midiData += jmevent.size;
1063
1064                             curMidiDataPos += kBridgeBaseMidiOutHeaderSize + jmevent.size;
1065                         }
1066                     }
1067
1068                     // make last event null, so server stops when reaching it
1069                     if (curMidiDataPos != 0 &&
1070                         curMidiDataPos + kBridgeBaseMidiOutHeaderSize < kBridgeRtClientDataMidiOutSize)
1071                     {
1072                         carla_zeroBytes(midiData, kBridgeBaseMidiOutHeaderSize);
1073
1074                         // sort events in case of mixdown
1075                         if (doMidiChanMixdown)
1076                         {
1077                             uint32_t time;
1078                             uint8_t size, *midiDataPtr;
1079                             uint8_t tmp[kBridgeBaseMidiOutHeaderSize + JackMidiPortBufferBase::kMaxEventSize];
1080                             bool wasSorted = true;
1081
1082                             for (; wasSorted;)
1083                             {
1084                                 midiDataPtr = fShmRtClientControl.data->midiOut;
1085                                 uint8_t* prevData = midiDataPtr;
1086                                 uint32_t prevTime = *(uint32_t*)midiDataPtr;
1087                                 uint8_t prevSize = *(midiDataPtr + 5);
1088                                 wasSorted = false;
1089
1090                                 for (;;)
1091                                 {
1092                                     time = *(uint32_t*)midiDataPtr;
1093                                     size = *(midiDataPtr + 5); // time and port
1094
1095                                     if (size == 0)
1096                                         break;
1097
1098                                     if (prevTime > time)
1099                                     {
1100                                         // copy previous data to a temporary place
1101                                         std::memcpy(tmp, prevData, kBridgeBaseMidiOutHeaderSize + prevSize);
1102                                         // override previous data with new one (shifting left)
1103                                         std::memcpy(prevData, midiDataPtr, kBridgeBaseMidiOutHeaderSize + size);
1104                                         // override new data with old one
1105                                         std::memcpy(midiDataPtr, tmp, kBridgeBaseMidiOutHeaderSize + prevSize);
1106                                         // done swapping, flag it
1107                                         wasSorted = true;
1108                                     }
1109
1110                                     prevTime = time;
1111                                     prevSize = size;
1112                                     prevData = midiDataPtr;
1113                                     midiDataPtr += 6 + size;
1114                                 }
1115                             }
1116                         }
1117                     }
1118                 }
1119             }
1120             else
1121             {
1122                 carla_stderr2("CarlaJackAppClient: fRealtimeThreadMutex tryLock failed");
1123             }
1124             fServer.monotonic_frame += frames;
1125             break;
1126         }
1127
1128         case kPluginBridgeRtClientQuit:
1129             ret = true;
1130             break;
1131         }
1132
1133 #ifdef DEBUG
1134         if (opcode != kPluginBridgeRtClientProcess && opcode != kPluginBridgeRtClientMidiEvent) {
1135             carla_debug("CarlaJackAppClientRtThread::run() - opcode %s done", PluginBridgeRtClientOpcode2str(opcode));
1136         }
1137 #endif
1138     }
1139
1140     return ret;
1141 }
1142
1143 bool CarlaJackAppClient::handleNonRtData()
1144 {
1145     bool ret = false;
1146
1147     for (; fShmNonRtClientControl.isDataAvailableForReading();)
1148     {
1149         const PluginBridgeNonRtClientOpcode opcode(fShmNonRtClientControl.readOpcode());
1150 #ifdef DEBUG
1151         if (opcode != kPluginBridgeNonRtClientPing) {
1152             carla_debug("CarlaJackAppClient::handleNonRtData() - got opcode: %s", PluginBridgeNonRtClientOpcode2str(opcode));
1153         }
1154 #endif
1155
1156         if (opcode != kPluginBridgeNonRtClientNull && opcode != kPluginBridgeNonRtClientPingOnOff && fLastPingTime > 0)
1157             fLastPingTime = getCurrentTimeMilliseconds();
1158
1159         switch (opcode)
1160         {
1161         case kPluginBridgeNonRtClientNull:
1162             break;
1163
1164         case kPluginBridgeNonRtClientVersion: {
1165             const uint apiVersion = fShmNonRtServerControl.readUInt();
1166             CARLA_SAFE_ASSERT_UINT2(apiVersion == CARLA_PLUGIN_BRIDGE_API_VERSION_CURRENT,
1167                                     apiVersion, CARLA_PLUGIN_BRIDGE_API_VERSION_CURRENT);
1168         }   break;
1169
1170         case kPluginBridgeNonRtClientPing: {
1171             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);
1172
1173             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPong);
1174             fShmNonRtServerControl.commitWrite();
1175         }   break;
1176
1177         case kPluginBridgeNonRtClientPingOnOff: {
1178             const uint32_t onOff(fShmNonRtClientControl.readBool());
1179
1180             fLastPingTime = onOff ? getCurrentTimeMilliseconds() : -1;
1181         }   break;
1182
1183         case kPluginBridgeNonRtClientActivate:
1184         case kPluginBridgeNonRtClientDeactivate:
1185             break;
1186
1187         case kPluginBridgeNonRtClientInitialSetup:
1188             // should never happen!!
1189             fShmNonRtServerControl.readUInt();
1190             fShmNonRtServerControl.readDouble();
1191             break;
1192
1193         case kPluginBridgeNonRtClientSetParameterValue:
1194         case kPluginBridgeNonRtClientSetParameterMidiChannel:
1195         case kPluginBridgeNonRtClientSetParameterMappedControlIndex:
1196         case kPluginBridgeNonRtClientSetParameterMappedRange:
1197         case kPluginBridgeNonRtClientSetProgram:
1198         case kPluginBridgeNonRtClientSetMidiProgram:
1199         case kPluginBridgeNonRtClientSetCustomData:
1200         case kPluginBridgeNonRtClientSetChunkDataFile:
1201         case kPluginBridgeNonRtClientSetWindowTitle:
1202             break;
1203
1204         case kPluginBridgeNonRtClientSetOption:
1205             fShmNonRtClientControl.readUInt();
1206             fShmNonRtClientControl.readBool();
1207             break;
1208
1209         case kPluginBridgeNonRtClientSetOptions:
1210             fShmNonRtClientControl.readUInt();
1211             break;
1212
1213         case kPluginBridgeNonRtClientSetCtrlChannel:
1214             fShmNonRtClientControl.readShort();
1215             break;
1216
1217         case kPluginBridgeNonRtClientGetParameterText:
1218             fShmNonRtClientControl.readUInt();
1219             break;
1220
1221         case kPluginBridgeNonRtClientPrepareForSave:
1222             {
1223                 if (fSessionManager == LIBJACK_SESSION_MANAGER_AUTO && std::getenv("NSM_URL") == nullptr)
1224                 {
1225                     struct sigaction sig;
1226                     carla_zeroStruct(sig);
1227
1228                     sigaction(SIGUSR1, nullptr, &sig);
1229
1230                     if (sig.sa_handler != nullptr)
1231                         fSessionManager = LIBJACK_SESSION_MANAGER_LADISH;
1232                 }
1233
1234                 if (fSessionManager == LIBJACK_SESSION_MANAGER_LADISH)
1235                     ::kill(::getpid(), SIGUSR1);
1236
1237                 const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);
1238
1239                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSaved);
1240                 fShmNonRtServerControl.commitWrite();
1241             }
1242             break;
1243
1244         case kPluginBridgeNonRtClientRestoreLV2State:
1245             break;
1246
1247         case kPluginBridgeNonRtClientShowUI:
1248             if (jack_carla_interposed_action(LIBJACK_INTERPOSER_ACTION_SHOW_HIDE_GUI, 1, nullptr) == 1337)
1249             {
1250                 // failed, LD_PRELOAD did not work?
1251                 const char* const message("Cannot show UI, LD_PRELOAD not working?");
1252                 const std::size_t messageSize(std::strlen(message));
1253
1254                 const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);
1255
1256                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerUiClosed);
1257                 fShmNonRtServerControl.commitWrite();
1258
1259                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerError);
1260                 fShmNonRtServerControl.writeUInt(messageSize);
1261                 fShmNonRtServerControl.writeCustomData(message, messageSize);
1262                 fShmNonRtServerControl.commitWrite();
1263             }
1264             break;
1265
1266         case kPluginBridgeNonRtClientHideUI:
1267             jack_carla_interposed_action(LIBJACK_INTERPOSER_ACTION_SHOW_HIDE_GUI, 0, nullptr);
1268             break;
1269
1270         case kPluginBridgeNonRtClientUiParameterChange:
1271         case kPluginBridgeNonRtClientUiProgramChange:
1272         case kPluginBridgeNonRtClientUiMidiProgramChange:
1273         case kPluginBridgeNonRtClientUiNoteOn:
1274         case kPluginBridgeNonRtClientUiNoteOff:
1275             break;
1276
1277         case kPluginBridgeNonRtClientEmbedUI:
1278             fShmNonRtClientControl.readULong();
1279             break;
1280
1281         case kPluginBridgeNonRtClientQuit:
1282             ret = true;
1283             break;
1284
1285         case kPluginBridgeNonRtClientReload:
1286             break;
1287         }
1288
1289 #ifdef DEBUG
1290         if (opcode != kPluginBridgeNonRtClientPing) {
1291             carla_debug("CarlaJackAppClient::handleNonRtData() - opcode %s handled", PluginBridgeNonRtClientOpcode2str(opcode));
1292         }
1293 #endif
1294     }
1295
1296     return ret;
1297 }
1298
1299 void CarlaJackAppClient::runRealtimeThread()
1300 {
1301     carla_debug("CarlaJackAppClient runRealtimeThread START");
1302
1303 #ifdef __SSE2_MATH__
1304     // Set FTZ and DAZ flags
1305     _mm_setcsr(_mm_getcsr() | 0x8040);
1306 #endif
1307
1308     bool quitReceived = false;
1309
1310     for (; ! fRealtimeThread.shouldThreadExit();)
1311     {
1312         if (handleRtData())
1313         {
1314             quitReceived = true;
1315             break;
1316         }
1317     }
1318
1319     fNonRealtimeThread.signalThreadShouldExit();
1320
1321     carla_debug("CarlaJackAppClient runRealtimeThread FINISHED");
1322
1323     // TODO
1324     return; (void)quitReceived;
1325 }
1326
1327 void CarlaJackAppClient::runNonRealtimeThread()
1328 {
1329     carla_debug("CarlaJackAppClient runNonRealtimeThread START");
1330     CARLA_SAFE_ASSERT_RETURN(initSharedMemmory(),);
1331
1332     if (fServer.numMidiIns > 0)
1333     {
1334         fMidiInBuffers = new JackMidiPortBufferOnStack[fServer.numMidiIns];
1335
1336         for (uint8_t i=0; i<fServer.numMidiIns; ++i)
1337             fMidiInBuffers[i].isInput = true;
1338     }
1339
1340     if (fServer.numMidiOuts > 0)
1341     {
1342         fMidiOutBuffers = new JackMidiPortBufferOnStack[fServer.numMidiOuts];
1343
1344         for (uint8_t i=0; i<fServer.numMidiOuts; ++i)
1345             fMidiOutBuffers[i].isInput = false;
1346     }
1347
1348     fRealtimeThread.startThread(true);
1349
1350     fLastPingTime = getCurrentTimeMilliseconds();
1351     carla_stdout("Carla Jack Client Ready!");
1352
1353     bool quitReceived = false,
1354          timedOut = false;
1355
1356     for (; ! fNonRealtimeThread.shouldThreadExit();)
1357     {
1358         carla_msleep(50);
1359
1360         try {
1361             quitReceived = handleNonRtData();
1362         } CARLA_SAFE_EXCEPTION("handleNonRtData");
1363
1364         if (quitReceived)
1365             break;
1366
1367         /*
1368         if (fLastPingTime > 0 && getCurrentTimeMilliseconds() > fLastPingTime + 30000)
1369         {
1370             carla_stderr("Did not receive ping message from server for 30 secs, closing...");
1371
1372             timedOut = true;
1373             fRealtimeThread.signalThreadShouldExit();
1374             break;
1375         }
1376         */
1377     }
1378
1379     //callback(true, true, ENGINE_CALLBACK_ENGINE_STOPPED, 0, 0, 0, 0.0f, nullptr);
1380
1381     if (quitReceived)
1382     {
1383         ::kill(::getpid(), SIGTERM);
1384     }
1385     else if (timedOut)
1386     {
1387         // TODO send shutdown?
1388         carla_stderr("CarlaJackAppClient error: runNonRealtimeThread ended with time out");
1389         ::kill(::getpid(), SIGTERM);
1390     }
1391     else
1392     {
1393         bool activated;
1394
1395         {
1396             const CarlaMutexLocker cms(fRealtimeThreadMutex);
1397
1398             if (fClients.isEmpty())
1399             {
1400                 activated = false;
1401             }
1402             else if (JackClientState* const jclient = fClients.getLast(nullptr))
1403             {
1404                 const CarlaMutexLocker cms2(jclient->mutex);
1405                 activated = jclient->activated;
1406             }
1407             else
1408             {
1409                 activated = true;
1410             }
1411         }
1412
1413         if (activated)
1414         {
1415             carla_stderr("CarlaJackAppClient error: runNonRealtimeThread ended while client is activated");
1416
1417             const char* const message("Plugin bridge error, process thread has stopped");
1418             const std::size_t messageSize(std::strlen(message));
1419
1420             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);
1421             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerError);
1422             fShmNonRtServerControl.writeUInt(messageSize);
1423             fShmNonRtServerControl.writeCustomData(message, messageSize);
1424             fShmNonRtServerControl.commitWrite();
1425         }
1426     }
1427
1428     if (fRealtimeThread.isThreadRunning())
1429     {
1430         fRealtimeThread.signalThreadShouldExit();
1431
1432         const CarlaMutexLocker cml(fRealtimeThreadMutex);
1433
1434         if (fShmRtClientControl.data != nullptr)
1435             fShmRtClientControl.data->procFlags = 1;
1436     }
1437
1438     clearSharedMemory();
1439
1440     fRealtimeThread.stopThread(5000);
1441
1442     carla_debug("CarlaJackAppClient runNonRealtimeThread FINISHED");
1443 }
1444
1445 CARLA_BACKEND_END_NAMESPACE
1446
1447 // ---------------------------------------------------------------------------------------------------------------------
1448
1449 using CARLA_BACKEND_NAMESPACE::CarlaJackAppClient;
1450 using CARLA_BACKEND_NAMESPACE::JackClientState;
1451
1452 static CarlaJackAppClient gClient;
1453
1454 CARLA_BACKEND_START_NAMESPACE
1455
1456 static int carla_interposed_callback(int cb_action, void* ptr)
1457 {
1458     return gClient.handleInterposerCallback(cb_action, ptr);
1459 }
1460
1461 CARLA_BACKEND_END_NAMESPACE
1462
1463 // ---------------------------------------------------------------------------------------------------------------------
1464
1465 CARLA_PLUGIN_EXPORT
1466 jack_client_t* jack_client_open(const char* client_name, jack_options_t options, jack_status_t* status, ...)
1467 {
1468     carla_debug("%s(%s, 0x%x, %p)", __FUNCTION__, client_name, options, status);
1469
1470     if (JackClientState* const client = gClient.createClient(client_name))
1471     {
1472         if (status != nullptr)
1473             *status = static_cast<JackStatus>(0x0);
1474
1475         return (jack_client_t*)client;
1476     }
1477
1478     if (status != nullptr)
1479         *status = JackServerError;
1480
1481     return nullptr;
1482
1483     // unused
1484     (void)options;
1485 }
1486
1487 CARLA_PLUGIN_EXPORT
1488 jack_client_t* jack_client_new(const char* client_name)
1489 {
1490     return jack_client_open(client_name, JackNullOption, nullptr);
1491 }
1492
1493 CARLA_PLUGIN_EXPORT
1494 int jack_client_close(jack_client_t* client)
1495 {
1496     carla_debug("%s(%p)", __FUNCTION__, client);
1497
1498     JackClientState* const jclient = (JackClientState*)client;
1499     CARLA_SAFE_ASSERT_RETURN(jclient != nullptr, 1);
1500
1501     gClient.destroyClient(jclient);
1502     return 0;
1503 }
1504
1505 CARLA_PLUGIN_EXPORT
1506 int jack_activate(jack_client_t* client)
1507 {
1508     carla_debug("%s(%p)", __FUNCTION__, client);
1509
1510     JackClientState* const jclient = (JackClientState*)client;
1511     CARLA_SAFE_ASSERT_RETURN(jclient != nullptr, 1);
1512
1513     return gClient.activateClient(jclient) ? 0 : 1;
1514 }
1515
1516 CARLA_PLUGIN_EXPORT
1517 int jack_deactivate(jack_client_t* client)
1518 {
1519     carla_debug("%s(%p)", __FUNCTION__, client);
1520
1521     JackClientState* const jclient = (JackClientState*)client;
1522     CARLA_SAFE_ASSERT_RETURN(jclient != nullptr, 1);
1523
1524     return gClient.deactivateClient(jclient) ? 0 : 1;
1525 }
1526
1527 // ---------------------------------------------------------------------------------------------------------------------
1528
1529 CARLA_PLUGIN_EXPORT
1530 char* jack_get_client_name_by_uuid(jack_client_t* const client, const char* const uuidstr)
1531 {
1532     carla_debug("%s(%p, %s)", __FUNCTION__, client, uuidstr);
1533
1534     jack_uuid_t uuid = JACK_UUID_EMPTY_INITIALIZER;
1535     CARLA_SAFE_ASSERT_RETURN(jack_uuid_parse(uuidstr, &uuid) == 0, nullptr);
1536
1537     JackClientState* const jclient = (JackClientState*)client;
1538     CARLA_SAFE_ASSERT_RETURN(jclient != nullptr, nullptr);
1539
1540     const char* clientName;
1541
1542     if (jclient->server.uuid == uuid)
1543         return strdup("system");
1544
1545     if (jclient->uuid == uuid)
1546     {
1547         clientName = jclient->name;
1548         CARLA_SAFE_ASSERT_RETURN(clientName != nullptr, nullptr);
1549     }
1550     else
1551     {
1552         CarlaJackAppClient* const jackAppPtr = jclient->server.jackAppPtr;
1553         CARLA_SAFE_ASSERT_RETURN(jackAppPtr != nullptr && jackAppPtr == &gClient, nullptr);
1554
1555         clientName = jackAppPtr->getClientNameFromUUID(uuid);
1556         CARLA_SAFE_ASSERT_RETURN(clientName != nullptr, nullptr);
1557     }
1558
1559     return strdup(clientName);
1560 }
1561
1562 CARLA_PLUGIN_EXPORT
1563 char* jack_get_uuid_for_client_name(jack_client_t* client, const char* name)
1564 {
1565     carla_debug("%s(%p, %s)", __FUNCTION__, client, name);
1566
1567     JackClientState* const jclient = (JackClientState*)client;
1568     CARLA_SAFE_ASSERT_RETURN(jclient != nullptr, nullptr);
1569
1570     if (std::strcmp(name, "system") == 0)
1571     {
1572         char* const uuidstr = static_cast<char*>(std::malloc(JACK_UUID_STRING_SIZE));
1573         CARLA_SAFE_ASSERT_RETURN(uuidstr != nullptr, nullptr);
1574
1575         jack_uuid_unparse(jclient->server.uuid, uuidstr);
1576         return uuidstr;
1577     }
1578     else
1579     {
1580         CarlaJackAppClient* const jackAppPtr = jclient->server.jackAppPtr;
1581         CARLA_SAFE_ASSERT_RETURN(jackAppPtr != nullptr && jackAppPtr == &gClient, nullptr);
1582
1583         const jack_uuid_t uuid = jackAppPtr->getUUIDForClientName(name);
1584         CARLA_SAFE_ASSERT_RETURN(uuid != JACK_UUID_EMPTY_INITIALIZER, nullptr);
1585
1586         char* const uuidstr = static_cast<char*>(std::malloc(JACK_UUID_STRING_SIZE));
1587         CARLA_SAFE_ASSERT_RETURN(uuidstr != nullptr, nullptr);
1588
1589         jack_uuid_unparse(jclient->uuid, uuidstr);
1590         return uuidstr;
1591     }
1592 }
1593
1594 // ---------------------------------------------------------------------------------------------------------------------
1595
1596 CARLA_PLUGIN_EXPORT
1597 pthread_t jack_client_thread_id(jack_client_t* client)
1598 {
1599     carla_debug("%s(%p)", __FUNCTION__, client);
1600
1601     JackClientState* const jclient = (JackClientState*)client;
1602     CARLA_SAFE_ASSERT_RETURN(jclient != nullptr, 0);
1603
1604     CarlaJackAppClient* const jackAppPtr = jclient->server.jackAppPtr;
1605     CARLA_SAFE_ASSERT_RETURN(jackAppPtr != nullptr && jackAppPtr == &gClient, 0);
1606
1607     return jackAppPtr->getRealtimeThreadId();
1608 }
1609
1610 // ---------------------------------------------------------------------------------------------------------------------
1611
1612 #include "jackbridge/JackBridge2.cpp"
1613 #include "CarlaBridgeUtils.cpp"
1614
1615 // ---------------------------------------------------------------------------------------------------------------------
1616 // TODO
1617
1618 CARLA_BACKEND_USE_NAMESPACE
1619
1620 CARLA_PLUGIN_EXPORT
1621 int jack_client_real_time_priority(jack_client_t* client)
1622 {
1623     carla_debug("%s(%p)", __FUNCTION__, client);
1624
1625     // code as used by water
1626     const int minPriority = sched_get_priority_min(SCHED_RR);
1627     const int maxPriority = sched_get_priority_max(SCHED_RR);
1628     return ((maxPriority - minPriority) * 9) / 10 + minPriority;
1629
1630     // unused
1631     (void)client;
1632 }
1633
1634 int jack_client_create_thread(jack_client_t* client, pthread_t* thread, int priority,
1635                                int realtime, void *(*start_routine)(void*), void* arg)
1636 {
1637     carla_stderr2("%s(%p, %p, %i, %i, %p, %p)", __FUNCTION__, client, thread, priority, realtime, start_routine, arg);
1638     return ENOSYS;
1639 }
1640
1641 typedef void (*JackSessionCallback)(jack_session_event_t*, void*);
1642
1643 CARLA_PLUGIN_EXPORT
1644 int jack_set_session_callback(jack_client_t* client, JackSessionCallback callback, void* arg)
1645 {
1646     carla_stderr2("%s(%p, %p, %p)", __FUNCTION__, client, callback, arg);
1647     return 0;
1648 }
1649
1650 // ---------------------------------------------------------------------------------------------------------------------