source/backend/plugin/CarlaPluginJack.cpp

   1 /*
   2  * Carla Plugin JACK
   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 "CarlaPluginInternal.hpp"
  19 #include "CarlaEngine.hpp"
  20
  21 #if defined(CARLA_OS_LINUX) || defined(CARLA_OS_MAC)
  22
  23 #include "CarlaLibJackHints.h"
  24 #include "CarlaBackendUtils.hpp"
  25 #include "CarlaBridgeUtils.hpp"
  26 #include "CarlaEngineUtils.hpp"
  27 #include "CarlaMathUtils.hpp"
  28 #include "CarlaPipeUtils.hpp"
  29 #include "CarlaScopeUtils.hpp"
  30 #include "CarlaShmUtils.hpp"
  31 #include "CarlaThread.hpp"
  32
  33 #ifdef HAVE_LIBLO
  34 # include "CarlaOscUtils.hpp"
  35 #else
  36 # warning No liblo support, NSM (session state) will not be available
  37 #endif
  38
  39 #include "water/files/File.h"
  40 #include "water/misc/Time.h"
  41 #include "water/text/StringArray.h"
  42 #include "water/threads/ChildProcess.h"
  43
  44 #include "jackbridge/JackBridge.hpp"
  45
  46 #include <ctime>
  47 #include <vector>
  48
  49 // -------------------------------------------------------------------------------------------------------------------
  50
  51 using water::ChildProcess;
  52 using water::File;
  53 using water::String;
  54 using water::StringArray;
  55
  56 CARLA_BACKEND_START_NAMESPACE
  57
  58 static size_t safe_rand(const size_t limit)
  59 {
  60     const int r = std::rand();
  61     CARLA_SAFE_ASSERT_RETURN(r >= 0, 0);
  62
  63     return static_cast<uint>(r) % limit;
  64 }
  65
  66 // -------------------------------------------------------------------------------------------------------------------
  67 // Fallback data
  68
  69 static const ExternalMidiNote kExternalMidiNoteFallback = { -1, 0, 0 };
  70
  71 // -------------------------------------------------------------------------------------------------------------------
  72
  73 struct Announcer {
  74     virtual ~Announcer() {}
  75     virtual void nsmAnnounced(bool hasGui) = 0;
  76 };
  77
  78 class CarlaPluginJackThread : public CarlaThread
  79 {
  80 public:
  81     CarlaPluginJackThread(Announcer* const ann, CarlaEngine* const engine, CarlaPlugin* const plugin) noexcept
  82         : CarlaThread("CarlaPluginJackThread"),
  83           kAnnouncer(ann),
  84           kEngine(engine),
  85           kPlugin(plugin),
  86           fShmIds(),
  87           fSetupLabel(),
  88 #ifdef HAVE_LIBLO
  89           fOscClientAddress(nullptr),
  90           fOscServer(nullptr),
  91           fHasOptionalGui(false),
  92           fProject(),
  93 #endif
  94           fProcess() {}
  95
  96     void setData(const char* const shmIds, const char* const setupLabel) noexcept
  97     {
  98         CARLA_SAFE_ASSERT_RETURN(shmIds != nullptr && shmIds[0] != '\0',);
  99         CARLA_SAFE_ASSERT_RETURN(setupLabel != nullptr && setupLabel[0] != '\0',);
 100         CARLA_SAFE_ASSERT(! isThreadRunning());
 101
 102         fShmIds     = shmIds;
 103         fSetupLabel = setupLabel;
 104     }
 105
 106     uintptr_t getProcessID() const noexcept
 107     {
 108         CARLA_SAFE_ASSERT_RETURN(fProcess != nullptr, 0);
 109
 110         return (uintptr_t)fProcess->getPID();
 111     }
 112
 113 #ifdef HAVE_LIBLO
 114     void nsmSave(const char* const setupLabel)
 115     {
 116         if (fOscClientAddress == nullptr)
 117             return;
 118
 119         if (fSetupLabel != setupLabel)
 120             fSetupLabel = setupLabel;
 121
 122         maybeOpenFirstTime(false);
 123
 124         lo_send_from(fOscClientAddress, fOscServer, LO_TT_IMMEDIATE, "/nsm/client/save", "");
 125     }
 126
 127     bool nsmShowGui(const bool yesNo)
 128     {
 129         if (fOscClientAddress == nullptr || ! fHasOptionalGui)
 130             return false;
 131
 132         lo_send_from(fOscClientAddress, fOscServer, LO_TT_IMMEDIATE,
 133                      yesNo ? "/nsm/client/show_optional_gui"
 134                            : "/nsm/client/hide_optional_gui", "");
 135
 136         return true;
 137     }
 138 #endif
 139
 140     char* getEnvVarsToExport()
 141     {
 142         const EngineOptions& options(kEngine->getOptions());
 143         CarlaString binaryDir(options.binaryDir);
 144        #ifdef HAVE_LIBLO
 145         const int sessionManager = fSetupLabel[4U] - '0';
 146        #endif
 147
 148         CarlaString ret;
 149        #ifdef CARLA_OS_MAC
 150         ret += "export DYLD_LIBRARY_PATH=" + binaryDir + "/jack\n";
 151         ret += "export DYLD_INSERT_LIBRARIES=" + binaryDir + "/libcarla_interposer-jack-x11.dylib\n";
 152         ret += "export DYLD_FORCE_FLAT_NAMESPACE=1\n";
 153        #else
 154         ret += "export LD_LIBRARY_PATH=" + binaryDir + "/jack\n";
 155         ret += "export LD_PRELOAD=" + binaryDir + "/libcarla_interposer-jack-x11.so\n";
 156        #endif
 157        #ifdef HAVE_LIBLO
 158         if (sessionManager == LIBJACK_SESSION_MANAGER_NSM)
 159         {
 160             for (int i=50; fOscServer == nullptr && --i>=0;)
 161                 carla_msleep(100);
 162
 163             ret += "export NSM_URL=";
 164             ret += lo_server_get_url(fOscServer);
 165             ret += "\n";
 166         }
 167        #endif
 168
 169         if (kPlugin->getHints() & PLUGIN_HAS_CUSTOM_UI)
 170             ret += "export CARLA_FRONTEND_WIN_ID=" + CarlaString(options.frontendWinId) + "\n";
 171
 172         ret += "export CARLA_LIBJACK_SETUP=" + fSetupLabel + "\n";
 173         ret += "export CARLA_SHM_IDS=" + fShmIds + "\n";
 174
 175         return ret.releaseBufferPointer();
 176     }
 177
 178 protected:
 179 #ifdef HAVE_LIBLO
 180     static void _osc_error_handler(int num, const char* msg, const char* path)
 181     {
 182         carla_stderr2("CarlaPluginJackThread::_osc_error_handler(%i, \"%s\", \"%s\")", num, msg, path);
 183     }
 184
 185     static int _broadcast_handler(const char* path, const char* types, lo_arg** argv, int argc, lo_message msg, void* data)
 186     {
 187         CARLA_SAFE_ASSERT_RETURN(data != nullptr, 0);
 188         carla_stdout("CarlaPluginJackThread::_broadcast_handler(%s, %s, %p, %i)", path, types, argv, argc);
 189
 190         return ((CarlaPluginJackThread*)data)->handleBroadcast(path, types, argv, msg);
 191     }
 192
 193     void maybeOpenFirstTime(const bool announced)
 194     {
 195         if (fSetupLabel.length() <= 6)
 196             return;
 197
 198         if ((announced || fProject.path.isEmpty()) && fProject.init(kPlugin->getName(),
 199                                                                     kEngine->getCurrentProjectFolder(),
 200                                                                     &fSetupLabel[6U]))
 201         {
 202             carla_stdout("Sending open signal %s %s %s",
 203                          fProject.path.buffer(), fProject.display.buffer(), fProject.clientName.buffer());
 204
 205             lo_send_from(fOscClientAddress, fOscServer, LO_TT_IMMEDIATE, "/nsm/client/open", "sss",
 206                          fProject.path.buffer(), fProject.display.buffer(), fProject.clientName.buffer());
 207         }
 208     }
 209
 210     int handleBroadcast(const char* path, const char* types, lo_arg** argv, lo_message msg)
 211     {
 212         if (std::strcmp(path, "/nsm/server/announce") == 0)
 213         {
 214             CARLA_SAFE_ASSERT_RETURN(std::strcmp(types, "sssiii") == 0, 0);
 215
 216             const lo_address msgAddress(lo_message_get_source(msg));
 217             CARLA_SAFE_ASSERT_RETURN(msgAddress != nullptr, 0);
 218
 219             char* const msgURL(lo_address_get_url(msgAddress));
 220             CARLA_SAFE_ASSERT_RETURN(msgURL != nullptr, 0);
 221
 222             if (fOscClientAddress != nullptr)
 223                 lo_address_free(fOscClientAddress);
 224
 225             fOscClientAddress = lo_address_new_from_url(msgURL);
 226             CARLA_SAFE_ASSERT_RETURN(fOscClientAddress != nullptr, 0);
 227
 228             fProject.appName = &argv[0]->s;
 229             fHasOptionalGui  = std::strstr(&argv[1]->s, ":optional-gui:") != nullptr;
 230
 231             kAnnouncer->nsmAnnounced(fHasOptionalGui);
 232
 233             static const char* const featuresG = ":server-control:optional-gui:";
 234             static const char* const featuresN = ":server-control:";
 235
 236             static const char* const method  = "/nsm/server/announce";
 237             static const char* const message = "Howdy, what took you so long?";
 238             static const char* const smName  = "Carla";
 239
 240             const char* const features = ((fSetupLabel[5U] - '0') & LIBJACK_FLAG_CONTROL_WINDOW)
 241                                        ? featuresG : featuresN;
 242
 243             lo_send_from(fOscClientAddress, fOscServer, LO_TT_IMMEDIATE, "/reply", "ssss",
 244                          method, message, smName, features);
 245
 246             maybeOpenFirstTime(true);
 247             return 0;
 248         }
 249
 250         CARLA_SAFE_ASSERT_RETURN(fOscClientAddress != nullptr, 0);
 251
 252         if (std::strcmp(path, "/reply") == 0)
 253         {
 254             CARLA_SAFE_ASSERT_RETURN(std::strcmp(types, "ss") == 0, 0);
 255
 256             const char* const method  = &argv[0]->s;
 257             const char* const message = &argv[1]->s;
 258
 259             carla_stdout("Got reply of '%s' as '%s'", method, message);
 260
 261             if (std::strcmp(method, "/nsm/client/open") == 0)
 262             {
 263                 carla_stdout("Sending 'Session is loaded' to %s", fProject.appName.buffer());
 264                 lo_send_from(fOscClientAddress, fOscServer, LO_TT_IMMEDIATE, "/nsm/client/session_is_loaded", "");
 265             }
 266         }
 267
 268         else if (std::strcmp(path, "/nsm/client/gui_is_shown") == 0)
 269         {
 270             CARLA_SAFE_ASSERT_RETURN(std::strcmp(types, "") == 0, 0);
 271
 272             kEngine->callback(true, true,
 273                               ENGINE_CALLBACK_UI_STATE_CHANGED,
 274                               kPlugin->getId(),
 275                               1,
 276                               0, 0, 0.0f, nullptr);
 277         }
 278
 279         else if (std::strcmp(path, "/nsm/client/gui_is_hidden") == 0)
 280         {
 281             CARLA_SAFE_ASSERT_RETURN(std::strcmp(types, "") == 0, 0);
 282
 283             kEngine->callback(true, true,
 284                               ENGINE_CALLBACK_UI_STATE_CHANGED,
 285                               kPlugin->getId(),
 286                               0,
 287                               0, 0, 0.0f, nullptr);
 288         }
 289
 290         // special messages
 291         else if (std::strcmp(path, "/nsm/gui/client/save") == 0)
 292         {
 293             CARLA_SAFE_ASSERT_RETURN(std::strcmp(types, "s") == 0, 0);
 294
 295             lo_send_from(fOscClientAddress, fOscServer, LO_TT_IMMEDIATE, "/nsm/client/save", "");
 296         }
 297
 298         else if (std::strcmp(path, "/nsm/server/stop") == 0)
 299         {
 300             CARLA_SAFE_ASSERT_RETURN(std::strcmp(types, "s") == 0, 0);
 301
 302             lo_send_from(fOscClientAddress, fOscServer, LO_TT_IMMEDIATE, "/nsm/client/hide_optional_gui", "");
 303
 304             kEngine->callback(true, true,
 305                               ENGINE_CALLBACK_UI_STATE_CHANGED,
 306                               kPlugin->getId(),
 307                               0,
 308                               0, 0, 0.0f, nullptr);
 309         }
 310
 311         return 0;
 312     }
 313 #endif
 314
 315     void run()
 316     {
 317 #ifdef HAVE_LIBLO
 318         if (fOscClientAddress != nullptr)
 319         {
 320             lo_address_free(fOscClientAddress);
 321             fOscClientAddress = nullptr;
 322         }
 323
 324         const int sessionManager = fSetupLabel[4U] - '0';
 325
 326         if (sessionManager == LIBJACK_SESSION_MANAGER_NSM)
 327         {
 328             // NSM support
 329             fOscServer = lo_server_new_with_proto(nullptr, LO_UDP, _osc_error_handler);
 330             CARLA_SAFE_ASSERT_RETURN(fOscServer != nullptr,);
 331
 332             lo_server_add_method(fOscServer, nullptr, nullptr, _broadcast_handler, this);
 333         }
 334 #endif
 335
 336         const bool externalProcess = ((fSetupLabel[5U] - '0') & LIBJACK_FLAG_EXTERNAL_START)
 337                                    && ! kEngine->isLoadingProject();
 338
 339         if (! externalProcess)
 340         {
 341             if (fProcess == nullptr)
 342             {
 343                 fProcess = new ChildProcess();
 344             }
 345             else if (fProcess->isRunning())
 346             {
 347                 carla_stderr("CarlaPluginJackThread::run() - already running");
 348             }
 349
 350             String name(kPlugin->getName());
 351             String filename(kPlugin->getFilename());
 352
 353             if (name.isEmpty())
 354                 name = "(none)";
 355
 356             CARLA_SAFE_ASSERT_RETURN(filename.isNotEmpty(),);
 357
 358             StringArray arguments;
 359
 360             // binary
 361             arguments.addTokens(filename, true);
 362
 363             const EngineOptions& options(kEngine->getOptions());
 364
 365             char winIdStr[STR_MAX+1];
 366             std::snprintf(winIdStr, STR_MAX, P_UINTPTR, options.frontendWinId);
 367             winIdStr[STR_MAX] = '\0';
 368
 369             const CarlaString libjackdir(CarlaString(options.binaryDir) + "/jack");
 370            #ifdef CARLA_OS_MAC
 371             const CarlaString ldpreload(CarlaString(options.binaryDir) + "/libcarla_interposer-jack-x11.dylib");
 372            #else
 373             const CarlaString ldpreload(CarlaString(options.binaryDir) + "/libcarla_interposer-jack-x11.so");
 374            #endif
 375
 376             const ScopedEngineEnvironmentLocker _seel(kEngine);
 377
 378            #ifdef CARLA_OS_MAC
 379             const CarlaScopedEnvVar sev2("DYLD_LIBRARY_PATH", libjackdir.buffer());
 380             const CarlaScopedEnvVar sev1("DYLD_INSERT_LIBRARIES", ldpreload.isNotEmpty() ? ldpreload.buffer() : nullptr);
 381             const CarlaScopedEnvVar sev0("DYLD_FORCE_FLAT_NAMESPACE", "1");
 382            #else
 383             const CarlaScopedEnvVar sev2("LD_LIBRARY_PATH", libjackdir.buffer());
 384             const CarlaScopedEnvVar sev1("LD_PRELOAD", ldpreload.isNotEmpty() ? ldpreload.buffer() : nullptr);
 385            #endif
 386            #ifdef HAVE_LIBLO
 387             const CarlaScopedEnvVar sev3("NSM_URL", lo_server_get_url(fOscServer));
 388            #endif
 389
 390             if (kPlugin->getHints() & PLUGIN_HAS_CUSTOM_UI)
 391                 carla_setenv("CARLA_FRONTEND_WIN_ID", winIdStr);
 392             else
 393                 carla_unsetenv("CARLA_FRONTEND_WIN_ID");
 394
 395             carla_setenv("CARLA_LIBJACK_SETUP", fSetupLabel.buffer());
 396             carla_setenv("CARLA_SHM_IDS", fShmIds.buffer());
 397
 398             if (! fProcess->start(arguments))
 399             {
 400                 carla_stdout("failed!");
 401                 fProcess = nullptr;
 402                 return;
 403             }
 404         }
 405
 406         for (; (externalProcess || fProcess->isRunning()) && ! shouldThreadExit();)
 407         {
 408 #ifdef HAVE_LIBLO
 409             if (sessionManager == LIBJACK_SESSION_MANAGER_NSM)
 410             {
 411                 lo_server_recv_noblock(fOscServer, 50);
 412             }
 413             else
 414 #endif
 415             {
 416                 carla_msleep(50);
 417             }
 418         }
 419
 420 #ifdef HAVE_LIBLO
 421         if (sessionManager == LIBJACK_SESSION_MANAGER_NSM)
 422         {
 423             lo_server_free(fOscServer);
 424             fOscServer = nullptr;
 425
 426             if (fOscClientAddress != nullptr)
 427             {
 428                 lo_address_free(fOscClientAddress);
 429                 fOscClientAddress = nullptr;
 430             }
 431         }
 432 #endif
 433
 434         if (! externalProcess)
 435         {
 436             // we only get here if bridge crashed or thread asked to exit
 437             if (fProcess->isRunning() && shouldThreadExit())
 438             {
 439                 fProcess->waitForProcessToFinish(2000);
 440
 441                 if (fProcess->isRunning())
 442                 {
 443                     carla_stdout("CarlaPluginJackThread::run() - application refused to close, force kill now");
 444                     fProcess->kill();
 445                 }
 446             }
 447             else
 448             {
 449                 // forced quit, may have crashed
 450                 if (fProcess->getExitCodeAndClearPID() != 0)
 451                 {
 452                     carla_stderr("CarlaPluginJackThread::run() - application crashed");
 453
 454                     CarlaString errorString("Plugin '" + CarlaString(kPlugin->getName()) + "' has crashed!\n"
 455                                             "Saving now will lose its current settings.\n"
 456                                             "Please remove this plugin, and not rely on it from this point.");
 457                     kEngine->callback(true, true,
 458                                     ENGINE_CALLBACK_ERROR,
 459                                     kPlugin->getId(),
 460                                     0, 0, 0, 0.0f,
 461                                     errorString);
 462                 }
 463             }
 464         }
 465
 466         fProcess = nullptr;
 467     }
 468
 469 private:
 470     Announcer* const kAnnouncer;
 471     CarlaEngine* const kEngine;
 472     CarlaPlugin* const kPlugin;
 473
 474     CarlaString fShmIds;
 475     CarlaString fSetupLabel;
 476
 477 #ifdef HAVE_LIBLO
 478     lo_address fOscClientAddress;
 479     lo_server  fOscServer;
 480     bool fHasOptionalGui;
 481
 482     struct ProjectData {
 483         CarlaString appName;
 484         CarlaString path;
 485         CarlaString display;
 486         CarlaString clientName;
 487
 488         ProjectData()
 489             : appName(),
 490               path(),
 491               display(),
 492               clientName() {}
 493
 494         bool init(const char* const pluginName,
 495                   const char* const engineProjectFolder,
 496                   const char* const uniqueCodeID)
 497         {
 498             CARLA_SAFE_ASSERT_RETURN(engineProjectFolder != nullptr && engineProjectFolder[0] != '\0', false);
 499             CARLA_SAFE_ASSERT_RETURN(uniqueCodeID != nullptr && uniqueCodeID[0] != '\0', false);
 500             CARLA_SAFE_ASSERT_RETURN(appName.isNotEmpty(), false);
 501
 502             String child(pluginName);
 503             child += ".";
 504             child += uniqueCodeID;
 505
 506             const File file(File(engineProjectFolder).getChildFile(child));
 507
 508             clientName = appName + "." + uniqueCodeID;
 509             path = file.getFullPathName().toRawUTF8();
 510             display = file.getFileNameWithoutExtension().toRawUTF8();
 511
 512             return true;
 513         }
 514
 515         CARLA_DECLARE_NON_COPYABLE(ProjectData)
 516     } fProject;
 517 #endif
 518
 519     CarlaScopedPointer<ChildProcess> fProcess;
 520
 521     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaPluginJackThread)
 522 };
 523
 524 // -------------------------------------------------------------------------------------------------------------------
 525
 526 class CarlaPluginJack : public CarlaPlugin,
 527                         public Announcer
 528 {
 529 public:
 530     CarlaPluginJack(CarlaEngine* const engine, const uint id)
 531         : CarlaPlugin(engine, id),
 532           fInitiated(false),
 533           fInitError(false),
 534           fTimedOut(false),
 535           fTimedError(false),
 536           fProcCanceled(false),
 537           fBufferSize(engine->getBufferSize()),
 538           fProcWaitTime(0),
 539           fSetupHints(0x0),
 540           fBridgeThread(this, engine, this),
 541           fShmAudioPool(),
 542           fShmRtClientControl(),
 543           fShmNonRtClientControl(),
 544           fShmNonRtServerControl(),
 545           fInfo()
 546     {
 547         carla_debug("CarlaPluginJack::CarlaPluginJack(%p, %i)", engine, id);
 548
 549         pData->hints |= PLUGIN_IS_BRIDGE;
 550     }
 551
 552     ~CarlaPluginJack() override
 553     {
 554         carla_debug("CarlaPluginJack::~CarlaPluginJack()");
 555
 556 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
 557         // close UI
 558         if (pData->hints & PLUGIN_HAS_CUSTOM_UI)
 559             pData->transientTryCounter = 0;
 560 #endif
 561
 562         pData->singleMutex.lock();
 563         pData->masterMutex.lock();
 564
 565         if (pData->client != nullptr && pData->client->isActive())
 566             pData->client->deactivate(true);
 567
 568         if (pData->active)
 569         {
 570             deactivate();
 571             pData->active = false;
 572         }
 573
 574         if (fBridgeThread.isThreadRunning())
 575         {
 576             fShmRtClientControl.writeOpcode(kPluginBridgeRtClientQuit);
 577             fShmRtClientControl.commitWrite();
 578
 579             fShmNonRtClientControl.writeOpcode(kPluginBridgeNonRtClientQuit);
 580             fShmNonRtClientControl.commitWrite();
 581
 582             if (! fTimedOut)
 583                 waitForClient("stopping", 3000);
 584         }
 585
 586         fBridgeThread.stopThread(3000);
 587
 588         fShmNonRtServerControl.clear();
 589         fShmNonRtClientControl.clear();
 590         fShmRtClientControl.clear();
 591         fShmAudioPool.clear();
 592
 593         clearBuffers();
 594
 595         fInfo.chunk.clear();
 596     }
 597
 598     // -------------------------------------------------------------------
 599
 600     void nsmAnnounced(bool hasGui) override
 601     {
 602         if (hasGui || (pData->hints & PLUGIN_HAS_CUSTOM_UI) == 0x0)
 603             return;
 604
 605         {
 606             const CarlaMutexLocker _cml(fShmNonRtClientControl.mutex);
 607
 608             fShmNonRtClientControl.writeOpcode(kPluginBridgeNonRtClientShowUI);
 609             fShmNonRtClientControl.commitWrite();
 610         }
 611
 612         pData->engine->callback(true, true,
 613                                 ENGINE_CALLBACK_UI_STATE_CHANGED,
 614                                 pData->id,
 615                                 1,
 616                                 0, 0, 0.0f, nullptr);
 617     }
 618
 619     // -------------------------------------------------------------------
 620     // Information (base)
 621
 622     PluginType getType() const noexcept override
 623     {
 624         return PLUGIN_JACK;
 625     }
 626
 627     PluginCategory getCategory() const noexcept override
 628     {
 629         return PLUGIN_CATEGORY_NONE;
 630     }
 631
 632     // -------------------------------------------------------------------
 633     // Information (count)
 634
 635     uint32_t getMidiInCount() const noexcept override
 636     {
 637         return fInfo.mIns;
 638     }
 639
 640     uint32_t getMidiOutCount() const noexcept override
 641     {
 642         return fInfo.mOuts;
 643     }
 644
 645     // -------------------------------------------------------------------
 646     // Information (current data)
 647
 648     // -------------------------------------------------------------------
 649     // Information (per-plugin data)
 650
 651     uint getOptionsAvailable() const noexcept override
 652     {
 653         uint options = 0x0;
 654
 655         if (fInfo.mIns > 0)
 656         {
 657             options |= PLUGIN_OPTION_SEND_CONTROL_CHANGES;
 658             options |= PLUGIN_OPTION_SEND_CHANNEL_PRESSURE;
 659             options |= PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH;
 660             options |= PLUGIN_OPTION_SEND_PITCHBEND;
 661             options |= PLUGIN_OPTION_SEND_ALL_SOUND_OFF;
 662             options |= PLUGIN_OPTION_SEND_PROGRAM_CHANGES;
 663             options |= PLUGIN_OPTION_SKIP_SENDING_NOTES;
 664         }
 665
 666         return options;
 667     }
 668
 669     bool getLabel(char* const strBuf) const noexcept override
 670     {
 671         std::strncpy(strBuf, fInfo.setupLabel, STR_MAX);
 672         return true;
 673     }
 674
 675     bool getMaker(char* const) const noexcept override
 676     {
 677         return false;
 678     }
 679
 680     bool getCopyright(char* const) const noexcept override
 681     {
 682         return false;
 683     }
 684
 685     bool getRealName(char* const strBuf) const noexcept override
 686     {
 687         // FIXME
 688         std::strncpy(strBuf, "Carla's libjack", STR_MAX);
 689         return true;
 690     }
 691
 692     // -------------------------------------------------------------------
 693     // Set data (state)
 694
 695     void prepareForSave(bool) noexcept override
 696     {
 697 #ifdef HAVE_LIBLO
 698         if (fInfo.setupLabel.length() == 6)
 699             setupUniqueProjectID();
 700 #endif
 701
 702         {
 703             const CarlaMutexLocker _cml(fShmNonRtClientControl.mutex);
 704
 705             fShmNonRtClientControl.writeOpcode(kPluginBridgeNonRtClientPrepareForSave);
 706             fShmNonRtClientControl.commitWrite();
 707         }
 708
 709 #ifdef HAVE_LIBLO
 710         fBridgeThread.nsmSave(fInfo.setupLabel);
 711 #endif
 712     }
 713
 714     // -------------------------------------------------------------------
 715     // Set data (internal stuff)
 716
 717     void setOption(const uint option, const bool yesNo, const bool sendCallback) override
 718     {
 719         {
 720             const CarlaMutexLocker _cml(fShmNonRtClientControl.mutex);
 721
 722             fShmNonRtClientControl.writeOpcode(kPluginBridgeNonRtClientSetOption);
 723             fShmNonRtClientControl.writeUInt(option);
 724             fShmNonRtClientControl.writeBool(yesNo);
 725             fShmNonRtClientControl.commitWrite();
 726         }
 727
 728         CarlaPlugin::setOption(option, yesNo, sendCallback);
 729     }
 730
 731     void setCtrlChannel(const int8_t channel, const bool sendOsc, const bool sendCallback) noexcept override
 732     {
 733         CARLA_SAFE_ASSERT_RETURN(sendOsc || sendCallback,); // never call this from RT
 734
 735         {
 736             const CarlaMutexLocker _cml(fShmNonRtClientControl.mutex);
 737
 738             fShmNonRtClientControl.writeOpcode(kPluginBridgeNonRtClientSetCtrlChannel);
 739             fShmNonRtClientControl.writeShort(channel);
 740             fShmNonRtClientControl.commitWrite();
 741         }
 742
 743         CarlaPlugin::setCtrlChannel(channel, sendOsc, sendCallback);
 744     }
 745
 746     // -------------------------------------------------------------------
 747     // Set data (plugin-specific stuff)
 748
 749     void setCustomData(const char* const type, const char* const key, const char* const value, const bool sendGui) override
 750     {
 751         CARLA_SAFE_ASSERT_RETURN(type != nullptr && type[0] != '\0',);
 752         CARLA_SAFE_ASSERT_RETURN(key != nullptr && key[0] != '\0',);
 753         CARLA_SAFE_ASSERT_RETURN(value != nullptr,);
 754
 755         if (std::strcmp(type, CUSTOM_DATA_TYPE_PROPERTY) == 0)
 756             return CarlaPlugin::setCustomData(type, key, value, sendGui);
 757
 758         if (std::strcmp(type, CUSTOM_DATA_TYPE_STRING) == 0 && std::strcmp(key, "__CarlaPingOnOff__") == 0)
 759         {
 760 #if 0
 761             const CarlaMutexLocker _cml(fShmNonRtClientControl.mutex);
 762
 763             fShmNonRtClientControl.writeOpcode(kPluginBridgeNonRtClientPingOnOff);
 764             fShmNonRtClientControl.writeBool(std::strcmp(value, "true") == 0);
 765             fShmNonRtClientControl.commitWrite();
 766 #endif
 767             return;
 768         }
 769
 770         CarlaPlugin::setCustomData(type, key, value, sendGui);
 771     }
 772
 773     // -------------------------------------------------------------------
 774     // Set ui stuff
 775
 776     void showCustomUI(const bool yesNo) override
 777     {
 778         if (yesNo && ! fBridgeThread.isThreadRunning()) {
 779             CARLA_SAFE_ASSERT_RETURN(restartBridgeThread(),);
 780         }
 781
 782 #ifdef HAVE_LIBLO
 783         if (! fBridgeThread.nsmShowGui(yesNo))
 784 #endif
 785         {
 786             const CarlaMutexLocker _cml(fShmNonRtClientControl.mutex);
 787
 788             fShmNonRtClientControl.writeOpcode(yesNo ? kPluginBridgeNonRtClientShowUI : kPluginBridgeNonRtClientHideUI);
 789             fShmNonRtClientControl.commitWrite();
 790         }
 791     }
 792
 793     void idle() override
 794     {
 795         if (fBridgeThread.isThreadRunning())
 796         {
 797             if (fInitiated && fTimedOut && pData->active)
 798                 setActive(false, true, true);
 799
 800             {
 801                 const CarlaMutexLocker _cml(fShmNonRtClientControl.mutex);
 802
 803                 fShmNonRtClientControl.writeOpcode(kPluginBridgeNonRtClientPing);
 804                 fShmNonRtClientControl.commitWrite();
 805             }
 806
 807             try {
 808                 handleNonRtData();
 809             } CARLA_SAFE_EXCEPTION("handleNonRtData");
 810         }
 811         else if (fInitiated)
 812         {
 813             fTimedOut   = true;
 814             fTimedError = true;
 815             fInitiated  = false;
 816             handleProcessStopped();
 817         }
 818         else if (fProcCanceled)
 819         {
 820             handleProcessStopped();
 821             fProcCanceled = false;
 822         }
 823
 824         CarlaPlugin::idle();
 825     }
 826
 827     // -------------------------------------------------------------------
 828     // Plugin state
 829
 830     void reload() override
 831     {
 832         CARLA_SAFE_ASSERT_RETURN(pData->engine != nullptr,);
 833         carla_debug("CarlaPluginJack::reload() - start");
 834
 835         const EngineProcessMode processMode(pData->engine->getProccessMode());
 836
 837         // Safely disable plugin for reload
 838         const ScopedDisabler sd(this);
 839
 840         // cleanup of previous data
 841         pData->audioIn.clear();
 842         pData->audioOut.clear();
 843         pData->event.clear();
 844
 845         bool needsCtrlIn, needsCtrlOut;
 846         needsCtrlIn = needsCtrlOut = false;
 847
 848         if (fInfo.aIns > 0)
 849         {
 850             pData->audioIn.createNew(fInfo.aIns);
 851         }
 852
 853         if (fInfo.aOuts > 0)
 854         {
 855             pData->audioOut.createNew(fInfo.aOuts);
 856             needsCtrlIn = true;
 857         }
 858
 859         if (fInfo.mIns > 0)
 860             needsCtrlIn = true;
 861
 862         if (fInfo.mOuts > 0)
 863             needsCtrlOut = true;
 864
 865         const uint portNameSize(pData->engine->getMaxPortNameSize());
 866         CarlaString portName;
 867
 868         // Audio Ins
 869         for (uint8_t j=0; j < fInfo.aIns; ++j)
 870         {
 871             portName.clear();
 872
 873             if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)
 874             {
 875                 portName  = pData->name;
 876                 portName += ":";
 877             }
 878
 879             if (fInfo.aIns > 1)
 880             {
 881                 portName += "audio_in_";
 882                 portName += CarlaString(j+1);
 883             }
 884             else
 885             {
 886                 portName += "audio_in";
 887             }
 888
 889             portName.truncate(portNameSize);
 890
 891             pData->audioIn.ports[j].port   = (CarlaEngineAudioPort*)pData->client->addPort(kEnginePortTypeAudio, portName, true, j);
 892             pData->audioIn.ports[j].rindex = j;
 893         }
 894
 895         // Audio Outs
 896         for (uint8_t j=0; j < fInfo.aOuts; ++j)
 897         {
 898             portName.clear();
 899
 900             if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)
 901             {
 902                 portName  = pData->name;
 903                 portName += ":";
 904             }
 905
 906             if (fInfo.aOuts > 1)
 907             {
 908                 portName += "audio_out_";
 909                 portName += CarlaString(j+1);
 910             }
 911             else
 912             {
 913                 portName += "audio_out";
 914             }
 915
 916             portName.truncate(portNameSize);
 917
 918             pData->audioOut.ports[j].port   = (CarlaEngineAudioPort*)pData->client->addPort(kEnginePortTypeAudio, portName, false, j);
 919             pData->audioOut.ports[j].rindex = j;
 920         }
 921
 922         if (needsCtrlIn)
 923         {
 924             portName.clear();
 925
 926             if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)
 927             {
 928                 portName  = pData->name;
 929                 portName += ":";
 930             }
 931
 932             portName += "event-in";
 933             portName.truncate(portNameSize);
 934
 935             pData->event.portIn = (CarlaEngineEventPort*)pData->client->addPort(kEnginePortTypeEvent, portName, true, 0);
 936         }
 937
 938         if (needsCtrlOut)
 939         {
 940             portName.clear();
 941
 942             if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)
 943             {
 944                 portName  = pData->name;
 945                 portName += ":";
 946             }
 947
 948             portName += "event-out";
 949             portName.truncate(portNameSize);
 950
 951             pData->event.portOut = (CarlaEngineEventPort*)pData->client->addPort(kEnginePortTypeEvent, portName, false, 0);
 952         }
 953
 954         // extra plugin hints
 955         pData->extraHints = 0x0;
 956
 957         if (fInfo.mIns > 0)
 958             pData->extraHints |= PLUGIN_EXTRA_HINT_HAS_MIDI_IN;
 959
 960         if (fInfo.mOuts > 0)
 961             pData->extraHints |= PLUGIN_EXTRA_HINT_HAS_MIDI_OUT;
 962
 963         bufferSizeChanged(pData->engine->getBufferSize());
 964         reloadPrograms(true);
 965
 966         carla_debug("CarlaPluginJack::reload() - end");
 967     }
 968
 969     // -------------------------------------------------------------------
 970     // Plugin processing
 971
 972     void activate() noexcept override
 973     {
 974         if (! fBridgeThread.isThreadRunning())
 975         {
 976             CARLA_SAFE_ASSERT_RETURN(restartBridgeThread(),);
 977         }
 978
 979         CARLA_SAFE_ASSERT_RETURN(! fTimedError,);
 980
 981         {
 982             const CarlaMutexLocker _cml(fShmNonRtClientControl.mutex);
 983
 984             fShmNonRtClientControl.writeOpcode(kPluginBridgeNonRtClientActivate);
 985             fShmNonRtClientControl.commitWrite();
 986         }
 987
 988         fTimedOut = false;
 989
 990         try {
 991             waitForClient("activate", 2000);
 992         } CARLA_SAFE_EXCEPTION("activate - waitForClient");
 993     }
 994
 995     void deactivate() noexcept override
 996     {
 997         if (! fBridgeThread.isThreadRunning())
 998             return;
 999
1000         CARLA_SAFE_ASSERT_RETURN(! fTimedError,);
1001
1002         {
1003             const CarlaMutexLocker _cml(fShmNonRtClientControl.mutex);
1004
1005             fShmNonRtClientControl.writeOpcode(kPluginBridgeNonRtClientDeactivate);
1006             fShmNonRtClientControl.commitWrite();
1007         }
1008
1009         fTimedOut = false;
1010
1011         try {
1012             waitForClient("deactivate", 2000);
1013         } CARLA_SAFE_EXCEPTION("deactivate - waitForClient");
1014     }
1015
1016     void process(const float* const* const audioIn, float** const audioOut,
1017                  const float* const*, float**, const uint32_t frames) override
1018     {
1019         // --------------------------------------------------------------------------------------------------------
1020         // Check if active
1021
1022         if (fProcCanceled || fTimedOut || fTimedError || ! pData->active)
1023         {
1024             // disable any output sound
1025             for (uint32_t i=0; i < pData->audioOut.count; ++i)
1026                 carla_zeroFloats(audioOut[i], frames);
1027             return;
1028         }
1029
1030         // --------------------------------------------------------------------------------------------------------
1031         // Check if needs reset
1032
1033         if (pData->needsReset)
1034         {
1035             // TODO
1036
1037             pData->needsReset = false;
1038         }
1039
1040         // --------------------------------------------------------------------------------------------------------
1041         // Event Input
1042
1043         if (pData->event.portIn != nullptr)
1044         {
1045             // ----------------------------------------------------------------------------------------------------
1046             // MIDI Input (External)
1047
1048             if (pData->extNotes.mutex.tryLock())
1049             {
1050                 for (RtLinkedList<ExternalMidiNote>::Itenerator it = pData->extNotes.data.begin2(); it.valid(); it.next())
1051                 {
1052                     const ExternalMidiNote& note(it.getValue(kExternalMidiNoteFallback));
1053                     CARLA_SAFE_ASSERT_CONTINUE(note.channel >= 0 && note.channel < MAX_MIDI_CHANNELS);
1054
1055                     uint8_t data1, data2, data3;
1056                     data1 = uint8_t((note.velo > 0 ? MIDI_STATUS_NOTE_ON : MIDI_STATUS_NOTE_OFF) | (note.channel & MIDI_CHANNEL_BIT));
1057                     data2 = note.note;
1058                     data3 = note.velo;
1059
1060                     fShmRtClientControl.writeOpcode(kPluginBridgeRtClientMidiEvent);
1061                     fShmRtClientControl.writeUInt(0); // time
1062                     fShmRtClientControl.writeByte(0); // port
1063                     fShmRtClientControl.writeByte(3); // size
1064                     fShmRtClientControl.writeByte(data1);
1065                     fShmRtClientControl.writeByte(data2);
1066                     fShmRtClientControl.writeByte(data3);
1067                     fShmRtClientControl.commitWrite();
1068                 }
1069
1070                 pData->extNotes.data.clear();
1071                 pData->extNotes.mutex.unlock();
1072
1073             } // End of MIDI Input (External)
1074
1075             // ----------------------------------------------------------------------------------------------------
1076             // Event Input (System)
1077
1078 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
1079             bool allNotesOffSent = false;
1080 #endif
1081             for (uint32_t i=0, numEvents=pData->event.portIn->getEventCount(); i < numEvents; ++i)
1082             {
1083                 const EngineEvent& event(pData->event.portIn->getEvent(i));
1084
1085                 // Control change
1086                 switch (event.type)
1087                 {
1088                 case kEngineEventTypeNull:
1089                     break;
1090
1091                 case kEngineEventTypeControl: {
1092                     const EngineControlEvent& ctrlEvent = event.ctrl;
1093
1094                     switch (ctrlEvent.type)
1095                     {
1096                     case kEngineControlEventTypeNull:
1097                         break;
1098
1099                     case kEngineControlEventTypeParameter:
1100 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
1101                         // Control backend stuff
1102                         if (event.channel == pData->ctrlChannel)
1103                         {
1104                             float value;
1105
1106                             if (MIDI_IS_CONTROL_BREATH_CONTROLLER(ctrlEvent.param) && (pData->hints & PLUGIN_CAN_DRYWET) != 0)
1107                             {
1108                                 value = ctrlEvent.normalizedValue;
1109                                 setDryWetRT(value, true);
1110                             }
1111
1112                             if (MIDI_IS_CONTROL_CHANNEL_VOLUME(ctrlEvent.param) && (pData->hints & PLUGIN_CAN_VOLUME) != 0)
1113                             {
1114                                 value = ctrlEvent.normalizedValue*127.0f/100.0f;
1115                                 setVolumeRT(value, true);
1116                             }
1117
1118                             if (MIDI_IS_CONTROL_BALANCE(ctrlEvent.param) && (pData->hints & PLUGIN_CAN_BALANCE) != 0)
1119                             {
1120                                 float left, right;
1121                                 value = ctrlEvent.normalizedValue/0.5f - 1.0f;
1122
1123                                 if (value < 0.0f)
1124                                 {
1125                                     left  = -1.0f;
1126                                     right = (value*2.0f)+1.0f;
1127                                 }
1128                                 else if (value > 0.0f)
1129                                 {
1130                                     left  = (value*2.0f)-1.0f;
1131                                     right = 1.0f;
1132                                 }
1133                                 else
1134                                 {
1135                                     left  = -1.0f;
1136                                     right = 1.0f;
1137                                 }
1138
1139                                 setBalanceLeftRT(left, true);
1140                                 setBalanceRightRT(right, true);
1141                             }
1142                         }
1143 #endif
1144                         if ((pData->options & PLUGIN_OPTION_SEND_CONTROL_CHANGES) != 0 && ctrlEvent.param < MAX_MIDI_VALUE)
1145                         {
1146                             fShmRtClientControl.writeOpcode(kPluginBridgeRtClientMidiEvent);
1147                             fShmRtClientControl.writeUInt(event.time);
1148                             fShmRtClientControl.writeByte(0); // port
1149                             fShmRtClientControl.writeByte(3); // size
1150                             fShmRtClientControl.writeByte(uint8_t(MIDI_STATUS_CONTROL_CHANGE | (event.channel & MIDI_CHANNEL_BIT)));
1151                             fShmRtClientControl.writeByte(uint8_t(ctrlEvent.param));
1152                             fShmRtClientControl.writeByte(uint8_t(ctrlEvent.normalizedValue*127.0f + 0.5f));
1153                         }
1154                         break;
1155
1156                     case kEngineControlEventTypeMidiBank:
1157                         if (pData->options & PLUGIN_OPTION_MAP_PROGRAM_CHANGES)
1158                         {
1159                             fShmRtClientControl.writeOpcode(kPluginBridgeRtClientControlEventMidiBank);
1160                             fShmRtClientControl.writeUInt(event.time);
1161                             fShmRtClientControl.writeByte(event.channel);
1162                             fShmRtClientControl.writeUShort(event.ctrl.param);
1163                             fShmRtClientControl.commitWrite();
1164                         }
1165                         break;
1166
1167                     case kEngineControlEventTypeMidiProgram:
1168                         if (pData->options & PLUGIN_OPTION_MAP_PROGRAM_CHANGES)
1169                         {
1170                             fShmRtClientControl.writeOpcode(kPluginBridgeRtClientControlEventMidiProgram);
1171                             fShmRtClientControl.writeUInt(event.time);
1172                             fShmRtClientControl.writeByte(event.channel);
1173                             fShmRtClientControl.writeUShort(event.ctrl.param);
1174                             fShmRtClientControl.commitWrite();
1175                         }
1176                         break;
1177
1178                     case kEngineControlEventTypeAllSoundOff:
1179                         if (pData->options & PLUGIN_OPTION_SEND_ALL_SOUND_OFF)
1180                         {
1181                             fShmRtClientControl.writeOpcode(kPluginBridgeRtClientControlEventAllSoundOff);
1182                             fShmRtClientControl.writeUInt(event.time);
1183                             fShmRtClientControl.writeByte(event.channel);
1184                             fShmRtClientControl.commitWrite();
1185                         }
1186                         break;
1187
1188                     case kEngineControlEventTypeAllNotesOff:
1189                         if (pData->options & PLUGIN_OPTION_SEND_ALL_SOUND_OFF)
1190                         {
1191 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
1192                             if (event.channel == pData->ctrlChannel && ! allNotesOffSent)
1193                             {
1194                                 allNotesOffSent = true;
1195                                 postponeRtAllNotesOff();
1196                             }
1197 #endif
1198
1199                             fShmRtClientControl.writeOpcode(kPluginBridgeRtClientControlEventAllNotesOff);
1200                             fShmRtClientControl.writeUInt(event.time);
1201                             fShmRtClientControl.writeByte(event.channel);
1202                             fShmRtClientControl.commitWrite();
1203                         }
1204                         break;
1205                     } // switch (ctrlEvent.type)
1206                     break;
1207                 } // case kEngineEventTypeControl
1208
1209                 case kEngineEventTypeMidi: {
1210                     const EngineMidiEvent& midiEvent(event.midi);
1211
1212                     if (midiEvent.size == 0 || midiEvent.size >= MAX_MIDI_VALUE)
1213                         continue;
1214
1215                     const uint8_t* const midiData(midiEvent.size > EngineMidiEvent::kDataSize ? midiEvent.dataExt : midiEvent.data);
1216
1217                     uint8_t status = uint8_t(MIDI_GET_STATUS_FROM_DATA(midiData));
1218
1219                     if ((status == MIDI_STATUS_NOTE_OFF || status == MIDI_STATUS_NOTE_ON) && (pData->options & PLUGIN_OPTION_SKIP_SENDING_NOTES))
1220                         continue;
1221                     if (status == MIDI_STATUS_CHANNEL_PRESSURE && (pData->options & PLUGIN_OPTION_SEND_CHANNEL_PRESSURE) == 0)
1222                         continue;
1223                     if (status == MIDI_STATUS_CONTROL_CHANGE && (pData->options & PLUGIN_OPTION_SEND_CONTROL_CHANGES) == 0)
1224                         continue;
1225                     if (status == MIDI_STATUS_POLYPHONIC_AFTERTOUCH && (pData->options & PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH) == 0)
1226                         continue;
1227                     if (status == MIDI_STATUS_PITCH_WHEEL_CONTROL && (pData->options & PLUGIN_OPTION_SEND_PITCHBEND) == 0)
1228                         continue;
1229
1230                     // Fix bad note-off
1231                     if (status == MIDI_STATUS_NOTE_ON && midiData[2] == 0)
1232                         status = MIDI_STATUS_NOTE_OFF;
1233
1234                     fShmRtClientControl.writeOpcode(kPluginBridgeRtClientMidiEvent);
1235                     fShmRtClientControl.writeUInt(event.time);
1236                     fShmRtClientControl.writeByte(midiEvent.port);
1237                     fShmRtClientControl.writeByte(midiEvent.size);
1238
1239                     fShmRtClientControl.writeByte(uint8_t(midiData[0] | (event.channel & MIDI_CHANNEL_BIT)));
1240
1241                     for (uint8_t j=1; j < midiEvent.size; ++j)
1242                         fShmRtClientControl.writeByte(midiData[j]);
1243
1244                     fShmRtClientControl.commitWrite();
1245
1246                     if (status == MIDI_STATUS_NOTE_ON)
1247                     {
1248                         pData->postponeNoteOnRtEvent(true, event.channel, midiData[1], midiData[2]);
1249                     }
1250                     else if (status == MIDI_STATUS_NOTE_OFF)
1251                     {
1252                         pData->postponeNoteOffRtEvent(true, event.channel, midiData[1]);
1253                     }
1254                 } break;
1255                 }
1256             }
1257
1258             pData->postRtEvents.trySplice();
1259
1260         } // End of Event Input
1261
1262         if (! processSingle(audioIn, audioOut, frames))
1263             return;
1264
1265         // --------------------------------------------------------------------------------------------------------
1266         // MIDI Output
1267
1268         if (pData->event.portOut != nullptr)
1269         {
1270             uint32_t time;
1271             uint8_t port, size;
1272             const uint8_t* midiData(fShmRtClientControl.data->midiOut);
1273
1274             for (std::size_t read=0; read<kBridgeRtClientDataMidiOutSize-kBridgeBaseMidiOutHeaderSize;)
1275             {
1276                 // get time
1277                 time = *(const uint32_t*)midiData;
1278                 midiData += 4;
1279
1280                 // get port and size
1281                 port = *midiData++;
1282                 size = *midiData++;
1283
1284                 if (size == 0)
1285                     break;
1286
1287                 // store midi data advancing as needed
1288                 uint8_t data[size];
1289
1290                 for (uint8_t j=0; j<size; ++j)
1291                     data[j] = *midiData++;
1292
1293                 pData->event.portOut->writeMidiEvent(time, size, data);
1294
1295                 read += kBridgeBaseMidiOutHeaderSize + size;
1296             }
1297
1298             // TODO
1299             (void)port;
1300
1301         } // End of Control and MIDI Output
1302     }
1303
1304     bool processSingle(const float* const* const audioIn, float** const audioOut, const uint32_t frames)
1305     {
1306         CARLA_SAFE_ASSERT_RETURN(! fTimedError, false);
1307         CARLA_SAFE_ASSERT_RETURN(frames > 0, false);
1308         CARLA_SAFE_ASSERT_RETURN(frames <= fBufferSize, false);
1309
1310         if (pData->audioIn.count > 0)
1311         {
1312             CARLA_SAFE_ASSERT_RETURN(audioIn != nullptr, false);
1313         }
1314         if (pData->audioOut.count > 0)
1315         {
1316             CARLA_SAFE_ASSERT_RETURN(audioOut != nullptr, false);
1317         }
1318
1319         // --------------------------------------------------------------------------------------------------------
1320         // Try lock, silence otherwise
1321
1322 #ifndef STOAT_TEST_BUILD
1323         if (pData->engine->isOffline())
1324         {
1325             pData->singleMutex.lock();
1326         }
1327         else
1328 #endif
1329         if (! pData->singleMutex.tryLock())
1330         {
1331             for (uint32_t i=0; i < pData->audioOut.count; ++i)
1332                 carla_zeroFloats(audioOut[i], frames);
1333             return false;
1334         }
1335
1336         // --------------------------------------------------------------------------------------------------------
1337         // Reset audio buffers
1338
1339         for (uint32_t i=0; i < fInfo.aIns; ++i)
1340             carla_copyFloats(fShmAudioPool.data + (i * fBufferSize), audioIn[i], frames);
1341
1342         // --------------------------------------------------------------------------------------------------------
1343         // TimeInfo
1344
1345         const EngineTimeInfo timeInfo(pData->engine->getTimeInfo());
1346         BridgeTimeInfo& bridgeTimeInfo(fShmRtClientControl.data->timeInfo);
1347
1348         bridgeTimeInfo.playing    = timeInfo.playing;
1349         bridgeTimeInfo.frame      = timeInfo.frame;
1350         bridgeTimeInfo.usecs      = timeInfo.usecs;
1351         bridgeTimeInfo.validFlags = timeInfo.bbt.valid ? kPluginBridgeTimeInfoValidBBT : 0x0;
1352
1353         if (timeInfo.bbt.valid)
1354         {
1355             bridgeTimeInfo.bar  = timeInfo.bbt.bar;
1356             bridgeTimeInfo.beat = timeInfo.bbt.beat;
1357             bridgeTimeInfo.tick = timeInfo.bbt.tick;
1358
1359             bridgeTimeInfo.beatsPerBar = timeInfo.bbt.beatsPerBar;
1360             bridgeTimeInfo.beatType    = timeInfo.bbt.beatType;
1361
1362             bridgeTimeInfo.ticksPerBeat   = timeInfo.bbt.ticksPerBeat;
1363             bridgeTimeInfo.beatsPerMinute = timeInfo.bbt.beatsPerMinute;
1364             bridgeTimeInfo.barStartTick   = timeInfo.bbt.barStartTick;
1365         }
1366
1367         // --------------------------------------------------------------------------------------------------------
1368         // Run plugin
1369
1370         {
1371             fShmRtClientControl.writeOpcode(kPluginBridgeRtClientProcess);
1372             fShmRtClientControl.writeUInt(frames);
1373             fShmRtClientControl.commitWrite();
1374         }
1375
1376         waitForClient("process", fProcWaitTime);
1377
1378         if (fTimedOut)
1379         {
1380             pData->singleMutex.unlock();
1381             return false;
1382         }
1383
1384         if (fShmRtClientControl.data->procFlags)
1385         {
1386             fInitiated    = false;
1387             fProcCanceled = true;
1388         }
1389
1390         for (uint32_t i=0; i < fInfo.aOuts; ++i)
1391             carla_copyFloats(audioOut[i], fShmAudioPool.data + ((i + fInfo.aIns) * fBufferSize), frames);
1392
1393 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
1394         // --------------------------------------------------------------------------------------------------------
1395         // Post-processing (dry/wet, volume and balance)
1396
1397         {
1398             const bool doVolume  = (pData->hints & PLUGIN_CAN_VOLUME) != 0 && carla_isNotEqual(pData->postProc.volume, 1.0f);
1399             const bool doDryWet  = (pData->hints & PLUGIN_CAN_DRYWET) != 0 && carla_isNotEqual(pData->postProc.dryWet, 1.0f);
1400             const bool doBalance = (pData->hints & PLUGIN_CAN_BALANCE) != 0 && ! (carla_isEqual(pData->postProc.balanceLeft, -1.0f) && carla_isEqual(pData->postProc.balanceRight, 1.0f));
1401             const bool isMono    = (pData->audioIn.count == 1);
1402
1403             bool isPair;
1404             float bufValue;
1405             float* const oldBufLeft = pData->postProc.extraBuffer;
1406
1407             for (uint32_t i=0; i < pData->audioOut.count; ++i)
1408             {
1409                 // Dry/Wet
1410                 if (doDryWet)
1411                 {
1412                     const uint32_t c = isMono ? 0 : i;
1413
1414                     for (uint32_t k=0; k < frames; ++k)
1415                     {
1416                         bufValue = audioIn[c][k];
1417                         audioOut[i][k] = (audioOut[i][k] * pData->postProc.dryWet) + (bufValue * (1.0f - pData->postProc.dryWet));
1418                     }
1419                 }
1420
1421                 // Balance
1422                 if (doBalance)
1423                 {
1424                     isPair = (i % 2 == 0);
1425
1426                     if (isPair)
1427                     {
1428                         CARLA_ASSERT(i+1 < pData->audioOut.count);
1429                         carla_copyFloats(oldBufLeft, audioOut[i], frames);
1430                     }
1431
1432                     float balRangeL = (pData->postProc.balanceLeft  + 1.0f)/2.0f;
1433                     float balRangeR = (pData->postProc.balanceRight + 1.0f)/2.0f;
1434
1435                     for (uint32_t k=0; k < frames; ++k)
1436                     {
1437                         if (isPair)
1438                         {
1439                             // left
1440                             audioOut[i][k]  = oldBufLeft[k]     * (1.0f - balRangeL);
1441                             audioOut[i][k] += audioOut[i+1][k] * (1.0f - balRangeR);
1442                         }
1443                         else
1444                         {
1445                             // right
1446                             audioOut[i][k]  = audioOut[i][k] * balRangeR;
1447                             audioOut[i][k] += oldBufLeft[k]   * balRangeL;
1448                         }
1449                     }
1450                 }
1451
1452                 // Volume
1453                 if (doVolume)
1454                 {
1455                     for (uint32_t k=0; k < frames; ++k)
1456                         audioOut[i][k] *= pData->postProc.volume;
1457                 }
1458             }
1459
1460         } // End of Post-processing
1461 #endif
1462         // --------------------------------------------------------------------------------------------------------
1463
1464         pData->singleMutex.unlock();
1465         return true;
1466     }
1467
1468     void bufferSizeChanged(const uint32_t newBufferSize) override
1469     {
1470         fBufferSize = newBufferSize;
1471         resizeAudioPool(newBufferSize);
1472
1473         {
1474             fShmRtClientControl.writeOpcode(kPluginBridgeRtClientSetBufferSize);
1475             fShmRtClientControl.writeUInt(newBufferSize);
1476             fShmRtClientControl.commitWrite();
1477         }
1478
1479         //fProcWaitTime = newBufferSize*1000/pData->engine->getSampleRate();
1480         fProcWaitTime = 1000;
1481
1482         waitForClient("buffersize", 1000);
1483     }
1484
1485     void sampleRateChanged(const double newSampleRate) override
1486     {
1487         {
1488             fShmRtClientControl.writeOpcode(kPluginBridgeRtClientSetSampleRate);
1489             fShmRtClientControl.writeDouble(newSampleRate);
1490             fShmRtClientControl.commitWrite();
1491         }
1492
1493         //fProcWaitTime = pData->engine->getBufferSize()*1000/newSampleRate;
1494         fProcWaitTime = 1000;
1495
1496         waitForClient("samplerate", 1000);
1497     }
1498
1499     void offlineModeChanged(const bool isOffline) override
1500     {
1501         {
1502             fShmRtClientControl.writeOpcode(kPluginBridgeRtClientSetOnline);
1503             fShmRtClientControl.writeBool(isOffline);
1504             fShmRtClientControl.commitWrite();
1505         }
1506
1507         waitForClient("offline", 1000);
1508     }
1509
1510     // -------------------------------------------------------------------
1511     // Post-poned UI Stuff
1512
1513     // -------------------------------------------------------------------
1514
1515     void handleNonRtData()
1516     {
1517         for (; fShmNonRtServerControl.isDataAvailableForReading();)
1518         {
1519             const PluginBridgeNonRtServerOpcode opcode(fShmNonRtServerControl.readOpcode());
1520 //#ifdef DEBUG
1521             if (opcode != kPluginBridgeNonRtServerPong)
1522             {
1523                 carla_debug("CarlaPluginJack::handleNonRtData() - got opcode: %s", PluginBridgeNonRtServerOpcode2str(opcode));
1524             }
1525 //#endif
1526             switch (opcode)
1527             {
1528             case kPluginBridgeNonRtServerNull:
1529             case kPluginBridgeNonRtServerPong:
1530             case kPluginBridgeNonRtServerPluginInfo1:
1531             case kPluginBridgeNonRtServerPluginInfo2:
1532             case kPluginBridgeNonRtServerAudioCount:
1533             case kPluginBridgeNonRtServerMidiCount:
1534             case kPluginBridgeNonRtServerCvCount:
1535             case kPluginBridgeNonRtServerParameterCount:
1536             case kPluginBridgeNonRtServerProgramCount:
1537             case kPluginBridgeNonRtServerMidiProgramCount:
1538             case kPluginBridgeNonRtServerPortName:
1539             case kPluginBridgeNonRtServerParameterData1:
1540             case kPluginBridgeNonRtServerParameterData2:
1541             case kPluginBridgeNonRtServerParameterRanges:
1542             case kPluginBridgeNonRtServerParameterValue:
1543             case kPluginBridgeNonRtServerParameterValue2:
1544             case kPluginBridgeNonRtServerParameterTouch:
1545             case kPluginBridgeNonRtServerDefaultValue:
1546             case kPluginBridgeNonRtServerCurrentProgram:
1547             case kPluginBridgeNonRtServerCurrentMidiProgram:
1548             case kPluginBridgeNonRtServerProgramName:
1549             case kPluginBridgeNonRtServerMidiProgramData:
1550             case kPluginBridgeNonRtServerSetCustomData:
1551             case kPluginBridgeNonRtServerVersion:
1552             case kPluginBridgeNonRtServerRespEmbedUI:
1553             case kPluginBridgeNonRtServerResizeEmbedUI:
1554                 break;
1555
1556             case kPluginBridgeNonRtServerSetChunkDataFile:
1557                 // uint/size, str[] (filename)
1558                 if (const uint32_t chunkFilePathSize = fShmNonRtServerControl.readUInt())
1559                 {
1560                     char chunkFilePath[chunkFilePathSize];
1561                     fShmNonRtServerControl.readCustomData(chunkFilePath, chunkFilePathSize);
1562                 }
1563                 break;
1564
1565             case kPluginBridgeNonRtServerSetLatency:
1566             case kPluginBridgeNonRtServerSetParameterText:
1567                 break;
1568
1569             case kPluginBridgeNonRtServerReady:
1570                 fInitiated = true;
1571                 break;
1572
1573             case kPluginBridgeNonRtServerSaved:
1574                 break;
1575
1576             case kPluginBridgeNonRtServerUiClosed:
1577                 pData->engine->callback(true, true,
1578                                         ENGINE_CALLBACK_UI_STATE_CHANGED,
1579                                         pData->id,
1580                                         0,
1581                                         0, 0, 0.0f, nullptr);
1582                 break;
1583
1584             case kPluginBridgeNonRtServerError: {
1585                 // error
1586                 const uint32_t errorSize(fShmNonRtServerControl.readUInt());
1587                 char error[errorSize+1];
1588                 carla_zeroChars(error, errorSize+1);
1589                 fShmNonRtServerControl.readCustomData(error, errorSize);
1590
1591                 if (fInitiated)
1592                 {
1593                     pData->engine->callback(true, true, ENGINE_CALLBACK_ERROR, pData->id, 0, 0, 0, 0.0f, error);
1594
1595                     // just in case
1596                     pData->engine->setLastError(error);
1597                     fInitError = true;
1598                 }
1599                 else
1600                 {
1601                     pData->engine->setLastError(error);
1602                     fInitError = true;
1603                     fInitiated = true;
1604                 }
1605             }   break;
1606             }
1607         }
1608     }
1609
1610     // -------------------------------------------------------------------
1611
1612     uintptr_t getUiBridgeProcessId() const noexcept override
1613     {
1614         return fBridgeThread.getProcessID();
1615     }
1616
1617     // -------------------------------------------------------------------
1618
1619     bool init(const CarlaPluginPtr plugin,
1620               const char* const filename, const char* const name, const char* const label, const uint options)
1621     {
1622         CARLA_SAFE_ASSERT_RETURN(pData->engine != nullptr, false);
1623
1624         // ---------------------------------------------------------------
1625         // first checks
1626
1627         if (pData->client != nullptr)
1628         {
1629             pData->engine->setLastError("Plugin client is already registered");
1630             return false;
1631         }
1632
1633         if (filename == nullptr || filename[0] == '\0')
1634         {
1635             pData->engine->setLastError("null filename");
1636             return false;
1637         }
1638
1639         if (label == nullptr || label[0] == '\0')
1640         {
1641             pData->engine->setLastError("null label");
1642             return false;
1643         }
1644
1645         // ---------------------------------------------------------------
1646         // check setup
1647
1648         if (std::strlen(label) < 6)
1649         {
1650             pData->engine->setLastError("invalid application setup received");
1651             return false;
1652         }
1653
1654         for (int i=4; --i >= 0;) {
1655             CARLA_SAFE_ASSERT_INT2_RETURN(label[i] >= '0' && label[i] <= '0'+64, i, label[i], false);
1656         }
1657         CARLA_SAFE_ASSERT_INT2_RETURN(label[4] >= '0' && label[4] < '0'+0x4f, 4, label[4], false);
1658         CARLA_SAFE_ASSERT_UINT2_RETURN(static_cast<uchar>(label[5]) >= '0' &&
1659                                        static_cast<uchar>(label[5]) <= '0'+0x73,
1660                                        static_cast<uchar>(label[5]),
1661                                        static_cast<uchar>('0'+0x73),
1662                                        false);
1663
1664         fInfo.aIns   = static_cast<uint8_t>(label[0] - '0');
1665         fInfo.aOuts  = static_cast<uint8_t>(label[1] - '0');
1666         fInfo.mIns   = static_cast<uint8_t>(carla_minPositive(label[2] - '0', 1));
1667         fInfo.mOuts  = static_cast<uint8_t>(carla_minPositive(label[3] - '0', 1));
1668
1669         fInfo.setupLabel = label;
1670
1671         // ---------------------------------------------------------------
1672         // set project unique id
1673
1674         if (label[6] == '\0')
1675             setupUniqueProjectID();
1676
1677         // ---------------------------------------------------------------
1678         // set icon
1679
1680         pData->iconName = carla_strdup_safe("application");
1681
1682         // ---------------------------------------------------------------
1683         // set info
1684
1685         pData->filename = carla_strdup(filename);
1686
1687         if (name != nullptr && name[0] != '\0')
1688             pData->name = pData->engine->getUniquePluginName(name);
1689         else
1690             pData->name = pData->engine->getUniquePluginName("Jack Application");
1691
1692         std::srand(static_cast<uint>(std::time(nullptr)));
1693
1694         // ---------------------------------------------------------------
1695         // init sem/shm
1696
1697         if (! fShmAudioPool.initializeServer())
1698         {
1699             carla_stderr("Failed to initialize shared memory audio pool");
1700             return false;
1701         }
1702
1703         if (! fShmRtClientControl.initializeServer())
1704         {
1705             carla_stderr("Failed to initialize RT client control");
1706             fShmAudioPool.clear();
1707             return false;
1708         }
1709
1710         if (! fShmNonRtClientControl.initializeServer())
1711         {
1712             carla_stderr("Failed to initialize Non-RT client control");
1713             fShmRtClientControl.clear();
1714             fShmAudioPool.clear();
1715             return false;
1716         }
1717
1718         if (! fShmNonRtServerControl.initializeServer())
1719         {
1720             carla_stderr("Failed to initialize Non-RT server control");
1721             fShmNonRtClientControl.clear();
1722             fShmRtClientControl.clear();
1723             fShmAudioPool.clear();
1724             return false;
1725         }
1726
1727         // ---------------------------------------------------------------
1728         // setup hints and options
1729
1730         fSetupHints = static_cast<uint>(static_cast<uchar>(label[5]) - '0');
1731
1732         // FIXME dryWet broken
1733         pData->hints  = PLUGIN_IS_BRIDGE;
1734 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
1735         pData->hints |= /*PLUGIN_CAN_DRYWET |*/ PLUGIN_CAN_VOLUME | PLUGIN_CAN_BALANCE;
1736 #endif
1737
1738         if (fSetupHints & LIBJACK_FLAG_CONTROL_WINDOW)
1739             pData->hints |= PLUGIN_HAS_CUSTOM_UI;
1740
1741         // ---------------------------------------------------------------
1742         // init bridge thread
1743
1744         {
1745             char shmIdsStr[6*4+1];
1746             carla_zeroChars(shmIdsStr, 6*4+1);
1747
1748             std::strncpy(shmIdsStr+6*0, &fShmAudioPool.filename[fShmAudioPool.filename.length()-6], 6);
1749             std::strncpy(shmIdsStr+6*1, &fShmRtClientControl.filename[fShmRtClientControl.filename.length()-6], 6);
1750             std::strncpy(shmIdsStr+6*2, &fShmNonRtClientControl.filename[fShmNonRtClientControl.filename.length()-6], 6);
1751             std::strncpy(shmIdsStr+6*3, &fShmNonRtServerControl.filename[fShmNonRtServerControl.filename.length()-6], 6);
1752
1753             fBridgeThread.setData(shmIdsStr, fInfo.setupLabel);
1754         }
1755
1756         if (! restartBridgeThread())
1757             return false;
1758
1759         // ---------------------------------------------------------------
1760         // register client
1761
1762         if (pData->name == nullptr)
1763             pData->name = pData->engine->getUniquePluginName("unknown");
1764
1765         pData->client = pData->engine->addClient(plugin);
1766
1767         if (pData->client == nullptr || ! pData->client->isOk())
1768         {
1769             pData->engine->setLastError("Failed to register plugin client");
1770             return false;
1771         }
1772
1773         // remove unprintable characters if needed
1774         if (fSetupHints & LIBJACK_FLAG_EXTERNAL_START)
1775             fInfo.setupLabel[5U] = static_cast<char>('0' + (fSetupHints ^ LIBJACK_FLAG_EXTERNAL_START));
1776
1777         // ---------------------------------------------------------------
1778         // set options
1779
1780         pData->options = PLUGIN_OPTION_FIXED_BUFFERS;
1781
1782         if (isPluginOptionEnabled(options, PLUGIN_OPTION_SEND_CONTROL_CHANGES))
1783             pData->options |= PLUGIN_OPTION_SEND_CONTROL_CHANGES;
1784
1785         if (isPluginOptionEnabled(options, PLUGIN_OPTION_SEND_CHANNEL_PRESSURE))
1786             pData->options |= PLUGIN_OPTION_SEND_CHANNEL_PRESSURE;
1787
1788         if (isPluginOptionEnabled(options, PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH))
1789             pData->options |= PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH;
1790
1791         if (isPluginOptionEnabled(options, PLUGIN_OPTION_SEND_PITCHBEND))
1792             pData->options |= PLUGIN_OPTION_SEND_PITCHBEND;
1793
1794         if (isPluginOptionEnabled(options, PLUGIN_OPTION_SEND_ALL_SOUND_OFF))
1795             pData->options |= PLUGIN_OPTION_SEND_ALL_SOUND_OFF;
1796
1797         if (isPluginOptionEnabled(options, PLUGIN_OPTION_SEND_PROGRAM_CHANGES))
1798             pData->options |= PLUGIN_OPTION_SEND_PROGRAM_CHANGES;
1799
1800         if (isPluginOptionInverseEnabled(options, PLUGIN_OPTION_SKIP_SENDING_NOTES))
1801             pData->options |= PLUGIN_OPTION_SKIP_SENDING_NOTES;
1802
1803         return true;
1804     }
1805
1806 private:
1807     bool fInitiated;
1808     bool fInitError;
1809     bool fTimedOut;
1810     bool fTimedError;
1811     bool fProcCanceled;
1812     uint fBufferSize;
1813     uint fProcWaitTime;
1814     uint fSetupHints;
1815
1816     CarlaPluginJackThread fBridgeThread;
1817
1818     BridgeAudioPool          fShmAudioPool;
1819     BridgeRtClientControl    fShmRtClientControl;
1820     BridgeNonRtClientControl fShmNonRtClientControl;
1821     BridgeNonRtServerControl fShmNonRtServerControl;
1822
1823     struct Info {
1824         uint8_t aIns, aOuts;
1825         uint8_t mIns, mOuts;
1826         CarlaString setupLabel;
1827         std::vector<uint8_t> chunk;
1828
1829         Info()
1830             : aIns(0),
1831               aOuts(0),
1832               mIns(0),
1833               mOuts(0),
1834               setupLabel(),
1835               chunk() {}
1836
1837         CARLA_DECLARE_NON_COPYABLE(Info)
1838     } fInfo;
1839
1840     void handleProcessStopped() noexcept
1841     {
1842         const bool wasActive = pData->active;
1843         pData->active = false;
1844
1845         if (wasActive)
1846         {
1847             pData->engine->callback(true, true,
1848                                     ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED,
1849                                     pData->id,
1850                                     PARAMETER_ACTIVE,
1851                                     0, 0,
1852                                     0.0f,
1853                                     nullptr);
1854         }
1855
1856         if (pData->hints & PLUGIN_HAS_CUSTOM_UI)
1857             pData->engine->callback(true, true,
1858                                     ENGINE_CALLBACK_UI_STATE_CHANGED,
1859                                     pData->id,
1860                                     0,
1861                                     0, 0, 0.0f, nullptr);
1862     }
1863
1864     void resizeAudioPool(const uint32_t bufferSize)
1865     {
1866         fShmAudioPool.resize(bufferSize, static_cast<uint32_t>(fInfo.aIns+fInfo.aOuts), 0);
1867
1868         fShmRtClientControl.writeOpcode(kPluginBridgeRtClientSetAudioPool);
1869         fShmRtClientControl.writeULong(static_cast<uint64_t>(fShmAudioPool.dataSize));
1870         fShmRtClientControl.commitWrite();
1871
1872         waitForClient("resize-pool", 5000);
1873     }
1874
1875     void setupUniqueProjectID()
1876     {
1877         const char* const engineProjectFolder = pData->engine->getCurrentProjectFolder();
1878         carla_stdout("setupUniqueProjectID %s", engineProjectFolder);
1879
1880         if (engineProjectFolder == nullptr || engineProjectFolder[0] == '\0')
1881             return;
1882
1883         const File file(engineProjectFolder);
1884         CARLA_SAFE_ASSERT_RETURN(file.exists(),);
1885
1886         char code[6];
1887         code[5] = '\0';
1888
1889         String child;
1890
1891         for (;;)
1892         {
1893             static const char* const kValidChars =
1894                 "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1895                 "abcdefghijklmnopqrstuvwxyz"
1896                 "0123456789";
1897
1898             static const size_t kValidCharsLen(std::strlen(kValidChars)-1U);
1899
1900             code[0] = kValidChars[safe_rand(kValidCharsLen)];
1901             code[1] = kValidChars[safe_rand(kValidCharsLen)];
1902             code[2] = kValidChars[safe_rand(kValidCharsLen)];
1903             code[3] = kValidChars[safe_rand(kValidCharsLen)];
1904             code[4] = kValidChars[safe_rand(kValidCharsLen)];
1905
1906             child  = pData->name;
1907             child += ".";
1908             child += code;
1909             const File newFile(file.getChildFile(child));
1910
1911             if (newFile.existsAsFile())
1912                 continue;
1913
1914             fInfo.setupLabel += code;
1915             carla_stdout("new label %s", fInfo.setupLabel.buffer());
1916             break;
1917         }
1918     }
1919
1920     bool restartBridgeThread()
1921     {
1922         fInitiated  = false;
1923         fInitError  = false;
1924         fTimedError = false;
1925
1926         // reset memory
1927         fProcCanceled = false;
1928         fShmRtClientControl.data->procFlags = 0;
1929         carla_zeroStruct(fShmRtClientControl.data->timeInfo);
1930         carla_zeroBytes(fShmRtClientControl.data->midiOut, kBridgeRtClientDataMidiOutSize);
1931
1932         fShmRtClientControl.clearData();
1933         fShmNonRtClientControl.clearData();
1934         fShmNonRtServerControl.clearData();
1935
1936         // initial values
1937         fShmNonRtClientControl.writeOpcode(kPluginBridgeNonRtClientVersion);
1938         fShmNonRtClientControl.writeUInt(CARLA_PLUGIN_BRIDGE_API_VERSION_CURRENT);
1939
1940         fShmNonRtClientControl.writeUInt(static_cast<uint32_t>(sizeof(BridgeRtClientData)));
1941         fShmNonRtClientControl.writeUInt(static_cast<uint32_t>(sizeof(BridgeNonRtClientData)));
1942         fShmNonRtClientControl.writeUInt(static_cast<uint32_t>(sizeof(BridgeNonRtServerData)));
1943
1944         fShmNonRtClientControl.writeOpcode(kPluginBridgeNonRtClientInitialSetup);
1945         fShmNonRtClientControl.writeUInt(pData->engine->getBufferSize());
1946         fShmNonRtClientControl.writeDouble(pData->engine->getSampleRate());
1947
1948         fShmNonRtClientControl.commitWrite();
1949
1950         if (fShmAudioPool.dataSize != 0)
1951         {
1952             fShmRtClientControl.writeOpcode(kPluginBridgeRtClientSetAudioPool);
1953             fShmRtClientControl.writeULong(static_cast<uint64_t>(fShmAudioPool.dataSize));
1954             fShmRtClientControl.commitWrite();
1955         }
1956         else
1957         {
1958             // testing dummy message
1959             fShmRtClientControl.writeOpcode(kPluginBridgeRtClientNull);
1960             fShmRtClientControl.commitWrite();
1961         }
1962
1963         fBridgeThread.startThread();
1964
1965         const bool needsCancelableAction = ! pData->engine->isLoadingProject();
1966         const bool needsEngineIdle = pData->engine->getType() != kEngineTypePlugin;
1967
1968         CarlaString actionName;
1969
1970         if (needsCancelableAction)
1971         {
1972             if (fSetupHints & LIBJACK_FLAG_EXTERNAL_START)
1973             {
1974                 const EngineOptions& options(pData->engine->getOptions());
1975                 CarlaString binaryDir(options.binaryDir);
1976
1977                 char* const hwVars = fBridgeThread.getEnvVarsToExport();
1978
1979                 actionName  = "Waiting for external JACK application start, please use the following environment variables:\n";
1980                 actionName += hwVars;
1981
1982                 delete[] hwVars;
1983             }
1984             else
1985             {
1986                 actionName = "Loading JACK application";
1987             }
1988
1989             pData->engine->setActionCanceled(false);
1990             pData->engine->callback(true, true,
1991                                     ENGINE_CALLBACK_CANCELABLE_ACTION,
1992                                     pData->id,
1993                                     1,
1994                                     0, 0, 0.0f,
1995                                     actionName.buffer());
1996         }
1997
1998         for (;fBridgeThread.isThreadRunning();)
1999         {
2000             pData->engine->callback(true, false, ENGINE_CALLBACK_IDLE, 0, 0, 0, 0, 0.0f, nullptr);
2001
2002             if (needsEngineIdle)
2003                 pData->engine->idle();
2004
2005             idle();
2006
2007             if (fInitiated)
2008                 break;
2009             if (pData->engine->isAboutToClose() || pData->engine->wasActionCanceled())
2010                 break;
2011
2012             carla_msleep(5);
2013         }
2014
2015         if (needsCancelableAction)
2016         {
2017             pData->engine->callback(true, true,
2018                                     ENGINE_CALLBACK_CANCELABLE_ACTION,
2019                                     pData->id,
2020                                     0,
2021                                     0, 0, 0.0f,
2022                                     actionName.buffer());
2023         }
2024
2025         if (fInitError || ! fInitiated)
2026         {
2027             fBridgeThread.stopThread(6000);
2028
2029             if (! fInitError)
2030                 pData->engine->setLastError("Timeout while waiting for a response from plugin-bridge\n"
2031                                             "(or the plugin crashed on initialization?)");
2032
2033             return false;
2034         }
2035
2036         return true;
2037     }
2038
2039     void waitForClient(const char* const action, const uint msecs)
2040     {
2041         CARLA_SAFE_ASSERT_RETURN(! fTimedOut,);
2042         CARLA_SAFE_ASSERT_RETURN(! fTimedError,);
2043
2044         if (fShmRtClientControl.waitForClient(msecs))
2045             return;
2046
2047         fTimedOut = true;
2048         carla_stderr2("waitForClient(%s) timed out", action);
2049     }
2050
2051     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaPluginJack)
2052 };
2053
2054 CARLA_BACKEND_END_NAMESPACE
2055
2056 #endif // CARLA_OS_LINUX
2057
2058 // -------------------------------------------------------------------------------------------------------------------
2059
2060 CARLA_BACKEND_START_NAMESPACE
2061
2062 CarlaPluginPtr CarlaPlugin::newJackApp(const Initializer& init)
2063 {
2064     carla_debug("CarlaPlugin::newJackApp({%p, \"%s\", \"%s\", \"%s\"})",
2065                 init.engine, init.filename, init.name, init.label);
2066
2067 #if defined(CARLA_OS_LINUX) || defined(CARLA_OS_MAC)
2068     std::shared_ptr<CarlaPluginJack> plugin(new CarlaPluginJack(init.engine, init.id));
2069
2070     if (! plugin->init(plugin, init.filename, init.name, init.label, init.options))
2071         return nullptr;
2072
2073     return plugin;
2074 #else
2075     init.engine->setLastError("JACK Application support not available");
2076     return nullptr;
2077 #endif
2078 }
2079
2080 CARLA_BACKEND_END_NAMESPACE
2081
2082 // -------------------------------------------------------------------------------------------------------------------