source/backend/engine/CarlaEngineBridge.cpp

   1 // SPDX-FileCopyrightText: 2011-2024 Filipe Coelho <falktx@falktx.com>
   2 // SPDX-License-Identifier: GPL-2.0-or-later
   3
   4 #ifndef BUILD_BRIDGE
   5 # error This file should not be compiled if not building bridge
   6 #endif
   7
   8 // must be first so we can undef CARLA_SAFE_*_RETURN_ERR* macros
   9 #include "CarlaPluginInternal.hpp"
  10 #undef CARLA_SAFE_ASSERT_RETURN_ERR
  11 #undef CARLA_SAFE_ASSERT_RETURN_ERRN
  12 #undef CARLA_SAFE_EXCEPTION_RETURN_ERR
  13 #undef CARLA_SAFE_EXCEPTION_RETURN_ERRN
  14
  15 #include "CarlaEngineClient.hpp"
  16 #include "CarlaEngineInit.hpp"
  17
  18 #include "CarlaBackendUtils.hpp"
  19 #include "CarlaBase64Utils.hpp"
  20 #include "CarlaBridgeUtils.hpp"
  21 #include "CarlaTimeUtils.hpp"
  22 #include "CarlaMIDI.h"
  23
  24 #ifdef __SSE2_MATH__
  25 # include <xmmintrin.h>
  26 #endif
  27
  28 #include "water/files/File.h"
  29 #include "water/misc/Time.h"
  30
  31 // must be last
  32 #include "jackbridge/JackBridge.hpp"
  33
  34 using water::File;
  35 using water::MemoryBlock;
  36 using water::String;
  37
  38 CARLA_BACKEND_START_NAMESPACE
  39
  40 // -----------------------------------------------------------------------
  41 // Bridge Engine client
  42
  43 struct LatencyChangedCallback {
  44     virtual ~LatencyChangedCallback() noexcept {}
  45     virtual void latencyChanged(const uint32_t samples) noexcept = 0;
  46 };
  47
  48 class CarlaEngineBridgeClient : public CarlaEngineClientForSubclassing
  49 {
  50 public:
  51 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
  52     CarlaEngineBridgeClient(const CarlaEngine& engine,
  53                             EngineInternalGraph& egraph,
  54                             const CarlaPluginPtr plugin,
  55                             LatencyChangedCallback* const cb)
  56         : CarlaEngineClientForSubclassing(engine, egraph, plugin),
  57           fLatencyCallback(cb) {}
  58 #else
  59     CarlaEngineBridgeClient(const CarlaEngine& engine, LatencyChangedCallback* const cb)
  60         : CarlaEngineClientForSubclassing(engine),
  61           fLatencyCallback(cb) {}
  62 #endif
  63
  64 protected:
  65     void setLatency(const uint32_t samples) noexcept override
  66     {
  67         if (getLatency() == samples)
  68             return;
  69
  70         fLatencyCallback->latencyChanged(samples);
  71         CarlaEngineClient::setLatency(samples);
  72     }
  73
  74 private:
  75     LatencyChangedCallback* const fLatencyCallback;
  76
  77     CARLA_DECLARE_NON_COPYABLE(CarlaEngineBridgeClient)
  78 };
  79
  80 // -------------------------------------------------------------------
  81
  82 struct BridgeTextReader {
  83     char* text;
  84
  85     BridgeTextReader(BridgeNonRtClientControl& nonRtClientCtrl)
  86         : text(nullptr)
  87     {
  88         const uint32_t size = nonRtClientCtrl.readUInt();
  89         CARLA_SAFE_ASSERT_RETURN(size != 0,);
  90
  91         text = new char[size + 1];
  92         nonRtClientCtrl.readCustomData(text, size);
  93         text[size] = '\0';
  94     }
  95
  96     BridgeTextReader(BridgeNonRtClientControl& nonRtClientCtrl, const uint32_t size)
  97         : text(nullptr)
  98     {
  99         text = new char[size + 1];
 100
 101         if (size != 0)
 102             nonRtClientCtrl.readCustomData(text, size);
 103
 104         text[size] = '\0';
 105     }
 106
 107     ~BridgeTextReader() noexcept
 108     {
 109         delete[] text;
 110     }
 111
 112     CARLA_DECLARE_NON_COPYABLE(BridgeTextReader)
 113 };
 114
 115 // -------------------------------------------------------------------
 116
 117 class CarlaEngineBridge : public CarlaEngine,
 118                           private CarlaThread,
 119                           private LatencyChangedCallback
 120 {
 121 public:
 122     CarlaEngineBridge(const char* const audioPoolBaseName, const char* const rtClientBaseName, const char* const nonRtClientBaseName, const char* const nonRtServerBaseName)
 123         : CarlaEngine(),
 124           CarlaThread("CarlaEngineBridge"),
 125           fShmAudioPool(),
 126           fShmRtClientControl(),
 127           fShmNonRtClientControl(),
 128           fShmNonRtServerControl(),
 129           fBaseNameAudioPool(audioPoolBaseName),
 130           fBaseNameRtClientControl(rtClientBaseName),
 131           fBaseNameNonRtClientControl(nonRtClientBaseName),
 132           fBaseNameNonRtServerControl(nonRtServerBaseName),
 133           fClosingDown(false),
 134           fIsOffline(false),
 135           fFirstIdle(true),
 136           fBridgeVersion(0),
 137           fLastPingTime(UINT32_MAX)
 138     {
 139         carla_debug("CarlaEngineBridge::CarlaEngineBridge(\"%s\", \"%s\", \"%s\", \"%s\")", audioPoolBaseName, rtClientBaseName, nonRtClientBaseName, nonRtServerBaseName);
 140     }
 141
 142     ~CarlaEngineBridge() noexcept override
 143     {
 144         carla_debug("CarlaEngineBridge::~CarlaEngineBridge()");
 145
 146         clear();
 147     }
 148
 149     // -------------------------------------
 150     // CarlaEngine virtual calls
 151
 152     bool init(const char* const clientName) override
 153     {
 154         carla_debug("CarlaEngineBridge::init(\"%s\")", clientName);
 155
 156         if (! pData->init(clientName))
 157         {
 158             setLastError("Failed to init internal data");
 159             return false;
 160         }
 161
 162         if (! fShmAudioPool.attachClient(fBaseNameAudioPool))
 163         {
 164             pData->close();
 165             setLastError("Failed to attach to audio pool shared memory");
 166             return false;
 167         }
 168
 169         if (! fShmRtClientControl.attachClient(fBaseNameRtClientControl))
 170         {
 171             pData->close();
 172             clear();
 173             setLastError("Failed to attach to rt client control shared memory");
 174             return false;
 175         }
 176
 177         if (! fShmRtClientControl.mapData())
 178         {
 179             pData->close();
 180             clear();
 181             setLastError("Failed to map rt client control shared memory");
 182             return false;
 183         }
 184
 185         if (! fShmNonRtClientControl.attachClient(fBaseNameNonRtClientControl))
 186         {
 187             pData->close();
 188             clear();
 189             setLastError("Failed to attach to non-rt client control shared memory");
 190             return false;
 191         }
 192
 193         if (! fShmNonRtClientControl.mapData())
 194         {
 195             pData->close();
 196             clear();
 197             setLastError("Failed to map non-rt control client shared memory");
 198             return false;
 199         }
 200
 201         if (! fShmNonRtServerControl.attachClient(fBaseNameNonRtServerControl))
 202         {
 203             pData->close();
 204             clear();
 205             setLastError("Failed to attach to non-rt server control shared memory");
 206             return false;
 207         }
 208
 209         if (! fShmNonRtServerControl.mapData())
 210         {
 211             pData->close();
 212             clear();
 213             setLastError("Failed to map non-rt control server shared memory");
 214             return false;
 215         }
 216
 217         PluginBridgeNonRtClientOpcode opcode;
 218
 219         opcode = fShmNonRtClientControl.readOpcode();
 220         CARLA_SAFE_ASSERT_RETURN(opcode == kPluginBridgeNonRtClientVersion, false);
 221
 222         const uint32_t apiVersion = fShmNonRtClientControl.readUInt();
 223         CARLA_SAFE_ASSERT_RETURN(apiVersion >= CARLA_PLUGIN_BRIDGE_API_VERSION_MINIMUM, false);
 224
 225         const uint32_t shmRtClientDataSize = fShmNonRtClientControl.readUInt();
 226         CARLA_SAFE_ASSERT_INT2(shmRtClientDataSize == sizeof(BridgeRtClientData), shmRtClientDataSize, sizeof(BridgeRtClientData));
 227
 228         const uint32_t shmNonRtClientDataSize = fShmNonRtClientControl.readUInt();
 229         CARLA_SAFE_ASSERT_INT2(shmNonRtClientDataSize == sizeof(BridgeNonRtClientData), shmNonRtClientDataSize, sizeof(BridgeNonRtClientData));
 230
 231         const uint32_t shmNonRtServerDataSize = fShmNonRtClientControl.readUInt();
 232         CARLA_SAFE_ASSERT_INT2(shmNonRtServerDataSize == sizeof(BridgeNonRtServerData), shmNonRtServerDataSize, sizeof(BridgeNonRtServerData));
 233
 234         if (shmRtClientDataSize != sizeof(BridgeRtClientData) ||
 235             shmNonRtClientDataSize != sizeof(BridgeNonRtClientData) ||
 236             shmNonRtServerDataSize != sizeof(BridgeNonRtServerData))
 237         {
 238             pData->close();
 239             clear();
 240             setLastError("Shared memory data size mismatch");
 241             return false;
 242         }
 243
 244         opcode = fShmNonRtClientControl.readOpcode();
 245         CARLA_SAFE_ASSERT_RETURN(opcode == kPluginBridgeNonRtClientInitialSetup, false);
 246
 247         pData->bufferSize = fShmNonRtClientControl.readUInt();
 248         pData->sampleRate = fShmNonRtClientControl.readDouble();
 249
 250         if (pData->bufferSize == 0 || carla_isZero(pData->sampleRate))
 251         {
 252             pData->close();
 253             clear();
 254             setLastError("Shared memory has invalid data");
 255             return false;
 256         }
 257
 258         pData->initTime(nullptr);
 259
 260         // tell backend we're live
 261         {
 262             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);
 263
 264             // kPluginBridgeNonRtServerVersion was added in API 7
 265             if (apiVersion >= 7)
 266             {
 267                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerVersion);
 268                 fShmNonRtServerControl.writeUInt(CARLA_PLUGIN_BRIDGE_API_VERSION_CURRENT);
 269             }
 270             else
 271             {
 272                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPong);
 273             }
 274
 275             fShmNonRtServerControl.commitWrite();
 276         }
 277
 278         startThread(true);
 279         return true;
 280     }
 281
 282     bool close() override
 283     {
 284         carla_debug("CarlaEngineBridge::close()");
 285         fLastPingTime = UINT32_MAX;
 286
 287         CarlaEngine::close();
 288
 289         stopThread(5000);
 290         clear();
 291
 292         return true;
 293     }
 294
 295     bool hasIdleOnMainThread() const noexcept override
 296     {
 297         return true;
 298     }
 299
 300     bool isRunning() const noexcept override
 301     {
 302         if (fClosingDown)
 303             return false;
 304
 305         return isThreadRunning() || ! fFirstIdle;
 306     }
 307
 308     bool isOffline() const noexcept override
 309     {
 310         return fIsOffline;
 311     }
 312
 313     EngineType getType() const noexcept override
 314     {
 315         return kEngineTypeBridge;
 316     }
 317
 318     const char* getCurrentDriverName() const noexcept override
 319     {
 320         return "Bridge";
 321     }
 322
 323     void touchPluginParameter(const uint id, const uint32_t parameterId, const bool touch) noexcept override
 324     {
 325         CARLA_SAFE_ASSERT_RETURN(id == 0,);
 326
 327         const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);
 328         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterTouch);
 329         fShmNonRtServerControl.writeUInt(parameterId);
 330         fShmNonRtServerControl.writeBool(touch);
 331         fShmNonRtServerControl.commitWrite();
 332     }
 333
 334     CarlaEngineClient* addClient(const CarlaPluginPtr plugin) override
 335     {
 336 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
 337         return new CarlaEngineBridgeClient(*this, pData->graph, plugin, this);
 338 #else
 339         return new CarlaEngineBridgeClient(*this, this);
 340
 341         // unused
 342         (void)plugin;
 343 #endif
 344     }
 345
 346     void idle() noexcept override
 347     {
 348         const CarlaPluginPtr plugin = pData->plugins[0].plugin;
 349
 350         if (plugin.get() == nullptr)
 351         {
 352             if (const uint32_t length = static_cast<uint32_t>(pData->lastError.length()))
 353             {
 354                 const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);
 355                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerError);
 356                 fShmNonRtServerControl.writeUInt(length);
 357                 fShmNonRtServerControl.writeCustomData(pData->lastError.buffer(), length);
 358                 fShmNonRtServerControl.commitWrite();
 359             }
 360
 361             signalThreadShouldExit();
 362             callback(true, true, ENGINE_CALLBACK_QUIT, 0, 0, 0, 0, 0.0f, nullptr);
 363             return;
 364         }
 365
 366         const bool wasFirstIdle = fFirstIdle;
 367
 368         if (wasFirstIdle)
 369         {
 370             fFirstIdle = false;
 371             fLastPingTime = carla_gettime_ms();
 372
 373             char bufStr[STR_MAX+1];
 374             carla_zeroChars(bufStr, STR_MAX+1);
 375
 376             uint32_t bufStrSize;
 377
 378             const CarlaEngineClient* const client(plugin->getEngineClient());
 379             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);
 380
 381             // kPluginBridgeNonRtServerPluginInfo1
 382             {
 383                 // uint/category, uint/hints, uint/optionsAvailable, uint/optionsEnabled, long/uniqueId
 384                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPluginInfo1);
 385                 fShmNonRtServerControl.writeUInt(plugin->getCategory());
 386                 fShmNonRtServerControl.writeUInt(plugin->getHints());
 387                 fShmNonRtServerControl.writeUInt(plugin->getOptionsAvailable());
 388                 fShmNonRtServerControl.writeUInt(plugin->getOptionsEnabled());
 389                 fShmNonRtServerControl.writeLong(plugin->getUniqueId());
 390                 fShmNonRtServerControl.commitWrite();
 391             }
 392
 393             // kPluginBridgeNonRtServerPluginInfo2
 394             {
 395                 // uint/size, str[] (realName), uint/size, str[] (label), uint/size, str[] (maker), uint/size, str[] (copyright)
 396                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPluginInfo2);
 397
 398                 if (! plugin->getRealName(bufStr))
 399                     bufStr[0] = '\0';
 400                 bufStrSize = carla_fixedValue(1U, 64U, static_cast<uint32_t>(std::strlen(bufStr)));
 401                 fShmNonRtServerControl.writeUInt(bufStrSize);
 402                 fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);
 403
 404                 if (! plugin->getLabel(bufStr))
 405                     bufStr[0] = '\0';
 406                 bufStrSize = carla_fixedValue(1U, 256U, static_cast<uint32_t>(std::strlen(bufStr)));
 407                 fShmNonRtServerControl.writeUInt(bufStrSize);
 408                 fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);
 409
 410                 if (! plugin->getMaker(bufStr))
 411                     bufStr[0] = '\0';
 412                 bufStrSize = carla_fixedValue(1U, 64U, static_cast<uint32_t>(std::strlen(bufStr)));
 413                 fShmNonRtServerControl.writeUInt(bufStrSize);
 414                 fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);
 415
 416                 if (! plugin->getCopyright(bufStr))
 417                     bufStr[0] = '\0';
 418                 bufStrSize = carla_fixedValue(1U, 64U, static_cast<uint32_t>(std::strlen(bufStr)));
 419                 fShmNonRtServerControl.writeUInt(bufStrSize);
 420                 fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);
 421
 422                 fShmNonRtServerControl.commitWrite();
 423             }
 424
 425             fShmNonRtServerControl.waitIfDataIsReachingLimit();
 426
 427             // kPluginBridgeNonRtServerAudioCount
 428             {
 429                 const uint32_t aIns  = plugin->getAudioInCount();
 430                 const uint32_t aOuts = plugin->getAudioOutCount();
 431
 432                 // uint/ins, uint/outs
 433                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerAudioCount);
 434                 fShmNonRtServerControl.writeUInt(aIns);
 435                 fShmNonRtServerControl.writeUInt(aOuts);
 436                 fShmNonRtServerControl.commitWrite();
 437
 438                 // kPluginBridgeNonRtServerPortName
 439                 for (uint32_t i=0; i<aIns; ++i)
 440                 {
 441                     const char* const portName(client->getAudioPortName(true, i));
 442                     CARLA_SAFE_ASSERT_CONTINUE(portName != nullptr && portName[0] != '\0');
 443
 444                     // byte/type, uint/index, uint/size, str[] (name)
 445                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPortName);
 446                     fShmNonRtServerControl.writeByte(kPluginBridgePortAudioInput);
 447                     fShmNonRtServerControl.writeUInt(i);
 448
 449                     bufStrSize = static_cast<uint32_t>(std::strlen(portName));
 450                     fShmNonRtServerControl.writeUInt(bufStrSize);
 451                     fShmNonRtServerControl.writeCustomData(portName, bufStrSize);
 452                 }
 453
 454                 // kPluginBridgeNonRtServerPortName
 455                 for (uint32_t i=0; i<aOuts; ++i)
 456                 {
 457                     const char* const portName(client->getAudioPortName(false, i));
 458                     CARLA_SAFE_ASSERT_CONTINUE(portName != nullptr && portName[0] != '\0');
 459
 460                     // byte/type, uint/index, uint/size, str[] (name)
 461                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPortName);
 462                     fShmNonRtServerControl.writeByte(kPluginBridgePortAudioOutput);
 463                     fShmNonRtServerControl.writeUInt(i);
 464
 465                     bufStrSize = static_cast<uint32_t>(std::strlen(portName));
 466                     fShmNonRtServerControl.writeUInt(bufStrSize);
 467                     fShmNonRtServerControl.writeCustomData(portName, bufStrSize);
 468                 }
 469             }
 470
 471             fShmNonRtServerControl.waitIfDataIsReachingLimit();
 472
 473             // kPluginBridgeNonRtServerMidiCount
 474             {
 475                 // uint/ins, uint/outs
 476                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerMidiCount);
 477                 fShmNonRtServerControl.writeUInt(plugin->getMidiInCount());
 478                 fShmNonRtServerControl.writeUInt(plugin->getMidiOutCount());
 479                 fShmNonRtServerControl.commitWrite();
 480             }
 481
 482             fShmNonRtServerControl.waitIfDataIsReachingLimit();
 483
 484             // kPluginBridgeNonRtServerCvCount
 485             {
 486                 // uint/ins, uint/outs
 487                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerCvCount);
 488                 fShmNonRtServerControl.writeUInt(plugin->getCVInCount());
 489                 fShmNonRtServerControl.writeUInt(plugin->getCVOutCount());
 490                 fShmNonRtServerControl.commitWrite();
 491             }
 492
 493             fShmNonRtServerControl.waitIfDataIsReachingLimit();
 494
 495             // kPluginBridgeNonRtServerParameter*
 496             if (const uint32_t count = plugin->getParameterCount())
 497             {
 498                 // uint/count
 499                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterCount);
 500                 fShmNonRtServerControl.writeUInt(count);
 501                 fShmNonRtServerControl.commitWrite();
 502
 503                 for (uint32_t i=0; i<count; ++i)
 504                 {
 505                     const ParameterData& paramData(plugin->getParameterData(i));
 506
 507                     if (paramData.type != PARAMETER_INPUT && paramData.type != PARAMETER_OUTPUT)
 508                         continue;
 509                     if ((paramData.hints & PARAMETER_IS_ENABLED) == 0)
 510                         continue;
 511
 512                     // kPluginBridgeNonRtServerParameterData1
 513                     {
 514                         // uint/index, int/rindex, uint/type, uint/hints, short/cc
 515                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterData1);
 516                         fShmNonRtServerControl.writeUInt(i);
 517                         fShmNonRtServerControl.writeInt(paramData.rindex);
 518                         fShmNonRtServerControl.writeUInt(paramData.type);
 519                         fShmNonRtServerControl.writeUInt(paramData.hints);
 520                         fShmNonRtServerControl.writeShort(paramData.mappedControlIndex);
 521                         fShmNonRtServerControl.commitWrite();
 522                     }
 523
 524                     // kPluginBridgeNonRtServerParameterData2
 525                     {
 526                         // uint/index, uint/size, str[] (name), uint/size, str[] (symbol), uint/size, str[] (unit)
 527                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterData2);
 528                         fShmNonRtServerControl.writeUInt(i);
 529
 530                         if (! plugin->getParameterName(i, bufStr))
 531                             std::snprintf(bufStr, STR_MAX, "Param %u", i+1);
 532                         bufStrSize = carla_fixedValue(1U, 32U, static_cast<uint32_t>(std::strlen(bufStr)));
 533                         fShmNonRtServerControl.writeUInt(bufStrSize);
 534                         fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);
 535
 536                         if (! plugin->getParameterSymbol(i, bufStr))
 537                             bufStr[0] = '\0';
 538                         bufStrSize = carla_fixedValue(1U, 64U, static_cast<uint32_t>(std::strlen(bufStr)));
 539                         fShmNonRtServerControl.writeUInt(bufStrSize);
 540                         fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);
 541
 542                         if (! plugin->getParameterUnit(i, bufStr))
 543                             bufStr[0] = '\0';
 544                         bufStrSize = carla_fixedValue(1U, 32U, static_cast<uint32_t>(std::strlen(bufStr)));
 545                         fShmNonRtServerControl.writeUInt(bufStrSize);
 546                         fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);
 547
 548                         fShmNonRtServerControl.commitWrite();
 549                     }
 550
 551                     // kPluginBridgeNonRtServerParameterRanges
 552                     {
 553                         const ParameterRanges& paramRanges(plugin->getParameterRanges(i));
 554
 555                         // uint/index, float/def, float/min, float/max, float/step, float/stepSmall, float/stepLarge
 556                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterRanges);
 557                         fShmNonRtServerControl.writeUInt(i);
 558                         fShmNonRtServerControl.writeFloat(paramRanges.def);
 559                         fShmNonRtServerControl.writeFloat(paramRanges.min);
 560                         fShmNonRtServerControl.writeFloat(paramRanges.max);
 561                         fShmNonRtServerControl.writeFloat(paramRanges.step);
 562                         fShmNonRtServerControl.writeFloat(paramRanges.stepSmall);
 563                         fShmNonRtServerControl.writeFloat(paramRanges.stepLarge);
 564                         fShmNonRtServerControl.commitWrite();
 565                     }
 566
 567                     // kPluginBridgeNonRtServerParameterValue2
 568                     {
 569                         // uint/index float/value (used for init/output parameters only, don't resend values)
 570                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterValue2);
 571                         fShmNonRtServerControl.writeUInt(i);
 572                         fShmNonRtServerControl.writeFloat(plugin->getParameterValue(i));
 573                         fShmNonRtServerControl.commitWrite();
 574                     }
 575
 576                     fShmNonRtServerControl.waitIfDataIsReachingLimit();
 577                 }
 578             }
 579
 580             // kPluginBridgeNonRtServerProgram*
 581             if (const uint32_t count = plugin->getProgramCount())
 582             {
 583                 // uint/count
 584                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerProgramCount);
 585                 fShmNonRtServerControl.writeUInt(count);
 586                 fShmNonRtServerControl.commitWrite();
 587
 588                 for (uint32_t i=0; i < count; ++i)
 589                 {
 590                     // uint/index, uint/size, str[] (name)
 591                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerProgramName);
 592                     fShmNonRtServerControl.writeUInt(i);
 593
 594                     if (! plugin->getProgramName(i, bufStr))
 595                         bufStr[0] = '\0';
 596                     bufStrSize = carla_fixedValue(1U, 32U, static_cast<uint32_t>(std::strlen(bufStr)));
 597                     fShmNonRtServerControl.writeUInt(bufStrSize);
 598                     fShmNonRtServerControl.writeCustomData(bufStr, bufStrSize);
 599
 600                     fShmNonRtServerControl.commitWrite();
 601                     fShmNonRtServerControl.waitIfDataIsReachingLimit();
 602                 }
 603             }
 604
 605             // kPluginBridgeNonRtServerMidiProgram*
 606             if (const uint32_t count = plugin->getMidiProgramCount())
 607             {
 608                 // uint/count
 609                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerMidiProgramCount);
 610                 fShmNonRtServerControl.writeUInt(count);
 611                 fShmNonRtServerControl.commitWrite();
 612
 613                 for (uint32_t i=0; i < count; ++i)
 614                 {
 615                     const MidiProgramData& mpData(plugin->getMidiProgramData(i));
 616                     CARLA_SAFE_ASSERT_CONTINUE(mpData.name != nullptr);
 617
 618                     // uint/index, uint/bank, uint/program, uint/size, str[] (name)
 619                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerMidiProgramData);
 620                     fShmNonRtServerControl.writeUInt(i);
 621                     fShmNonRtServerControl.writeUInt(mpData.bank);
 622                     fShmNonRtServerControl.writeUInt(mpData.program);
 623
 624                     bufStrSize = carla_fixedValue(1U, 32U, static_cast<uint32_t>(std::strlen(mpData.name)));
 625                     fShmNonRtServerControl.writeUInt(bufStrSize);
 626                     fShmNonRtServerControl.writeCustomData(mpData.name, bufStrSize);
 627
 628                     fShmNonRtServerControl.commitWrite();
 629                     fShmNonRtServerControl.waitIfDataIsReachingLimit();
 630                 }
 631             }
 632
 633             if (const uint32_t latency = plugin->getLatencyInFrames())
 634             {
 635                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetLatency);
 636                 fShmNonRtServerControl.writeUInt(latency);
 637                 fShmNonRtServerControl.commitWrite();
 638             }
 639
 640             // ready!
 641             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerReady);
 642             fShmNonRtServerControl.commitWrite();
 643             fShmNonRtServerControl.waitIfDataIsReachingLimit();
 644
 645             carla_stdout("Carla Bridge Ready!");
 646             fLastPingTime = carla_gettime_ms();
 647         }
 648
 649         // send parameter outputs
 650         if (const uint32_t count = plugin->getParameterCount())
 651         {
 652             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);
 653
 654             for (uint32_t i=0; i < count; ++i)
 655             {
 656                 if (! plugin->isParameterOutput(i))
 657                     continue;
 658
 659                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterValue2);
 660                 fShmNonRtServerControl.writeUInt(i);
 661                 fShmNonRtServerControl.writeFloat(plugin->getParameterValue(i));
 662
 663                 // parameter outputs are not that important, we can skip some
 664                 if (! fShmNonRtServerControl.commitWrite())
 665                     break;
 666             }
 667         }
 668
 669         CarlaEngine::idle();
 670
 671         try {
 672             handleNonRtData();
 673         } CARLA_SAFE_EXCEPTION("handleNonRtData");
 674
 675         if (fLastPingTime != UINT32_MAX && carla_gettime_ms() > fLastPingTime + 30000 && ! wasFirstIdle)
 676         {
 677             carla_stderr("Did not receive ping message from server for 30 secs, closing...");
 678             signalThreadShouldExit();
 679             callback(true, true, ENGINE_CALLBACK_QUIT, 0, 0, 0, 0, 0.0f, nullptr);
 680         }
 681     }
 682
 683     void callback(const bool sendHost, const bool sendOsc,
 684                   const EngineCallbackOpcode action, const uint pluginId,
 685                   const int value1, const int value2, const int value3,
 686                   const float valuef, const char* const valueStr) noexcept override
 687     {
 688         CarlaEngine::callback(sendHost, sendOsc, action, pluginId, value1, value2, value3, valuef, valueStr);
 689
 690         if (fClosingDown || ! sendHost)
 691             return;
 692
 693         switch (action)
 694         {
 695         // uint/index float/value
 696         case ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED: {
 697             CARLA_SAFE_ASSERT_BREAK(value1 >= 0);
 698             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);
 699             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterValue);
 700             fShmNonRtServerControl.writeUInt(static_cast<uint>(value1));
 701             fShmNonRtServerControl.writeFloat(valuef);
 702             fShmNonRtServerControl.commitWrite();
 703         }   break;
 704
 705         // uint/index float/value
 706         case ENGINE_CALLBACK_PARAMETER_DEFAULT_CHANGED: {
 707             CARLA_SAFE_ASSERT_BREAK(value1 >= 0);
 708             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);
 709             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerDefaultValue);
 710             fShmNonRtServerControl.writeUInt(static_cast<uint>(value1));
 711             fShmNonRtServerControl.writeFloat(valuef);
 712             fShmNonRtServerControl.commitWrite();
 713         }   break;
 714
 715         // int/index
 716         case ENGINE_CALLBACK_PROGRAM_CHANGED: {
 717             CARLA_SAFE_ASSERT_BREAK(value1 >= -1);
 718             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);
 719             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerCurrentProgram);
 720             fShmNonRtServerControl.writeInt(value1);
 721             fShmNonRtServerControl.commitWrite();
 722         }   break;
 723
 724         // int/index
 725         case ENGINE_CALLBACK_MIDI_PROGRAM_CHANGED: {
 726             CARLA_SAFE_ASSERT_BREAK(value1 >= -1);
 727             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);
 728             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerCurrentMidiProgram);
 729             fShmNonRtServerControl.writeInt(value1);
 730             fShmNonRtServerControl.commitWrite();
 731         }   break;
 732
 733         case ENGINE_CALLBACK_UI_STATE_CHANGED:
 734             if (value1 != 1)
 735             {
 736                 const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);
 737                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerUiClosed);
 738                 fShmNonRtServerControl.commitWrite();
 739             }
 740             break;
 741
 742         case ENGINE_CALLBACK_EMBED_UI_RESIZED: {
 743             CARLA_SAFE_ASSERT_BREAK(value1 > 1);
 744             CARLA_SAFE_ASSERT_BREAK(value2 > 1);
 745
 746             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);
 747
 748             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerResizeEmbedUI);
 749             fShmNonRtServerControl.writeUInt(static_cast<uint>(value1));
 750             fShmNonRtServerControl.writeUInt(static_cast<uint>(value2));
 751             fShmNonRtServerControl.commitWrite();
 752         }   break;
 753
 754         case ENGINE_CALLBACK_RELOAD_PARAMETERS:
 755             if (const CarlaPluginPtr plugin = pData->plugins[0].plugin)
 756             {
 757                 if (const uint32_t count = plugin->getParameterCount())
 758                 {
 759                     const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);
 760
 761                     for (uint32_t i=0; i<count; ++i)
 762                     {
 763                         const ParameterData& paramData(plugin->getParameterData(i));
 764
 765                         if (paramData.type != PARAMETER_INPUT && paramData.type != PARAMETER_OUTPUT)
 766                             continue;
 767                         if ((paramData.hints & PARAMETER_IS_ENABLED) == 0)
 768                             continue;
 769
 770                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerParameterValue);
 771                         fShmNonRtServerControl.writeUInt(i);
 772                         fShmNonRtServerControl.writeFloat(plugin->getParameterValue(i));
 773                         fShmNonRtServerControl.commitWrite();
 774
 775                         fShmNonRtServerControl.waitIfDataIsReachingLimit();
 776                     }
 777                 }
 778             }
 779             break;
 780
 781         default:
 782             break;
 783         }
 784     }
 785
 786     // -------------------------------------------------------------------
 787
 788     void clear() noexcept
 789     {
 790         fShmAudioPool.clear();
 791         fShmRtClientControl.clear();
 792         fShmNonRtClientControl.clear();
 793         fShmNonRtServerControl.clear();
 794     }
 795
 796     void handleNonRtData()
 797     {
 798         const CarlaPluginPtr plugin = pData->plugins[0].plugin;
 799         CARLA_SAFE_ASSERT_RETURN(plugin.get() != nullptr,);
 800
 801         for (; fShmNonRtClientControl.isDataAvailableForReading();)
 802         {
 803             const PluginBridgeNonRtClientOpcode opcode = fShmNonRtClientControl.readOpcode();
 804
 805 #ifdef DEBUG
 806             if (opcode != kPluginBridgeNonRtClientPing) {
 807                 carla_debug("CarlaEngineBridge::handleNonRtData() - got opcode: %i:%s",
 808                             opcode, PluginBridgeNonRtClientOpcode2str(opcode));
 809             }
 810 #endif
 811
 812             if (opcode != kPluginBridgeNonRtClientNull &&
 813                 opcode != kPluginBridgeNonRtClientPingOnOff && fLastPingTime != UINT32_MAX)
 814                 fLastPingTime = carla_gettime_ms();
 815
 816             switch (opcode)
 817             {
 818             case kPluginBridgeNonRtClientNull:
 819                 break;
 820
 821             case kPluginBridgeNonRtClientVersion: {
 822                 fBridgeVersion = fShmNonRtServerControl.readUInt();
 823                 CARLA_SAFE_ASSERT_UINT2(fBridgeVersion >= CARLA_PLUGIN_BRIDGE_API_VERSION_MINIMUM,
 824                                         fBridgeVersion, CARLA_PLUGIN_BRIDGE_API_VERSION_MINIMUM);
 825             }   break;
 826
 827             case kPluginBridgeNonRtClientPing: {
 828                 const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);
 829
 830                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerPong);
 831                 fShmNonRtServerControl.commitWrite();
 832             }   break;
 833
 834             case kPluginBridgeNonRtClientPingOnOff:
 835                 fLastPingTime = fShmNonRtClientControl.readBool() ? carla_gettime_ms() : UINT32_MAX;
 836                 break;
 837
 838             case kPluginBridgeNonRtClientActivate:
 839                 if (plugin->isEnabled())
 840                     plugin->setActive(true, false, false);
 841                 break;
 842
 843             case kPluginBridgeNonRtClientDeactivate:
 844                 if (plugin->isEnabled())
 845                     plugin->setActive(false, false, false);
 846                 break;
 847
 848             case kPluginBridgeNonRtClientInitialSetup:
 849                 // should never happen!!
 850                 fShmNonRtServerControl.readUInt();
 851                 fShmNonRtServerControl.readDouble();
 852                 break;
 853
 854             case kPluginBridgeNonRtClientSetParameterValue: {
 855                 const uint32_t index(fShmNonRtClientControl.readUInt());
 856                 const float    value(fShmNonRtClientControl.readFloat());
 857
 858                 if (plugin->isEnabled())
 859                     plugin->setParameterValue(index, value, false, false, false);
 860                 break;
 861             }
 862
 863             case kPluginBridgeNonRtClientSetParameterMidiChannel: {
 864                 const uint32_t index(fShmNonRtClientControl.readUInt());
 865                 const uint8_t  channel(fShmNonRtClientControl.readByte());
 866
 867                 if (plugin->isEnabled())
 868                     plugin->setParameterMidiChannel(index, channel, false, false);
 869                 break;
 870             }
 871
 872             case kPluginBridgeNonRtClientSetParameterMappedControlIndex: {
 873                 const uint32_t index(fShmNonRtClientControl.readUInt());
 874                 const int16_t  ctrl(fShmNonRtClientControl.readShort());
 875
 876                 if (plugin->isEnabled())
 877                     plugin->setParameterMappedControlIndex(index, ctrl, false, false, true);
 878                 break;
 879             }
 880
 881             case kPluginBridgeNonRtClientSetParameterMappedRange: {
 882                 const uint32_t index   = fShmNonRtClientControl.readUInt();
 883                 const float    minimum = fShmNonRtClientControl.readFloat();
 884                 const float    maximum = fShmNonRtClientControl.readFloat();
 885
 886                 if (plugin->isEnabled())
 887                     plugin->setParameterMappedRange(index, minimum, maximum, false, false);
 888                 break;
 889             }
 890
 891             case kPluginBridgeNonRtClientSetProgram: {
 892                 const int32_t index(fShmNonRtClientControl.readInt());
 893
 894                 if (plugin->isEnabled())
 895                     plugin->setProgram(index, true, false, false);
 896                 break;
 897             }
 898
 899             case kPluginBridgeNonRtClientSetMidiProgram: {
 900                 const int32_t index(fShmNonRtClientControl.readInt());
 901
 902                 if (plugin->isEnabled())
 903                     plugin->setMidiProgram(index, true, false, false);
 904                 break;
 905             }
 906
 907             case kPluginBridgeNonRtClientSetCustomData: {
 908                 const uint32_t maxLocalValueLen = fBridgeVersion >= 10 ? 4096 : 16384;
 909
 910                 // type
 911                 const BridgeTextReader type(fShmNonRtClientControl);
 912
 913                 // key
 914                 const BridgeTextReader key(fShmNonRtClientControl);
 915
 916                 // value
 917                 const uint32_t valueSize = fShmNonRtClientControl.readUInt();
 918
 919                 if (valueSize > 0)
 920                 {
 921                     if (valueSize > maxLocalValueLen)
 922                     {
 923                         const BridgeTextReader bigValueFilePathTry(fShmNonRtClientControl);
 924
 925                         CARLA_SAFE_ASSERT_BREAK(bigValueFilePathTry.text[0] != '\0');
 926                         if (! plugin->isEnabled()) break;
 927
 928                         String bigValueFilePath(bigValueFilePathTry.text);
 929
 930 #ifdef CARLA_OS_WIN
 931                         // check if running under Wine
 932                         if (bigValueFilePath.startsWith("/"))
 933                             bigValueFilePath = bigValueFilePath.replaceSection(0, 1, "Z:\\").replace("/", "\\");
 934 #endif
 935
 936                         File bigValueFile(bigValueFilePath.toRawUTF8());
 937                         CARLA_SAFE_ASSERT_BREAK(bigValueFile.existsAsFile());
 938
 939                         plugin->setCustomData(type.text, key.text, bigValueFile.loadFileAsString().toRawUTF8(), true);
 940
 941                         bigValueFile.deleteFile();
 942                     }
 943                     else
 944                     {
 945                         const BridgeTextReader value(fShmNonRtClientControl, valueSize);
 946
 947                         if (plugin->isEnabled())
 948                             plugin->setCustomData(type.text, key.text, value.text, true);
 949                     }
 950                 }
 951                 else
 952                 {
 953                     if (plugin->isEnabled())
 954                         plugin->setCustomData(type.text, key.text, "", true);
 955                 }
 956
 957                 break;
 958             }
 959
 960             case kPluginBridgeNonRtClientSetChunkDataFile: {
 961                 const uint32_t size = fShmNonRtClientControl.readUInt();
 962                 CARLA_SAFE_ASSERT_BREAK(size > 0);
 963
 964                 const BridgeTextReader chunkFilePathTry(fShmNonRtClientControl, size);
 965
 966                 CARLA_SAFE_ASSERT_BREAK(chunkFilePathTry.text[0] != '\0');
 967                 if (! plugin->isEnabled()) break;
 968
 969                 String chunkFilePath(chunkFilePathTry.text);
 970
 971 #ifdef CARLA_OS_WIN
 972                 // check if running under Wine
 973                 if (chunkFilePath.startsWith("/"))
 974                     chunkFilePath = chunkFilePath.replaceSection(0, 1, "Z:\\").replace("/", "\\");
 975 #endif
 976
 977                 File chunkFile(chunkFilePath.toRawUTF8());
 978                 CARLA_SAFE_ASSERT_BREAK(chunkFile.existsAsFile());
 979
 980                 String chunkDataBase64(chunkFile.loadFileAsString());
 981                 chunkFile.deleteFile();
 982                 CARLA_SAFE_ASSERT_BREAK(chunkDataBase64.isNotEmpty());
 983
 984                 std::vector<uint8_t> chunk(carla_getChunkFromBase64String(chunkDataBase64.toRawUTF8()));
 985
 986 #ifdef CARLA_PROPER_CPP11_SUPPORT
 987                 plugin->setChunkData(chunk.data(), chunk.size());
 988 #else
 989                 plugin->setChunkData(&chunk.front(), chunk.size());
 990 #endif
 991                 break;
 992             }
 993
 994             case kPluginBridgeNonRtClientSetCtrlChannel: {
 995                 const int16_t channel(fShmNonRtClientControl.readShort());
 996                 CARLA_SAFE_ASSERT_BREAK(channel >= -1 && channel < MAX_MIDI_CHANNELS);
 997
 998                 if (plugin->isEnabled())
 999                     plugin->setCtrlChannel(static_cast<int8_t>(channel), false, false);
1000                 break;
1001             }
1002
1003             case kPluginBridgeNonRtClientSetOption: {
1004                 const uint32_t option(fShmNonRtClientControl.readUInt());
1005                 const bool     yesNo(fShmNonRtClientControl.readBool());
1006
1007                 if (plugin->isEnabled())
1008                     plugin->setOption(option, yesNo, false);
1009                 break;
1010             }
1011
1012             case kPluginBridgeNonRtClientSetOptions: {
1013                 const uint32_t options(fShmNonRtClientControl.readUInt());
1014
1015                 plugin->pData->options = options;
1016                 break;
1017             }
1018
1019             case kPluginBridgeNonRtClientSetWindowTitle: {
1020                 const BridgeTextReader title(fShmNonRtClientControl);
1021
1022                 plugin->setCustomUITitle(title.text);
1023                 break;
1024             }
1025
1026             case kPluginBridgeNonRtClientGetParameterText: {
1027                 const int32_t index = fShmNonRtClientControl.readInt();
1028
1029                 if (index >= 0 && plugin->isEnabled())
1030                 {
1031                     char bufStr[STR_MAX+1];
1032                     carla_zeroChars(bufStr, STR_MAX+1);
1033                     if (! plugin->getParameterText(static_cast<uint32_t>(index), bufStr))
1034                         bufStr[0] = '\0';
1035
1036                     const uint32_t bufStrLen = static_cast<uint32_t>(std::strlen(bufStr));
1037
1038                     const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);
1039
1040                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetParameterText);
1041
1042                     fShmNonRtServerControl.writeInt(index);
1043                     fShmNonRtServerControl.writeUInt(bufStrLen);
1044                     fShmNonRtServerControl.writeCustomData(bufStr, bufStrLen);
1045                     fShmNonRtServerControl.commitWrite();
1046
1047                     fShmNonRtServerControl.waitIfDataIsReachingLimit();
1048                 }
1049                 else
1050                 {
1051                     const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);
1052
1053                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetParameterText);
1054                     fShmNonRtServerControl.writeInt(index);
1055                     fShmNonRtServerControl.writeUInt(0);
1056                     fShmNonRtServerControl.commitWrite();
1057                 }
1058
1059                 break;
1060             }
1061
1062             case kPluginBridgeNonRtClientPrepareForSave: {
1063                 if (! plugin->isEnabled())
1064                 {
1065                     const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);
1066                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSaved);
1067                     fShmNonRtServerControl.commitWrite();
1068                     return;
1069                 }
1070
1071                 plugin->prepareForSave(false);
1072
1073                 const uint32_t maxLocalValueLen = fBridgeVersion >= 10 ? 4096 : 16384;
1074
1075                 for (uint32_t i=0, count=plugin->getCustomDataCount(); i<count; ++i)
1076                 {
1077                     const CustomData& cdata(plugin->getCustomData(i));
1078
1079                     if (std::strcmp(cdata.type, CUSTOM_DATA_TYPE_PROPERTY) == 0)
1080                         continue;
1081
1082                     const uint32_t typeLen  = static_cast<uint32_t>(std::strlen(cdata.type));
1083                     const uint32_t keyLen   = static_cast<uint32_t>(std::strlen(cdata.key));
1084                     const uint32_t valueLen = static_cast<uint32_t>(std::strlen(cdata.value));
1085
1086                     {
1087                         const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);
1088
1089                         if (valueLen > maxLocalValueLen)
1090                             fShmNonRtServerControl.waitIfDataIsReachingLimit();
1091
1092                         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetCustomData);
1093
1094                         fShmNonRtServerControl.writeUInt(typeLen);
1095                         fShmNonRtServerControl.writeCustomData(cdata.type, typeLen);
1096
1097                         fShmNonRtServerControl.writeUInt(keyLen);
1098                         fShmNonRtServerControl.writeCustomData(cdata.key, keyLen);
1099
1100                         fShmNonRtServerControl.writeUInt(valueLen);
1101
1102                         if (valueLen > 0)
1103                         {
1104                             if (valueLen > maxLocalValueLen)
1105                             {
1106                                 String filePath(File::getSpecialLocation(File::tempDirectory).getFullPathName());
1107
1108                                 filePath += CARLA_OS_SEP_STR ".CarlaCustomData_";
1109                                 filePath += fShmAudioPool.getFilenameSuffix();
1110
1111                                 if (File(filePath.toRawUTF8()).replaceWithText(cdata.value))
1112                                 {
1113                                     const uint32_t ulength(static_cast<uint32_t>(filePath.length()));
1114
1115                                     fShmNonRtServerControl.writeUInt(ulength);
1116                                     fShmNonRtServerControl.writeCustomData(filePath.toRawUTF8(), ulength);
1117                                 }
1118                                 else
1119                                 {
1120                                     fShmNonRtServerControl.writeUInt(0);
1121                                 }
1122                             }
1123                             else
1124                             {
1125                                 fShmNonRtServerControl.writeCustomData(cdata.value, valueLen);
1126                             }
1127                         }
1128
1129                         fShmNonRtServerControl.commitWrite();
1130                         fShmNonRtServerControl.waitIfDataIsReachingLimit();
1131                     }
1132                 }
1133
1134                 if (plugin->getOptionsEnabled() & PLUGIN_OPTION_USE_CHUNKS)
1135                 {
1136                     void* data = nullptr;
1137                     if (const std::size_t dataSize = plugin->getChunkData(&data))
1138                     {
1139                         CARLA_SAFE_ASSERT_BREAK(data != nullptr);
1140
1141                         CarlaString dataBase64 = CarlaString::asBase64(data, dataSize);
1142                         CARLA_SAFE_ASSERT_BREAK(dataBase64.length() > 0);
1143
1144                         String filePath(File::getSpecialLocation(File::tempDirectory).getFullPathName());
1145
1146                         filePath += CARLA_OS_SEP_STR ".CarlaChunk_";
1147                         filePath += fShmAudioPool.getFilenameSuffix();
1148
1149                         if (File(filePath.toRawUTF8()).replaceWithText(dataBase64.buffer()))
1150                         {
1151                             const uint32_t ulength(static_cast<uint32_t>(filePath.length()));
1152
1153                             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);
1154
1155                             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetChunkDataFile);
1156                             fShmNonRtServerControl.writeUInt(ulength);
1157                             fShmNonRtServerControl.writeCustomData(filePath.toRawUTF8(), ulength);
1158                             fShmNonRtServerControl.commitWrite();
1159                         }
1160                     }
1161                 }
1162
1163                 {
1164                     const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);
1165
1166                     fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSaved);
1167                     fShmNonRtServerControl.commitWrite();
1168                 }
1169                 break;
1170             }
1171
1172             case kPluginBridgeNonRtClientRestoreLV2State:
1173                 if (plugin->isEnabled())
1174                     plugin->restoreLV2State(false);
1175                 break;
1176
1177             case kPluginBridgeNonRtClientShowUI:
1178                 if (plugin->isEnabled())
1179                     plugin->showCustomUI(true);
1180                 break;
1181
1182             case kPluginBridgeNonRtClientHideUI:
1183                 if (plugin->isEnabled())
1184                     plugin->showCustomUI(false);
1185                 break;
1186
1187             case kPluginBridgeNonRtClientEmbedUI: {
1188                 const uint64_t winId = fShmNonRtClientControl.readULong();
1189                 uint64_t resp = 0;
1190
1191                 if (plugin->isEnabled())
1192                     resp = reinterpret_cast<uint64_t>(plugin->embedCustomUI(reinterpret_cast<void*>(winId)));
1193
1194                 if (resp == 0)
1195                     resp = 1;
1196
1197                 const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);
1198
1199                 fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerRespEmbedUI);
1200                 fShmNonRtServerControl.writeULong(resp);
1201                 fShmNonRtServerControl.commitWrite();
1202                 break;
1203             }
1204
1205             case kPluginBridgeNonRtClientUiParameterChange: {
1206                 const uint32_t index = fShmNonRtClientControl.readUInt();
1207                 const float    value = fShmNonRtClientControl.readFloat();
1208
1209                 if (plugin->isEnabled())
1210                     plugin->uiParameterChange(index, value);
1211                 break;
1212             }
1213
1214             case kPluginBridgeNonRtClientUiProgramChange: {
1215                 const uint32_t index(fShmNonRtClientControl.readUInt());
1216
1217                 if (plugin->isEnabled())
1218                     plugin->uiProgramChange(index);
1219                 break;
1220             }
1221
1222             case kPluginBridgeNonRtClientUiMidiProgramChange: {
1223                 const uint32_t index(fShmNonRtClientControl.readUInt());
1224
1225                 if (plugin->isEnabled())
1226                     plugin->uiMidiProgramChange(index);
1227                 break;
1228             }
1229
1230             case kPluginBridgeNonRtClientUiNoteOn: {
1231                 const uint8_t chnl(fShmNonRtClientControl.readByte());
1232                 const uint8_t note(fShmNonRtClientControl.readByte());
1233                 const uint8_t velo(fShmNonRtClientControl.readByte());
1234
1235                 if (plugin->isEnabled())
1236                     plugin->uiNoteOn(chnl, note, velo);
1237                 break;
1238             }
1239
1240             case kPluginBridgeNonRtClientUiNoteOff: {
1241                 const uint8_t chnl(fShmNonRtClientControl.readByte());
1242                 const uint8_t note(fShmNonRtClientControl.readByte());
1243
1244                 if (plugin->isEnabled())
1245                     plugin->uiNoteOff(chnl, note);
1246                 break;
1247             }
1248
1249             case kPluginBridgeNonRtClientQuit:
1250                 fClosingDown = true;
1251                 signalThreadShouldExit();
1252                 callback(true, true, ENGINE_CALLBACK_QUIT, 0, 0, 0, 0, 0.0f, nullptr);
1253                 break;
1254
1255             case kPluginBridgeNonRtClientReload:
1256                 fFirstIdle = true;
1257                 break;
1258             }
1259         }
1260     }
1261
1262     // -------------------------------------------------------------------
1263
1264 protected:
1265     void run() override
1266     {
1267 #ifdef __SSE2_MATH__
1268         // Set FTZ and DAZ flags
1269         _mm_setcsr(_mm_getcsr() | 0x8040);
1270 #endif
1271
1272         bool quitReceived = false;
1273
1274         for (; ! shouldThreadExit();)
1275         {
1276             const BridgeRtClientControl::WaitHelper helper(fShmRtClientControl);
1277
1278             if (! helper.ok)
1279                 continue;
1280
1281             for (; fShmRtClientControl.isDataAvailableForReading();)
1282             {
1283                 const PluginBridgeRtClientOpcode opcode(fShmRtClientControl.readOpcode());
1284                 const CarlaPluginPtr plugin = pData->plugins[0].plugin;
1285
1286 #ifdef DEBUG
1287                 if (opcode != kPluginBridgeRtClientProcess && opcode != kPluginBridgeRtClientMidiEvent) {
1288                     carla_debug("CarlaEngineBridgeRtThread::run() - got opcode: %s", PluginBridgeRtClientOpcode2str(opcode));
1289                 }
1290 #endif
1291
1292                 switch (opcode)
1293                 {
1294                 case kPluginBridgeRtClientNull:
1295                     break;
1296
1297                 case kPluginBridgeRtClientSetAudioPool: {
1298                     if (fShmAudioPool.data != nullptr)
1299                     {
1300                         jackbridge_shm_unmap(fShmAudioPool.shm, fShmAudioPool.data);
1301                         fShmAudioPool.data = nullptr;
1302                     }
1303                     const uint64_t poolSize(fShmRtClientControl.readULong());
1304                     CARLA_SAFE_ASSERT_BREAK(poolSize > 0);
1305                     fShmAudioPool.data = (float*)jackbridge_shm_map(fShmAudioPool.shm, static_cast<size_t>(poolSize));
1306                     break;
1307                 }
1308
1309                 case kPluginBridgeRtClientSetBufferSize: {
1310                     const uint32_t bufferSize(fShmRtClientControl.readUInt());
1311                     pData->bufferSize = bufferSize;
1312                     bufferSizeChanged(bufferSize);
1313                     break;
1314                 }
1315
1316                 case kPluginBridgeRtClientSetSampleRate: {
1317                     const double sampleRate(fShmRtClientControl.readDouble());
1318                     pData->sampleRate = sampleRate;
1319                     sampleRateChanged(sampleRate);
1320                     break;
1321                 }
1322
1323                 case kPluginBridgeRtClientSetOnline:
1324                     fIsOffline = fShmRtClientControl.readBool();
1325                     offlineModeChanged(fIsOffline);
1326                     break;
1327
1328                 // NOTE this is never used
1329                 case kPluginBridgeRtClientControlEventParameter: {
1330                     const uint32_t time(fShmRtClientControl.readUInt());
1331                     const uint8_t  channel(fShmRtClientControl.readByte());
1332                     const uint16_t param(fShmRtClientControl.readUShort());
1333                     const float    value(fShmRtClientControl.readFloat());
1334
1335                     if (EngineEvent* const event = getNextFreeInputEvent())
1336                     {
1337                         event->type                 = kEngineEventTypeControl;
1338                         event->time                 = time;
1339                         event->channel              = channel;
1340                         event->ctrl.type            = kEngineControlEventTypeParameter;
1341                         event->ctrl.param           = param;
1342                         event->ctrl.midiValue       = -1;
1343                         event->ctrl.normalizedValue = value;
1344                         event->ctrl.handled         = true;
1345                     }
1346                     break;
1347                 }
1348
1349                 case kPluginBridgeRtClientControlEventMidiBank: {
1350                     const uint32_t time(fShmRtClientControl.readUInt());
1351                     const uint8_t  channel(fShmRtClientControl.readByte());
1352                     const uint16_t index(fShmRtClientControl.readUShort());
1353
1354                     if (EngineEvent* const event = getNextFreeInputEvent())
1355                     {
1356                         event->type                 = kEngineEventTypeControl;
1357                         event->time                 = time;
1358                         event->channel              = channel;
1359                         event->ctrl.type            = kEngineControlEventTypeMidiBank;
1360                         event->ctrl.param           = index;
1361                         event->ctrl.midiValue       = -1;
1362                         event->ctrl.normalizedValue = 0.0f;
1363                         event->ctrl.handled         = true;
1364                     }
1365                     break;
1366                 }
1367
1368                 case kPluginBridgeRtClientControlEventMidiProgram: {
1369                     const uint32_t time(fShmRtClientControl.readUInt());
1370                     const uint8_t  channel(fShmRtClientControl.readByte());
1371                     const uint16_t index(fShmRtClientControl.readUShort());
1372
1373                     if (EngineEvent* const event = getNextFreeInputEvent())
1374                     {
1375                         event->type                 = kEngineEventTypeControl;
1376                         event->time                 = time;
1377                         event->channel              = channel;
1378                         event->ctrl.type            = kEngineControlEventTypeMidiProgram;
1379                         event->ctrl.param           = index;
1380                         event->ctrl.midiValue       = -1;
1381                         event->ctrl.normalizedValue = 0.0f;
1382                         event->ctrl.handled         = true;
1383                     }
1384                     break;
1385                 }
1386
1387                 case kPluginBridgeRtClientControlEventAllSoundOff: {
1388                     const uint32_t time(fShmRtClientControl.readUInt());
1389                     const uint8_t  channel(fShmRtClientControl.readByte());
1390
1391                     if (EngineEvent* const event = getNextFreeInputEvent())
1392                     {
1393                         event->type                 = kEngineEventTypeControl;
1394                         event->time                 = time;
1395                         event->channel              = channel;
1396                         event->ctrl.type            = kEngineControlEventTypeAllSoundOff;
1397                         event->ctrl.param           = 0;
1398                         event->ctrl.midiValue       = -1;
1399                         event->ctrl.normalizedValue = 0.0f;
1400                         event->ctrl.handled         = true;
1401                     }
1402                 }   break;
1403
1404                 case kPluginBridgeRtClientControlEventAllNotesOff: {
1405                     const uint32_t time(fShmRtClientControl.readUInt());
1406                     const uint8_t  channel(fShmRtClientControl.readByte());
1407
1408                     if (EngineEvent* const event = getNextFreeInputEvent())
1409                     {
1410                         event->type                 = kEngineEventTypeControl;
1411                         event->time                 = time;
1412                         event->channel              = channel;
1413                         event->ctrl.type            = kEngineControlEventTypeAllNotesOff;
1414                         event->ctrl.param           = 0;
1415                         event->ctrl.midiValue       = -1;
1416                         event->ctrl.normalizedValue = 0.0f;
1417                         event->ctrl.handled         = true;
1418                     }
1419                 }   break;
1420
1421                 case kPluginBridgeRtClientMidiEvent: {
1422                     const uint32_t time(fShmRtClientControl.readUInt());
1423                     const uint8_t  port(fShmRtClientControl.readByte());
1424                     const uint8_t  size(fShmRtClientControl.readByte());
1425                     CARLA_SAFE_ASSERT_BREAK(size > 0);
1426
1427                     // FIXME variable-size stack
1428                     uint8_t data[4];
1429
1430                     {
1431                         uint8_t i=0;
1432                         for (; i<size && i<4; ++i)
1433                             data[i] = fShmRtClientControl.readByte();
1434                         for (; i<size; ++i)
1435                             fShmRtClientControl.readByte();
1436                     }
1437
1438                     if (size > 4)
1439                         continue;
1440
1441                     if (EngineEvent* const event = getNextFreeInputEvent())
1442                     {
1443                         event->type    = kEngineEventTypeMidi;
1444                         event->time    = time;
1445                         event->channel = MIDI_GET_CHANNEL_FROM_DATA(data);
1446
1447                         event->midi.port = port;
1448                         event->midi.size = size;
1449
1450                         if (size > EngineMidiEvent::kDataSize)
1451                         {
1452                             event->midi.dataExt = data;
1453                             std::memset(event->midi.data, 0, sizeof(uint8_t)*EngineMidiEvent::kDataSize);
1454                         }
1455                         else
1456                         {
1457                             event->midi.data[0] = MIDI_GET_STATUS_FROM_DATA(data);
1458
1459                             uint8_t i=1;
1460                             for (; i < size; ++i)
1461                                 event->midi.data[i] = data[i];
1462                             for (; i < EngineMidiEvent::kDataSize; ++i)
1463                                 event->midi.data[i] = 0;
1464
1465                             event->midi.dataExt = nullptr;
1466                         }
1467                     }
1468                     break;
1469                 }
1470
1471                 case kPluginBridgeRtClientProcess: {
1472                     const uint32_t frames(fShmRtClientControl.readUInt());
1473
1474                     CARLA_SAFE_ASSERT_BREAK(fShmAudioPool.data != nullptr);
1475
1476                     if (plugin.get() != nullptr && plugin->isEnabled() && plugin->tryLock(fIsOffline))
1477                     {
1478                         const BridgeTimeInfo& bridgeTimeInfo(fShmRtClientControl.data->timeInfo);
1479
1480                         const uint32_t audioInCount = plugin->getAudioInCount();
1481                         const uint32_t audioOutCount = plugin->getAudioOutCount();
1482                         const uint32_t cvInCount = plugin->getCVInCount();
1483                         const uint32_t cvOutCount = plugin->getCVOutCount();
1484
1485                         const float* audioIn[64];
1486                         /* */ float* audioOut[64];
1487                         const float* cvIn[32];
1488                         /* */ float* cvOut[32];
1489
1490                         float* fdata = fShmAudioPool.data;
1491
1492                         for (uint32_t i=0; i < audioInCount; ++i, fdata += pData->bufferSize)
1493                             audioIn[i] = fdata;
1494                         for (uint32_t i=0; i < audioOutCount; ++i, fdata += pData->bufferSize)
1495                             audioOut[i] = fdata;
1496
1497                         for (uint32_t i=0; i < cvInCount; ++i, fdata += pData->bufferSize)
1498                             cvIn[i] = fdata;
1499                         for (uint32_t i=0; i < cvOutCount; ++i, fdata += pData->bufferSize)
1500                             cvOut[i] = fdata;
1501
1502                         EngineTimeInfo& timeInfo(pData->timeInfo);
1503
1504                         timeInfo.playing   = bridgeTimeInfo.playing;
1505                         timeInfo.frame     = bridgeTimeInfo.frame;
1506                         timeInfo.usecs     = bridgeTimeInfo.usecs;
1507                         timeInfo.bbt.valid = (bridgeTimeInfo.validFlags & kPluginBridgeTimeInfoValidBBT) != 0;
1508
1509                         if (timeInfo.bbt.valid)
1510                         {
1511                             timeInfo.bbt.bar  = bridgeTimeInfo.bar;
1512                             timeInfo.bbt.beat = bridgeTimeInfo.beat;
1513                             timeInfo.bbt.tick = bridgeTimeInfo.tick;
1514
1515                             timeInfo.bbt.beatsPerBar = bridgeTimeInfo.beatsPerBar;
1516                             timeInfo.bbt.beatType    = bridgeTimeInfo.beatType;
1517
1518                             timeInfo.bbt.ticksPerBeat   = bridgeTimeInfo.ticksPerBeat;
1519                             timeInfo.bbt.beatsPerMinute = bridgeTimeInfo.beatsPerMinute;
1520                             timeInfo.bbt.barStartTick   = bridgeTimeInfo.barStartTick;
1521                         }
1522
1523                         plugin->initBuffers();
1524                         plugin->process(audioIn, audioOut, cvIn, cvOut, frames);
1525                         plugin->unlock();
1526                     }
1527
1528                     uint8_t* midiData(fShmRtClientControl.data->midiOut);
1529                     carla_zeroBytes(midiData, kBridgeBaseMidiOutHeaderSize);
1530                     std::size_t curMidiDataPos = 0;
1531
1532                     if (pData->events.in[0].type != kEngineEventTypeNull)
1533                         carla_zeroStructs(pData->events.in, kMaxEngineEventInternalCount);
1534
1535                     if (pData->events.out[0].type != kEngineEventTypeNull)
1536                     {
1537                         for (ushort i=0; i < kMaxEngineEventInternalCount; ++i)
1538                         {
1539                             const EngineEvent& event(pData->events.out[i]);
1540
1541                             if (event.type == kEngineEventTypeNull)
1542                                 break;
1543
1544                             if (event.type == kEngineEventTypeControl)
1545                             {
1546                                 uint8_t data[3];
1547                                 const uint8_t size = event.ctrl.convertToMidiData(event.channel, data);
1548                                 CARLA_SAFE_ASSERT_CONTINUE(size > 0 && size <= 3);
1549
1550                                 if (curMidiDataPos + kBridgeBaseMidiOutHeaderSize + size >= kBridgeRtClientDataMidiOutSize)
1551                                     break;
1552
1553                                 // set time
1554                                 *(uint32_t*)midiData = event.time;
1555                                 midiData = midiData + 4;
1556                                 curMidiDataPos += 4;
1557
1558                                 // set port
1559                                 *midiData++ = 0;
1560                                 ++curMidiDataPos;
1561
1562                                 // set size
1563                                 *midiData++ = size;
1564                                 ++curMidiDataPos;
1565
1566                                 // set data
1567                                 for (uint8_t j=0; j<size; ++j)
1568                                     *midiData++ = data[j];
1569
1570                                 curMidiDataPos += size;
1571                             }
1572                             else if (event.type == kEngineEventTypeMidi)
1573                             {
1574                                 const EngineMidiEvent& _midiEvent(event.midi);
1575
1576                                 if (curMidiDataPos + kBridgeBaseMidiOutHeaderSize + _midiEvent.size >= kBridgeRtClientDataMidiOutSize)
1577                                     break;
1578
1579                                 const uint8_t* const _midiData(_midiEvent.dataExt != nullptr ? _midiEvent.dataExt : _midiEvent.data);
1580
1581                                 // set time
1582                                 *(uint32_t*)midiData = event.time;
1583                                 midiData += 4;
1584                                 curMidiDataPos += 4;
1585
1586                                 // set port
1587                                 *midiData++ = _midiEvent.port;
1588                                 ++curMidiDataPos;
1589
1590                                 // set size
1591                                 *midiData++ = _midiEvent.size;
1592                                 ++curMidiDataPos;
1593
1594                                 // set data
1595                                 *midiData++ = uint8_t(_midiData[0] | (event.channel & MIDI_CHANNEL_BIT));
1596
1597                                 for (uint8_t j=1; j<_midiEvent.size; ++j)
1598                                     *midiData++ = _midiData[j];
1599
1600                                 curMidiDataPos += _midiEvent.size;
1601                             }
1602                         }
1603
1604                         if (curMidiDataPos != 0 &&
1605                             curMidiDataPos + kBridgeBaseMidiOutHeaderSize < kBridgeRtClientDataMidiOutSize)
1606                             carla_zeroBytes(midiData, kBridgeBaseMidiOutHeaderSize);
1607
1608                         carla_zeroStructs(pData->events.out, kMaxEngineEventInternalCount);
1609                     }
1610
1611                 }   break;
1612
1613                 case kPluginBridgeRtClientQuit: {
1614                     quitReceived = true;
1615                     fClosingDown = true;
1616                     signalThreadShouldExit();
1617                 }   break;
1618                 }
1619             }
1620         }
1621
1622         callback(true, true, ENGINE_CALLBACK_ENGINE_STOPPED, 0, 0, 0, 0, 0.0f, nullptr);
1623
1624         if (! quitReceived)
1625         {
1626             const char* const message("Plugin bridge error, process thread has stopped");
1627             const std::size_t messageSize(std::strlen(message));
1628
1629             const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);
1630             fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerError);
1631             fShmNonRtServerControl.writeUInt(messageSize);
1632             fShmNonRtServerControl.writeCustomData(message, messageSize);
1633             fShmNonRtServerControl.commitWrite();
1634         }
1635     }
1636
1637     // called from process thread above
1638     EngineEvent* getNextFreeInputEvent() const noexcept
1639     {
1640         for (ushort i=0; i < kMaxEngineEventInternalCount; ++i)
1641         {
1642             EngineEvent* const event(&pData->events.in[i]);
1643
1644             if (event->type == kEngineEventTypeNull)
1645                 return event;
1646         }
1647         return nullptr;
1648     }
1649
1650     void latencyChanged(const uint32_t samples) noexcept override
1651     {
1652         const CarlaMutexLocker _cml(fShmNonRtServerControl.mutex);
1653
1654         fShmNonRtServerControl.writeOpcode(kPluginBridgeNonRtServerSetLatency);
1655         fShmNonRtServerControl.writeUInt(samples);
1656         fShmNonRtServerControl.commitWrite();
1657     }
1658
1659     // -------------------------------------------------------------------
1660
1661 private:
1662     BridgeAudioPool          fShmAudioPool;
1663     BridgeRtClientControl    fShmRtClientControl;
1664     BridgeNonRtClientControl fShmNonRtClientControl;
1665     BridgeNonRtServerControl fShmNonRtServerControl;
1666
1667     CarlaString fBaseNameAudioPool;
1668     CarlaString fBaseNameRtClientControl;
1669     CarlaString fBaseNameNonRtClientControl;
1670     CarlaString fBaseNameNonRtServerControl;
1671
1672     bool fClosingDown;
1673     bool fIsOffline;
1674     bool fFirstIdle;
1675     uint32_t fBridgeVersion;
1676     uint32_t fLastPingTime;
1677
1678     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CarlaEngineBridge)
1679 };
1680
1681 // -----------------------------------------------------------------------
1682
1683 namespace EngineInit {
1684
1685 CarlaEngine* newBridge(const char* const audioPoolBaseName,
1686                        const char* const rtClientBaseName,
1687                        const char* const nonRtClientBaseName,
1688                        const char* const nonRtServerBaseName)
1689 {
1690     return new CarlaEngineBridge(audioPoolBaseName, rtClientBaseName, nonRtClientBaseName, nonRtServerBaseName);
1691 }
1692
1693 }
1694
1695 // -----------------------------------------------------------------------
1696
1697 CARLA_BACKEND_END_NAMESPACE
1698
1699 // -----------------------------------------------------------------------
1700
1701 #include "CarlaBridgeUtils.cpp"
1702
1703 // -----------------------------------------------------------------------