source/utils/CarlaBridgeUtils.cpp

   1 /*
   2  * Carla Bridge utils
   3  * Copyright (C) 2013-2023 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 "CarlaBridgeUtils.hpp"
  19 #include "CarlaShmUtils.hpp"
  20 #include "CarlaTimeUtils.hpp"
  21
  22 // must be last
  23 #include "jackbridge/JackBridge.hpp"
  24
  25 #if defined(CARLA_OS_WIN) && !defined(BUILDING_CARLA_FOR_WINE)
  26 # define PLUGIN_BRIDGE_NAMEPREFIX_AUDIO_POOL    "Local\\carla-bridge_shm_ap_"
  27 # define PLUGIN_BRIDGE_NAMEPREFIX_RT_CLIENT     "Local\\carla-bridge_shm_rtC_"
  28 # define PLUGIN_BRIDGE_NAMEPREFIX_NON_RT_CLIENT "Local\\carla-bridge_shm_nonrtC_"
  29 # define PLUGIN_BRIDGE_NAMEPREFIX_NON_RT_SERVER "Local\\carla-bridge_shm_nonrtS_"
  30 #else
  31 # define PLUGIN_BRIDGE_NAMEPREFIX_AUDIO_POOL    "/crlbrdg_shm_ap_"
  32 # define PLUGIN_BRIDGE_NAMEPREFIX_RT_CLIENT     "/crlbrdg_shm_rtC_"
  33 # define PLUGIN_BRIDGE_NAMEPREFIX_NON_RT_CLIENT "/crlbrdg_shm_nonrtC_"
  34 # define PLUGIN_BRIDGE_NAMEPREFIX_NON_RT_SERVER "/crlbrdg_shm_nonrtS_"
  35 #endif
  36
  37 // -------------------------------------------------------------------------------------------------------------------
  38
  39 template<typename T>
  40 bool jackbridge_shm_map2(void* shm, T*& value) noexcept
  41 {
  42     value = (T*)jackbridge_shm_map(shm, sizeof(T));
  43     return (value != nullptr);
  44 }
  45
  46 // -------------------------------------------------------------------------------------------------------------------
  47
  48 BridgeAudioPool::BridgeAudioPool() noexcept
  49     : data(nullptr),
  50       dataSize(0),
  51       filename(),
  52       isServer(false)
  53 {
  54     carla_zeroChars(shm, 64);
  55     jackbridge_shm_init(shm);
  56 }
  57
  58 BridgeAudioPool::~BridgeAudioPool() noexcept
  59 {
  60     // should be cleared by now
  61     CARLA_SAFE_ASSERT(data == nullptr);
  62
  63     clear();
  64 }
  65
  66 bool BridgeAudioPool::initializeServer() noexcept
  67 {
  68     char tmpFileBase[64] = {};
  69     std::snprintf(tmpFileBase, sizeof(tmpFileBase)-1, PLUGIN_BRIDGE_NAMEPREFIX_AUDIO_POOL "XXXXXX");
  70
  71     const carla_shm_t shm2 = carla_shm_create_temp(tmpFileBase);
  72     CARLA_SAFE_ASSERT_RETURN(carla_is_shm_valid(shm2), false);
  73
  74     void* const shmptr = shm;
  75     carla_shm_t& shm1  = *(carla_shm_t*)shmptr;
  76     carla_copyStruct(shm1, shm2);
  77
  78     filename = tmpFileBase;
  79     isServer = true;
  80     return true;
  81 }
  82
  83 bool BridgeAudioPool::attachClient(const char* const basename) noexcept
  84 {
  85     CARLA_SAFE_ASSERT_RETURN(basename != nullptr && basename[0] != '\0', false);
  86
  87     // must be invalid right now
  88     CARLA_SAFE_ASSERT_RETURN(! jackbridge_shm_is_valid(shm), false);
  89
  90     filename  = PLUGIN_BRIDGE_NAMEPREFIX_AUDIO_POOL;
  91     filename += basename;
  92
  93     jackbridge_shm_attach(shm, filename);
  94
  95     return jackbridge_shm_is_valid(shm);
  96 }
  97
  98 void BridgeAudioPool::clear() noexcept
  99 {
 100     filename.clear();
 101
 102     if (! jackbridge_shm_is_valid(shm))
 103     {
 104         CARLA_SAFE_ASSERT(data == nullptr);
 105         return;
 106     }
 107
 108     if (data != nullptr)
 109     {
 110         if (isServer)
 111             jackbridge_shm_unmap(shm, data);
 112         data = nullptr;
 113     }
 114
 115     dataSize = 0;
 116     jackbridge_shm_close(shm);
 117     jackbridge_shm_init(shm);
 118 }
 119
 120 void BridgeAudioPool::resize(const uint32_t bufferSize, const uint32_t audioPortCount, const uint32_t cvPortCount) noexcept
 121 {
 122     CARLA_SAFE_ASSERT_RETURN(jackbridge_shm_is_valid(shm),);
 123     CARLA_SAFE_ASSERT_RETURN(isServer,);
 124
 125     if (data != nullptr)
 126         jackbridge_shm_unmap(shm, data);
 127
 128     dataSize = (audioPortCount+cvPortCount)*bufferSize*sizeof(float);
 129
 130     if (dataSize == 0)
 131         dataSize = sizeof(float);
 132
 133     data = (float*)jackbridge_shm_map(shm, dataSize);
 134     CARLA_SAFE_ASSERT_RETURN(data != nullptr,);
 135
 136     std::memset(data, 0, dataSize);
 137 }
 138
 139 const char* BridgeAudioPool::getFilenameSuffix() const noexcept
 140 {
 141     CARLA_SAFE_ASSERT_RETURN(filename.isNotEmpty(), nullptr);
 142
 143     const std::size_t prefixLength(std::strlen(PLUGIN_BRIDGE_NAMEPREFIX_AUDIO_POOL));
 144     CARLA_SAFE_ASSERT_RETURN(filename.length() > prefixLength, nullptr);
 145
 146     return filename.buffer() + prefixLength;
 147 }
 148
 149 // -------------------------------------------------------------------------------------------------------------------
 150
 151 BridgeRtClientControl::BridgeRtClientControl() noexcept
 152     : data(nullptr),
 153       filename(),
 154       needsSemDestroy(false),
 155       isServer(false)
 156 {
 157     carla_zeroChars(shm, 64);
 158     jackbridge_shm_init(shm);
 159 }
 160
 161 BridgeRtClientControl::~BridgeRtClientControl() noexcept
 162 {
 163     // should be cleared by now
 164     CARLA_SAFE_ASSERT(data == nullptr);
 165
 166     clear();
 167 }
 168
 169 bool BridgeRtClientControl::initializeServer() noexcept
 170 {
 171     char tmpFileBase[64] = {};
 172     std::snprintf(tmpFileBase, sizeof(tmpFileBase)-1, PLUGIN_BRIDGE_NAMEPREFIX_RT_CLIENT "XXXXXX");
 173
 174     const carla_shm_t shm2 = carla_shm_create_temp(tmpFileBase);
 175     CARLA_SAFE_ASSERT_RETURN(carla_is_shm_valid(shm2), false);
 176
 177     void* const shmptr = shm;
 178     carla_shm_t& shm1  = *(carla_shm_t*)shmptr;
 179     carla_copyStruct(shm1, shm2);
 180
 181     filename = tmpFileBase;
 182     isServer = true;
 183
 184     if (! mapData())
 185     {
 186         jackbridge_shm_close(shm);
 187         jackbridge_shm_init(shm);
 188         return false;
 189     }
 190
 191     CARLA_SAFE_ASSERT(data != nullptr);
 192
 193     if (! jackbridge_sem_init(&data->sem.server))
 194     {
 195         unmapData();
 196         jackbridge_shm_close(shm);
 197         jackbridge_shm_init(shm);
 198         return false;
 199     }
 200
 201     if (! jackbridge_sem_init(&data->sem.client))
 202     {
 203         jackbridge_sem_destroy(&data->sem.server);
 204         unmapData();
 205         jackbridge_shm_close(shm);
 206         jackbridge_shm_init(shm);
 207         return false;
 208     }
 209
 210     needsSemDestroy = true;
 211     return true;
 212 }
 213
 214 bool BridgeRtClientControl::attachClient(const char* const basename) noexcept
 215 {
 216     CARLA_SAFE_ASSERT_RETURN(basename != nullptr && basename[0] != '\0', false);
 217
 218     // must be invalid right now
 219     CARLA_SAFE_ASSERT_RETURN(! jackbridge_shm_is_valid(shm), false);
 220
 221     filename  = PLUGIN_BRIDGE_NAMEPREFIX_RT_CLIENT;
 222     filename += basename;
 223
 224     jackbridge_shm_attach(shm, filename);
 225
 226     return jackbridge_shm_is_valid(shm);
 227 }
 228
 229 void BridgeRtClientControl::clear() noexcept
 230 {
 231     filename.clear();
 232
 233     if (needsSemDestroy)
 234     {
 235         jackbridge_sem_destroy(&data->sem.client);
 236         jackbridge_sem_destroy(&data->sem.server);
 237         needsSemDestroy = false;
 238     }
 239
 240     if (data != nullptr)
 241         unmapData();
 242
 243     if (! jackbridge_shm_is_valid(shm))
 244         return;
 245
 246     jackbridge_shm_close(shm);
 247     jackbridge_shm_init(shm);
 248 }
 249
 250 bool BridgeRtClientControl::mapData() noexcept
 251 {
 252     CARLA_SAFE_ASSERT(data == nullptr);
 253
 254     if (! jackbridge_shm_map2<BridgeRtClientData>(shm, data))
 255         return false;
 256
 257     if (isServer)
 258     {
 259         std::memset(data, 0, sizeof(BridgeRtClientData));
 260         setRingBuffer(&data->ringBuffer, true);
 261     }
 262     else
 263     {
 264         CARLA_SAFE_ASSERT(data->midiOut[0] == 0);
 265         setRingBuffer(&data->ringBuffer, false);
 266
 267         CARLA_SAFE_ASSERT_RETURN(jackbridge_sem_connect(&data->sem.server), false);
 268         CARLA_SAFE_ASSERT_RETURN(jackbridge_sem_connect(&data->sem.client), false);
 269     }
 270
 271     return true;
 272 }
 273
 274 void BridgeRtClientControl::unmapData() noexcept
 275 {
 276     if (isServer)
 277     {
 278         CARLA_SAFE_ASSERT_RETURN(data != nullptr,);
 279         jackbridge_shm_unmap(shm, data);
 280     }
 281
 282     data = nullptr;
 283     setRingBuffer(nullptr, false);
 284 }
 285
 286 bool BridgeRtClientControl::waitForClient(const uint msecs) noexcept
 287 {
 288     CARLA_SAFE_ASSERT_RETURN(msecs > 0, false);
 289     CARLA_SAFE_ASSERT_RETURN(data != nullptr, false);
 290     CARLA_SAFE_ASSERT_RETURN(isServer, false);
 291
 292     jackbridge_sem_post(&data->sem.server, true);
 293
 294     return jackbridge_sem_timedwait(&data->sem.client, msecs, true);
 295 }
 296
 297 bool BridgeRtClientControl::writeOpcode(const PluginBridgeRtClientOpcode opcode) noexcept
 298 {
 299     return writeUInt(static_cast<uint32_t>(opcode));
 300 }
 301
 302 PluginBridgeRtClientOpcode BridgeRtClientControl::readOpcode() noexcept
 303 {
 304     CARLA_SAFE_ASSERT_RETURN(! isServer, kPluginBridgeRtClientNull);
 305
 306     return static_cast<PluginBridgeRtClientOpcode>(readUInt());
 307 }
 308
 309 BridgeRtClientControl::WaitHelper::WaitHelper(BridgeRtClientControl& c) noexcept
 310     : data(c.data),
 311       ok(jackbridge_sem_timedwait(&data->sem.server, 5000, false)) {}
 312
 313 BridgeRtClientControl::WaitHelper::~WaitHelper() noexcept
 314 {
 315     if (ok)
 316         jackbridge_sem_post(&data->sem.client, false);
 317 }
 318
 319 // -------------------------------------------------------------------------------------------------------------------
 320
 321 BridgeNonRtClientControl::BridgeNonRtClientControl() noexcept
 322     : data(nullptr),
 323       filename(),
 324       mutex(),
 325       isServer(false)
 326 {
 327     carla_zeroChars(shm, 64);
 328     jackbridge_shm_init(shm);
 329 }
 330
 331 BridgeNonRtClientControl::~BridgeNonRtClientControl() noexcept
 332 {
 333     // should be cleared by now
 334     CARLA_SAFE_ASSERT(data == nullptr);
 335
 336     clear();
 337 }
 338
 339 bool BridgeNonRtClientControl::initializeServer() noexcept
 340 {
 341     char tmpFileBase[64] = {};
 342     std::snprintf(tmpFileBase, sizeof(tmpFileBase)-1, PLUGIN_BRIDGE_NAMEPREFIX_NON_RT_CLIENT "XXXXXX");
 343
 344     const carla_shm_t shm2 = carla_shm_create_temp(tmpFileBase);
 345     CARLA_SAFE_ASSERT_RETURN(carla_is_shm_valid(shm2), false);
 346
 347     void* const shmptr = shm;
 348     carla_shm_t& shm1  = *(carla_shm_t*)shmptr;
 349     carla_copyStruct(shm1, shm2);
 350
 351     filename = tmpFileBase;
 352     isServer = true;
 353
 354     if (! mapData())
 355     {
 356         jackbridge_shm_close(shm);
 357         jackbridge_shm_init(shm);
 358         return false;
 359     }
 360
 361     CARLA_SAFE_ASSERT(data != nullptr);
 362     return true;
 363 }
 364
 365 bool BridgeNonRtClientControl::attachClient(const char* const basename) noexcept
 366 {
 367     CARLA_SAFE_ASSERT_RETURN(basename != nullptr && basename[0] != '\0', false);
 368
 369     // must be invalid right now
 370     CARLA_SAFE_ASSERT_RETURN(! jackbridge_shm_is_valid(shm), false);
 371
 372     filename  = PLUGIN_BRIDGE_NAMEPREFIX_NON_RT_CLIENT;
 373     filename += basename;
 374
 375     jackbridge_shm_attach(shm, filename);
 376
 377     return jackbridge_shm_is_valid(shm);
 378 }
 379
 380 void BridgeNonRtClientControl::clear() noexcept
 381 {
 382     filename.clear();
 383
 384     if (data != nullptr)
 385         unmapData();
 386
 387     if (! jackbridge_shm_is_valid(shm))
 388     {
 389         if (! isServer) {
 390             CARLA_SAFE_ASSERT(data == nullptr);
 391         }
 392         return;
 393     }
 394
 395     jackbridge_shm_close(shm);
 396     jackbridge_shm_init(shm);
 397 }
 398
 399 bool BridgeNonRtClientControl::mapData() noexcept
 400 {
 401     CARLA_SAFE_ASSERT(data == nullptr);
 402
 403     if (jackbridge_shm_map2<BridgeNonRtClientData>(shm, data))
 404     {
 405         setRingBuffer(&data->ringBuffer, isServer);
 406         return true;
 407     }
 408
 409     return false;
 410 }
 411
 412 void BridgeNonRtClientControl::unmapData() noexcept
 413 {
 414     if (isServer)
 415     {
 416         CARLA_SAFE_ASSERT_RETURN(data != nullptr,);
 417         jackbridge_shm_unmap(shm, data);
 418     }
 419
 420     data = nullptr;
 421     setRingBuffer(nullptr, false);
 422 }
 423
 424 void BridgeNonRtClientControl::waitIfDataIsReachingLimit() noexcept
 425 {
 426     CARLA_SAFE_ASSERT_RETURN(isServer,);
 427
 428     if (getWritableDataSize() < BigStackBuffer::size/4)
 429         return;
 430
 431     for (int i=50; --i >= 0;)
 432     {
 433         if (getWritableDataSize() >= BigStackBuffer::size*3/4)
 434         {
 435             writeOpcode(kPluginBridgeNonRtClientPing);
 436             commitWrite();
 437             return;
 438         }
 439         carla_msleep(20);
 440     }
 441
 442     carla_stderr("Server waitIfDataIsReachingLimit() reached and failed");
 443 }
 444
 445 bool BridgeNonRtClientControl::writeOpcode(const PluginBridgeNonRtClientOpcode opcode) noexcept
 446 {
 447     CARLA_SAFE_ASSERT_RETURN(isServer, false);
 448
 449     return writeUInt(static_cast<uint32_t>(opcode));
 450 }
 451
 452 PluginBridgeNonRtClientOpcode BridgeNonRtClientControl::readOpcode() noexcept
 453 {
 454     CARLA_SAFE_ASSERT_RETURN(! isServer, kPluginBridgeNonRtClientNull);
 455
 456     return static_cast<PluginBridgeNonRtClientOpcode>(readUInt());
 457 }
 458
 459 // -------------------------------------------------------------------------------------------------------------------
 460
 461 BridgeNonRtServerControl::BridgeNonRtServerControl() noexcept
 462     : data(nullptr),
 463       filename(),
 464       mutex(),
 465       isServer(false)
 466 {
 467     carla_zeroChars(shm, 64);
 468     jackbridge_shm_init(shm);
 469 }
 470
 471 BridgeNonRtServerControl::~BridgeNonRtServerControl() noexcept
 472 {
 473     // should be cleared by now
 474     CARLA_SAFE_ASSERT(data == nullptr);
 475
 476     clear();
 477 }
 478
 479 bool BridgeNonRtServerControl::initializeServer() noexcept
 480 {
 481     char tmpFileBase[64] = {};
 482     std::snprintf(tmpFileBase, sizeof(tmpFileBase)-1, PLUGIN_BRIDGE_NAMEPREFIX_NON_RT_SERVER "XXXXXX");
 483
 484     const carla_shm_t shm2 = carla_shm_create_temp(tmpFileBase);
 485     CARLA_SAFE_ASSERT_RETURN(carla_is_shm_valid(shm2), false);
 486
 487     void* const shmptr = shm;
 488     carla_shm_t& shm1  = *(carla_shm_t*)shmptr;
 489     carla_copyStruct(shm1, shm2);
 490
 491     filename = tmpFileBase;
 492     isServer = true;
 493
 494     if (! mapData())
 495     {
 496         jackbridge_shm_close(shm);
 497         jackbridge_shm_init(shm);
 498         return false;
 499     }
 500
 501     CARLA_SAFE_ASSERT(data != nullptr);
 502     return true;
 503 }
 504
 505 bool BridgeNonRtServerControl::attachClient(const char* const basename) noexcept
 506 {
 507     CARLA_SAFE_ASSERT_RETURN(basename != nullptr && basename[0] != '\0', false);
 508
 509     // must be invalid right now
 510     CARLA_SAFE_ASSERT_RETURN(! jackbridge_shm_is_valid(shm), false);
 511
 512     filename  = PLUGIN_BRIDGE_NAMEPREFIX_NON_RT_SERVER;
 513     filename += basename;
 514
 515     jackbridge_shm_attach(shm, filename);
 516
 517     return jackbridge_shm_is_valid(shm);
 518 }
 519
 520 void BridgeNonRtServerControl::clear() noexcept
 521 {
 522     filename.clear();
 523
 524     if (data != nullptr)
 525         unmapData();
 526
 527     if (! jackbridge_shm_is_valid(shm))
 528     {
 529         CARLA_SAFE_ASSERT(data == nullptr);
 530         return;
 531     }
 532
 533     jackbridge_shm_close(shm);
 534     jackbridge_shm_init(shm);
 535 }
 536
 537 bool BridgeNonRtServerControl::mapData() noexcept
 538 {
 539     CARLA_SAFE_ASSERT(data == nullptr);
 540
 541     if (jackbridge_shm_map2<BridgeNonRtServerData>(shm, data))
 542     {
 543         setRingBuffer(&data->ringBuffer, isServer);
 544         return true;
 545     }
 546
 547     return false;
 548 }
 549
 550 void BridgeNonRtServerControl::unmapData() noexcept
 551 {
 552     if (isServer)
 553     {
 554         CARLA_SAFE_ASSERT_RETURN(data != nullptr,);
 555         jackbridge_shm_unmap(shm, data);
 556     }
 557
 558     data = nullptr;
 559     setRingBuffer(nullptr, false);
 560 }
 561
 562 PluginBridgeNonRtServerOpcode BridgeNonRtServerControl::readOpcode() noexcept
 563 {
 564     CARLA_SAFE_ASSERT_RETURN(isServer, kPluginBridgeNonRtServerNull);
 565
 566     return static_cast<PluginBridgeNonRtServerOpcode>(readUInt());
 567 }
 568
 569 void BridgeNonRtServerControl::waitIfDataIsReachingLimit() noexcept
 570 {
 571     CARLA_SAFE_ASSERT_RETURN(! isServer,);
 572
 573     if (getWritableDataSize() < HugeStackBuffer::size/4)
 574         return;
 575
 576     for (int i=50; --i >= 0;)
 577     {
 578         if (getWritableDataSize() >= HugeStackBuffer::size*3/4)
 579         {
 580             writeOpcode(kPluginBridgeNonRtServerPong);
 581             commitWrite();
 582             return;
 583         }
 584         carla_msleep(20);
 585     }
 586
 587     carla_stderr("Client waitIfDataIsReachingLimit() reached and failed");
 588 }
 589
 590 bool BridgeNonRtServerControl::writeOpcode(const PluginBridgeNonRtServerOpcode opcode) noexcept
 591 {
 592     CARLA_SAFE_ASSERT_RETURN(! isServer, false);
 593
 594     return writeUInt(static_cast<uint32_t>(opcode));
 595 }
 596
 597 // -------------------------------------------------------------------------------------------------------------------