source/backend/plugin/CarlaPluginInternal.cpp

   1 /*
   2  * Carla Plugin
   3  * Copyright (C) 2011-2020 Filipe Coelho <falktx@falktx.com>
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License as
   7  * published by the Free Software Foundation; either version 2 of
   8  * the License, or any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13  * GNU General Public License for more details.
  14  *
  15  * For a full copy of the GNU General Public License see the doc/GPL.txt file.
  16  */
  17
  18 #include "CarlaPluginInternal.hpp"
  19 #include "CarlaEngine.hpp"
  20
  21 #include "CarlaLibCounter.hpp"
  22 #include "CarlaMathUtils.hpp"
  23 #include "CarlaMIDI.h"
  24
  25 CARLA_BACKEND_START_NAMESPACE
  26
  27 // -------------------------------------------------------------------
  28 // Fallback data
  29
  30 static const MidiProgramData kMidiProgramDataNull  = { 0, 0, nullptr };
  31 static /* */ CustomData      kCustomDataFallbackNC = { nullptr, nullptr, nullptr };
  32
  33 // -----------------------------------------------------------------------
  34 // PluginAudioData
  35
  36 PluginAudioData::PluginAudioData() noexcept
  37     : count(0),
  38       ports(nullptr) {}
  39
  40 PluginAudioData::~PluginAudioData() noexcept
  41 {
  42     CARLA_SAFE_ASSERT_INT(count == 0, count);
  43     CARLA_SAFE_ASSERT(ports == nullptr);
  44 }
  45
  46 void PluginAudioData::createNew(const uint32_t newCount)
  47 {
  48     CARLA_SAFE_ASSERT_INT(count == 0, count);
  49     CARLA_SAFE_ASSERT_RETURN(ports == nullptr,);
  50     CARLA_SAFE_ASSERT_RETURN(newCount > 0,);
  51
  52     ports = new PluginAudioPort[newCount];
  53     carla_zeroStructs(ports, newCount);
  54
  55     count = newCount;
  56 }
  57
  58 void PluginAudioData::clear() noexcept
  59 {
  60     if (ports != nullptr)
  61     {
  62         for (uint32_t i=0; i < count; ++i)
  63         {
  64             if (ports[i].port != nullptr)
  65             {
  66                 delete ports[i].port;
  67                 ports[i].port = nullptr;
  68             }
  69         }
  70
  71         delete[] ports;
  72         ports = nullptr;
  73     }
  74
  75     count = 0;
  76 }
  77
  78 void PluginAudioData::initBuffers() const noexcept
  79 {
  80     for (uint32_t i=0; i < count; ++i)
  81     {
  82         if (ports[i].port != nullptr)
  83             ports[i].port->initBuffer();
  84     }
  85 }
  86
  87 // -----------------------------------------------------------------------
  88 // PluginCVData
  89
  90 PluginCVData::PluginCVData() noexcept
  91     : count(0),
  92       ports(nullptr) {}
  93
  94 PluginCVData::~PluginCVData() noexcept
  95 {
  96     CARLA_SAFE_ASSERT_INT(count == 0, count);
  97     CARLA_SAFE_ASSERT(ports == nullptr);
  98 }
  99
 100 void PluginCVData::createNew(const uint32_t newCount)
 101 {
 102     CARLA_SAFE_ASSERT_INT(count == 0, count);
 103     CARLA_SAFE_ASSERT_RETURN(ports == nullptr,);
 104     CARLA_SAFE_ASSERT_RETURN(newCount > 0,);
 105
 106     ports = new PluginCVPort[newCount];
 107     carla_zeroStructs(ports, newCount);
 108
 109     count = newCount;
 110 }
 111
 112 void PluginCVData::clear() noexcept
 113 {
 114     if (ports != nullptr)
 115     {
 116         for (uint32_t i=0; i < count; ++i)
 117         {
 118             if (ports[i].port != nullptr)
 119             {
 120                 delete ports[i].port;
 121                 ports[i].port = nullptr;
 122             }
 123         }
 124
 125         delete[] ports;
 126         ports = nullptr;
 127     }
 128
 129     count = 0;
 130 }
 131
 132 void PluginCVData::initBuffers() const noexcept
 133 {
 134     for (uint32_t i=0; i < count; ++i)
 135     {
 136         if (ports[i].port != nullptr)
 137             ports[i].port->initBuffer();
 138     }
 139 }
 140
 141 // -----------------------------------------------------------------------
 142 // PluginEventData
 143
 144 PluginEventData::PluginEventData() noexcept
 145     : portIn(nullptr),
 146       portOut(nullptr)
 147 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
 148     , cvSourcePorts(nullptr)
 149 #endif
 150     {
 151     }
 152
 153 PluginEventData::~PluginEventData() noexcept
 154 {
 155     CARLA_SAFE_ASSERT(portIn == nullptr);
 156     CARLA_SAFE_ASSERT(portOut == nullptr);
 157 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
 158     CARLA_SAFE_ASSERT(cvSourcePorts == nullptr);
 159 #endif
 160 }
 161
 162 void PluginEventData::clear() noexcept
 163 {
 164     if (portIn != nullptr)
 165     {
 166         delete portIn;
 167         portIn = nullptr;
 168     }
 169
 170     if (portOut != nullptr)
 171     {
 172         delete portOut;
 173         portOut = nullptr;
 174     }
 175
 176 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
 177     if (cvSourcePorts != nullptr)
 178     {
 179         cvSourcePorts->cleanup();
 180         cvSourcePorts = nullptr;
 181     }
 182 #endif
 183 }
 184
 185 void PluginEventData::initBuffers() const noexcept
 186 {
 187     if (portIn != nullptr)
 188         portIn->initBuffer();
 189
 190     if (portOut != nullptr)
 191         portOut->initBuffer();
 192 }
 193
 194 // -----------------------------------------------------------------------
 195 // PluginParameterData
 196
 197 PluginParameterData::PluginParameterData() noexcept
 198     : count(0),
 199       data(nullptr),
 200       ranges(nullptr),
 201       special(nullptr) {}
 202
 203 PluginParameterData::~PluginParameterData() noexcept
 204 {
 205     CARLA_SAFE_ASSERT_INT(count == 0, count);
 206     CARLA_SAFE_ASSERT(data == nullptr);
 207     CARLA_SAFE_ASSERT(ranges == nullptr);
 208     CARLA_SAFE_ASSERT(special == nullptr);
 209 }
 210
 211 void PluginParameterData::createNew(const uint32_t newCount, const bool withSpecial)
 212 {
 213     CARLA_SAFE_ASSERT_INT(count == 0, count);
 214     CARLA_SAFE_ASSERT_RETURN(data == nullptr,);
 215     CARLA_SAFE_ASSERT_RETURN(ranges == nullptr,);
 216     CARLA_SAFE_ASSERT_RETURN(special == nullptr,);
 217     CARLA_SAFE_ASSERT_RETURN(newCount > 0,);
 218
 219     data = new ParameterData[newCount];
 220     carla_zeroStructs(data, newCount);
 221
 222     for (uint32_t i=0; i < newCount; ++i)
 223     {
 224         data[i].index  = PARAMETER_NULL;
 225         data[i].rindex = PARAMETER_NULL;
 226         data[i].mappedControlIndex = CONTROL_INDEX_NONE;
 227         data[i].mappedMinimum = -1.0f;
 228         data[i].mappedMaximum = 1.0f;
 229     }
 230
 231     ranges = new ParameterRanges[newCount];
 232     carla_zeroStructs(ranges, newCount);
 233
 234     if (withSpecial)
 235     {
 236         special = new SpecialParameterType[newCount];
 237         carla_zeroStructs(special, newCount);
 238     }
 239
 240     count = newCount;
 241 }
 242
 243 void PluginParameterData::clear() noexcept
 244 {
 245     if (data != nullptr)
 246     {
 247         delete[] data;
 248         data = nullptr;
 249     }
 250
 251     if (ranges != nullptr)
 252     {
 253         delete[] ranges;
 254         ranges = nullptr;
 255     }
 256
 257     if (special != nullptr)
 258     {
 259         delete[] special;
 260         special = nullptr;
 261     }
 262
 263     count = 0;
 264 }
 265
 266 float PluginParameterData::getFixedValue(const uint32_t parameterId, float value) const noexcept
 267 {
 268     CARLA_SAFE_ASSERT_RETURN(parameterId < count, 0.0f);
 269
 270     const uint             paramHints (data[parameterId].hints);
 271     const ParameterRanges& paramRanges(ranges[parameterId]);
 272
 273     // if boolean, return either min or max
 274     if (paramHints & PARAMETER_IS_BOOLEAN)
 275     {
 276         const float middlePoint = paramRanges.min + (paramRanges.max-paramRanges.min)/2.0f;
 277         return value >= middlePoint ? paramRanges.max : paramRanges.min;
 278     }
 279
 280     // if integer, round first
 281     if (paramHints & PARAMETER_IS_INTEGER)
 282         return paramRanges.getFixedValue(std::round(value));
 283
 284     // normal mode
 285     return paramRanges.getFixedValue(value);
 286 }
 287
 288 // copied from ParameterRanges::getUnnormalizedValue
 289 static float _getUnnormalizedValue(const float min, const float max, const float value) noexcept
 290 {
 291     if (value <= 0.0f)
 292         return min;
 293     if (value >= 1.0f)
 294         return max;
 295
 296     return value * (max - min) + min;
 297 }
 298
 299 // copied from ParameterRanges::getUnnormalizedLogValue
 300 static float _getUnnormalizedLogValue(const float min, const float max, const float value) noexcept
 301 {
 302     if (value <= 0.0f)
 303         return min;
 304     if (value >= 1.0f)
 305         return max;
 306
 307     float rmin = min;
 308
 309     if (std::abs(min) < std::numeric_limits<float>::epsilon())
 310         rmin = 0.00001f;
 311
 312     return rmin * std::pow(max/rmin, value);
 313 }
 314
 315 float PluginParameterData::getFinalUnnormalizedValue(const uint32_t parameterId,
 316                                                      const float normalizedValue) const noexcept
 317 {
 318     float min, max, value;
 319
 320     if (data[parameterId].mappedControlIndex != CONTROL_INDEX_CV
 321         && (data[parameterId].hints & PARAMETER_MAPPED_RANGES_SET) != 0x0)
 322     {
 323         min = data[parameterId].mappedMinimum;
 324         max = data[parameterId].mappedMaximum;
 325     }
 326     else
 327     {
 328         min = ranges[parameterId].min;
 329         max = ranges[parameterId].max;
 330     }
 331
 332     if (data[parameterId].hints & PARAMETER_IS_BOOLEAN)
 333     {
 334         value = (normalizedValue < 0.5f) ? min : max;
 335     }
 336     else
 337     {
 338         if (data[parameterId].hints & PARAMETER_IS_LOGARITHMIC)
 339             value = _getUnnormalizedLogValue(min, max, normalizedValue);
 340         else
 341             value = _getUnnormalizedValue(min, max, normalizedValue);
 342
 343         if (data[parameterId].hints & PARAMETER_IS_INTEGER)
 344             value = std::rint(value);
 345     }
 346
 347     return value;
 348 }
 349
 350 float PluginParameterData::getFinalValueWithMidiDelta(const uint32_t parameterId,
 351                                                       float value, int8_t delta) const noexcept
 352 {
 353     if (delta < 0)
 354         return value;
 355     if (data[parameterId].mappedControlIndex <= 0 || data[parameterId].mappedControlIndex >= MAX_MIDI_CONTROL)
 356         return value;
 357
 358     float min, max;
 359
 360     if ((data[parameterId].hints & PARAMETER_MAPPED_RANGES_SET) != 0x0)
 361     {
 362         min = data[parameterId].mappedMinimum;
 363         max = data[parameterId].mappedMaximum;
 364     }
 365     else
 366     {
 367         min = ranges[parameterId].min;
 368         max = ranges[parameterId].max;
 369     }
 370
 371     if (data[parameterId].hints & PARAMETER_IS_BOOLEAN)
 372     {
 373         value = delta > 63 ? min : max;
 374     }
 375     else
 376     {
 377         if (data[parameterId].hints & PARAMETER_IS_INTEGER)
 378         {
 379             if (delta > 63)
 380                 value += delta - 128.0f;
 381             else
 382                 value += delta;
 383         }
 384         else
 385         {
 386             if (delta > 63)
 387                 delta = static_cast<int8_t>(delta - 128);
 388
 389             value += (max - min) * (static_cast<float>(delta) / 127.0f);
 390         }
 391
 392         if (value < min)
 393             value = min;
 394         else if (value > max)
 395             value = max;
 396     }
 397
 398     return value;
 399 }
 400
 401 // -----------------------------------------------------------------------
 402 // PluginProgramData
 403
 404 PluginProgramData::PluginProgramData() noexcept
 405     : count(0),
 406       current(-1),
 407       names(nullptr) {}
 408
 409 PluginProgramData::~PluginProgramData() noexcept
 410 {
 411     CARLA_SAFE_ASSERT_INT(count == 0, count);
 412     CARLA_SAFE_ASSERT_INT(current == -1, current);
 413     CARLA_SAFE_ASSERT(names == nullptr);
 414 }
 415
 416 void PluginProgramData::createNew(const uint32_t newCount)
 417 {
 418     CARLA_SAFE_ASSERT_INT(count == 0, count);
 419     CARLA_SAFE_ASSERT_INT(current == -1, current);
 420     CARLA_SAFE_ASSERT_RETURN(names == nullptr,);
 421     CARLA_SAFE_ASSERT_RETURN(newCount > 0,);
 422
 423     names = new ProgramName[newCount];
 424     carla_zeroStructs(names, newCount);
 425
 426     count   = newCount;
 427     current = -1;
 428 }
 429
 430 void PluginProgramData::clear() noexcept
 431 {
 432     if (names != nullptr)
 433     {
 434         for (uint32_t i=0; i < count; ++i)
 435         {
 436             if (names[i] != nullptr)
 437             {
 438                 delete[] names[i];
 439                 names[i] = nullptr;
 440             }
 441         }
 442
 443         delete[] names;
 444         names = nullptr;
 445     }
 446
 447     count   = 0;
 448     current = -1;
 449 }
 450
 451 // -----------------------------------------------------------------------
 452 // PluginMidiProgramData
 453
 454 PluginMidiProgramData::PluginMidiProgramData() noexcept
 455     : count(0),
 456       current(-1),
 457       data(nullptr) {}
 458
 459 PluginMidiProgramData::~PluginMidiProgramData() noexcept
 460 {
 461     CARLA_SAFE_ASSERT_INT(count == 0, count);
 462     CARLA_SAFE_ASSERT_INT(current == -1, current);
 463     CARLA_SAFE_ASSERT(data == nullptr);
 464 }
 465
 466 void PluginMidiProgramData::createNew(const uint32_t newCount)
 467 {
 468     CARLA_SAFE_ASSERT_INT(count == 0, count);
 469     CARLA_SAFE_ASSERT_INT(current == -1, current);
 470     CARLA_SAFE_ASSERT_RETURN(data == nullptr,);
 471     CARLA_SAFE_ASSERT_RETURN(newCount > 0,);
 472
 473     data = new MidiProgramData[newCount];
 474     carla_zeroStructs(data, newCount);
 475
 476     count   = newCount;
 477     current = -1;
 478 }
 479
 480 void PluginMidiProgramData::clear() noexcept
 481 {
 482     if (data != nullptr)
 483     {
 484         for (uint32_t i=0; i < count; ++i)
 485         {
 486             if (data[i].name != nullptr)
 487             {
 488                 delete[] data[i].name;
 489                 data[i].name = nullptr;
 490             }
 491         }
 492
 493         delete[] data;
 494         data = nullptr;
 495     }
 496
 497     count   = 0;
 498     current = -1;
 499 }
 500
 501 const MidiProgramData& PluginMidiProgramData::getCurrent() const noexcept
 502 {
 503     CARLA_SAFE_ASSERT_RETURN(current >= 0 && current < static_cast<int32_t>(count), kMidiProgramDataNull);
 504     return data[current];
 505 }
 506
 507 // -----------------------------------------------------------------------
 508 // ProtectedData::ExternalNotes
 509
 510 CarlaPlugin::ProtectedData::ExternalNotes::ExternalNotes() noexcept
 511     : mutex(),
 512       dataPool("CarlaPlugin::ProtectedData::ExternalNotes", 32, 152),
 513       data(dataPool) {}
 514
 515 CarlaPlugin::ProtectedData::ExternalNotes::~ExternalNotes() noexcept
 516 {
 517     clear();
 518 }
 519
 520 void CarlaPlugin::ProtectedData::ExternalNotes::appendNonRT(const ExternalMidiNote& note) noexcept
 521 {
 522     mutex.lock();
 523     data.append_sleepy(note);
 524     mutex.unlock();
 525 }
 526
 527 void CarlaPlugin::ProtectedData::ExternalNotes::clear() noexcept
 528 {
 529     mutex.lock();
 530     data.clear();
 531     mutex.unlock();
 532 }
 533
 534 // -----------------------------------------------------------------------
 535 // ProtectedData::Latency
 536
 537 CarlaPlugin::ProtectedData::Latency::Latency() noexcept
 538 #ifdef BUILD_BRIDGE
 539     : frames(0) {}
 540 #else
 541     : frames(0),
 542       channels(0),
 543       buffers(nullptr) {}
 544 #endif
 545
 546 #ifndef BUILD_BRIDGE
 547 CarlaPlugin::ProtectedData::Latency::~Latency() noexcept
 548 {
 549     clearBuffers();
 550 }
 551
 552 void CarlaPlugin::ProtectedData::Latency::clearBuffers() noexcept
 553 {
 554     if (buffers != nullptr)
 555     {
 556         for (uint32_t i=0; i < channels; ++i)
 557         {
 558             CARLA_SAFE_ASSERT_CONTINUE(buffers[i] != nullptr);
 559
 560             delete[] buffers[i];
 561             buffers[i] = nullptr;
 562         }
 563
 564         delete[] buffers;
 565         buffers = nullptr;
 566     }
 567
 568     channels = 0;
 569     frames   = 0;
 570 }
 571
 572 void CarlaPlugin::ProtectedData::Latency::recreateBuffers(const uint32_t newChannels, const uint32_t newFrames)
 573 {
 574     CARLA_SAFE_ASSERT_RETURN(channels != newChannels || frames != newFrames,);
 575
 576     const bool retrieveOldBuffer = (channels == newChannels && channels > 0 && frames > 0 && newFrames > 0);
 577     float** const oldBuffers = buffers;
 578     const uint32_t oldFrames = frames;
 579
 580     channels = newChannels;
 581     frames   = newFrames;
 582
 583     if (channels > 0 && frames > 0)
 584     {
 585         buffers = new float*[channels];
 586
 587         for (uint32_t i=0; i < channels; ++i)
 588         {
 589             buffers[i] = new float[frames];
 590
 591             if (retrieveOldBuffer)
 592             {
 593                 if (oldFrames > frames)
 594                 {
 595                     const uint32_t diff = oldFrames - frames;
 596                     carla_copyFloats(buffers[i], oldBuffers[i] + diff, frames);
 597                 }
 598                 else
 599                 {
 600                     const uint32_t diff = frames - oldFrames;
 601                     carla_zeroFloats(buffers[i], diff);
 602                     carla_copyFloats(buffers[i] + diff, oldBuffers[i], oldFrames);
 603                 }
 604             }
 605             else
 606             {
 607                 carla_zeroFloats(buffers[i], frames);
 608             }
 609         }
 610     }
 611     else
 612     {
 613         buffers = nullptr;
 614     }
 615
 616     // delete old buffer
 617     if (oldBuffers != nullptr)
 618     {
 619         for (uint32_t i=0; i < channels; ++i)
 620         {
 621             CARLA_SAFE_ASSERT_CONTINUE(oldBuffers[i] != nullptr);
 622
 623             delete[] oldBuffers[i];
 624             oldBuffers[i] = nullptr;
 625         }
 626
 627         delete[] oldBuffers;
 628     }
 629 }
 630 #endif
 631
 632 // -----------------------------------------------------------------------
 633 // ProtectedData::PostRtEvents
 634
 635 CarlaPlugin::ProtectedData::PostRtEvents::PostRtEvents() noexcept
 636     : dataPool("CarlaPlugin::ProtectedData::PostRtEvents", 512, 512),
 637       data(dataPool),
 638       dataPendingRT(dataPool),
 639       dataMutex(),
 640       dataPendingMutex(),
 641       poolMutex() {}
 642
 643 CarlaPlugin::ProtectedData::PostRtEvents::~PostRtEvents() noexcept
 644 {
 645     const CarlaMutexLocker cml1(dataMutex);
 646     const CarlaMutexLocker cml2(dataPendingMutex);
 647     const CarlaMutexLocker cml3(poolMutex);
 648
 649     data.clear();
 650     dataPendingRT.clear();
 651 }
 652
 653 void CarlaPlugin::ProtectedData::PostRtEvents::appendRT(const PluginPostRtEvent& e) noexcept
 654 {
 655     CARLA_SAFE_ASSERT_INT_RETURN(dataPendingMutex.tryLock(), e.type,);
 656     {
 657         const CarlaMutexLocker cml(poolMutex);
 658         dataPendingRT.append(e);
 659     }
 660     dataPendingMutex.unlock();
 661 }
 662
 663 void CarlaPlugin::ProtectedData::PostRtEvents::trySplice() noexcept
 664 {
 665     const CarlaMutexTryLocker cmtl(dataPendingMutex);
 666
 667     if (cmtl.wasLocked() && dataPendingRT.isNotEmpty() && dataMutex.tryLock())
 668     {
 669         {
 670             const CarlaMutexLocker cml(poolMutex);
 671             dataPendingRT.moveTo(data, true);
 672         }
 673         dataMutex.unlock();
 674     }
 675 }
 676
 677 // -----------------------------------------------------------------------
 678 // ProtectedData::PostUiEvents
 679
 680 CarlaPlugin::ProtectedData::PostUiEvents::PostUiEvents() noexcept
 681     : mutex(),
 682       data() {}
 683
 684 CarlaPlugin::ProtectedData::PostUiEvents::~PostUiEvents() noexcept
 685 {
 686     clear();
 687 }
 688
 689 void CarlaPlugin::ProtectedData::PostUiEvents::append(const PluginPostRtEvent& e) noexcept
 690 {
 691     mutex.lock();
 692     data.append(e);
 693     mutex.unlock();
 694 }
 695
 696 void CarlaPlugin::ProtectedData::PostUiEvents::clear() noexcept
 697 {
 698     mutex.lock();
 699     data.clear();
 700     mutex.unlock();
 701 }
 702
 703 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
 704 // -----------------------------------------------------------------------
 705 // ProtectedData::PostProc
 706
 707 CarlaPlugin::ProtectedData::PostProc::PostProc() noexcept
 708     : dryWet(1.0f),
 709       volume(1.0f),
 710       balanceLeft(-1.0f),
 711       balanceRight(1.0f),
 712       panning(0.0f),
 713       extraBuffer(nullptr) {}
 714 #endif
 715
 716 // -----------------------------------------------------------------------
 717
 718 CarlaPlugin::ProtectedData::ProtectedData(CarlaEngine* const eng, const uint idx) noexcept
 719     : engine(eng),
 720       client(nullptr),
 721       id(idx),
 722       hints(0x0),
 723       options(0x0),
 724       nodeId(0),
 725       active(false),
 726       enabled(false),
 727       needsReset(false),
 728       engineBridged(eng->getType() == kEngineTypeBridge),
 729       enginePlugin(eng->getType() == kEngineTypePlugin),
 730       lib(nullptr),
 731       uiLib(nullptr),
 732       ctrlChannel(0),
 733       extraHints(0x0),
 734 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
 735       midiLearnParameterIndex(-1),
 736       transientTryCounter(0),
 737       transientFirstTry(true),
 738 #endif
 739       name(nullptr),
 740       filename(nullptr),
 741       iconName(nullptr),
 742       audioIn(),
 743       audioOut(),
 744       cvIn(),
 745       cvOut(),
 746       event(),
 747       param(),
 748       prog(),
 749       midiprog(),
 750       custom(),
 751       masterMutex(),
 752       singleMutex(),
 753       stateSave(),
 754       uiTitle(),
 755       extNotes(),
 756       latency(),
 757       postRtEvents(),
 758       postUiEvents()
 759 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
 760     , postProc()
 761 #endif
 762       {}
 763
 764 CarlaPlugin::ProtectedData::~ProtectedData() noexcept
 765 {
 766     CARLA_SAFE_ASSERT(! (active && needsReset));
 767 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
 768     CARLA_SAFE_ASSERT(transientTryCounter == 0);
 769 #endif
 770
 771     {
 772         // mutex MUST have been locked before
 773         const bool lockMaster(masterMutex.tryLock());
 774         const bool lockSingle(singleMutex.tryLock());
 775         CARLA_SAFE_ASSERT(! lockMaster);
 776         CARLA_SAFE_ASSERT(! lockSingle);
 777     }
 778
 779     if (client != nullptr)
 780     {
 781         if (client->isActive())
 782         {
 783             // must not happen
 784             carla_safe_assert("client->isActive()", __FILE__, __LINE__);
 785             client->deactivate(true);
 786         }
 787
 788         clearBuffers();
 789
 790         delete client;
 791         client = nullptr;
 792     }
 793
 794     if (name != nullptr)
 795     {
 796         delete[] name;
 797         name = nullptr;
 798     }
 799
 800     if (filename != nullptr)
 801     {
 802         delete[] filename;
 803         filename = nullptr;
 804     }
 805
 806     if (iconName != nullptr)
 807     {
 808         delete[] iconName;
 809         iconName = nullptr;
 810     }
 811
 812     for (LinkedList<CustomData>::Itenerator it = custom.begin2(); it.valid(); it.next())
 813     {
 814         CustomData& customData(it.getValue(kCustomDataFallbackNC));
 815         //CARLA_SAFE_ASSERT_CONTINUE(customData.isValid());
 816
 817         if (customData.type != nullptr)
 818         {
 819             delete[] customData.type;
 820             customData.type = nullptr;
 821         }
 822         else
 823             carla_safe_assert("customData.type != nullptr", __FILE__, __LINE__);
 824
 825         if (customData.key != nullptr)
 826         {
 827             delete[] customData.key;
 828             customData.key = nullptr;
 829         }
 830         else
 831             carla_safe_assert("customData.key != nullptr", __FILE__, __LINE__);
 832
 833         if (customData.value != nullptr)
 834         {
 835             delete[] customData.value;
 836             customData.value = nullptr;
 837         }
 838         else
 839             carla_safe_assert("customData.value != nullptr", __FILE__, __LINE__);
 840     }
 841
 842     prog.clear();
 843     midiprog.clear();
 844     custom.clear();
 845
 846     // MUST have been locked before
 847     masterMutex.unlock();
 848     singleMutex.unlock();
 849
 850     CARLA_SAFE_ASSERT(uiLib == nullptr);
 851
 852     if (lib != nullptr)
 853         libClose();
 854 }
 855
 856 // -----------------------------------------------------------------------
 857 // Buffer functions
 858
 859 void CarlaPlugin::ProtectedData::clearBuffers() noexcept
 860 {
 861     audioIn.clear();
 862     audioOut.clear();
 863     cvIn.clear();
 864     cvOut.clear();
 865     param.clear();
 866     event.clear();
 867 #ifndef BUILD_BRIDGE
 868     latency.clearBuffers();
 869 #endif
 870 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
 871     if (postProc.extraBuffer != nullptr)
 872     {
 873         delete[] postProc.extraBuffer;
 874         postProc.extraBuffer = nullptr;
 875     }
 876 #endif
 877 }
 878
 879 // -----------------------------------------------------------------------
 880 // Post-poned events
 881
 882 void CarlaPlugin::ProtectedData::postponeRtEvent(const PluginPostRtEvent& rtEvent) noexcept
 883 {
 884     CARLA_SAFE_ASSERT_RETURN(rtEvent.type != kPluginPostRtEventNull,);
 885
 886     postRtEvents.appendRT(rtEvent);
 887 }
 888
 889 void CarlaPlugin::ProtectedData::postponeParameterChangeRtEvent(const bool sendCallbackLater,
 890                                                                 const int32_t index,
 891                                                                 const float value) noexcept
 892 {
 893     PluginPostRtEvent rtEvent = { kPluginPostRtEventParameterChange, sendCallbackLater, {} };
 894     rtEvent.parameter.index = index;
 895     rtEvent.parameter.value = value;
 896
 897     postRtEvents.appendRT(rtEvent);
 898 }
 899
 900 void CarlaPlugin::ProtectedData::postponeProgramChangeRtEvent(const bool sendCallbackLater,
 901                                                               const uint32_t index) noexcept
 902 {
 903     PluginPostRtEvent rtEvent = { kPluginPostRtEventProgramChange, sendCallbackLater, {} };
 904     rtEvent.program.index = index;
 905
 906     postRtEvents.appendRT(rtEvent);
 907 }
 908
 909 void CarlaPlugin::ProtectedData::postponeMidiProgramChangeRtEvent(const bool sendCallbackLater,
 910                                                                   const uint32_t index) noexcept
 911 {
 912     PluginPostRtEvent rtEvent = { kPluginPostRtEventMidiProgramChange, sendCallbackLater, {} };
 913     rtEvent.program.index = index;
 914
 915     postRtEvents.appendRT(rtEvent);
 916 }
 917
 918 void CarlaPlugin::ProtectedData::postponeNoteOnRtEvent(const bool sendCallbackLater,
 919                                                        const uint8_t channel,
 920                                                        const uint8_t note,
 921                                                        const uint8_t velocity) noexcept
 922 {
 923     PluginPostRtEvent rtEvent = { kPluginPostRtEventNoteOn, sendCallbackLater, {} };
 924     rtEvent.note.channel = channel;
 925     rtEvent.note.note = note;
 926     rtEvent.note.velocity = velocity;
 927
 928     postRtEvents.appendRT(rtEvent);
 929 }
 930 void CarlaPlugin::ProtectedData::postponeNoteOffRtEvent(const bool sendCallbackLater,
 931                                                         const uint8_t channel,
 932                                                         const uint8_t note) noexcept
 933 {
 934     PluginPostRtEvent rtEvent = { kPluginPostRtEventNoteOff, sendCallbackLater, {} };
 935     rtEvent.note.channel = channel;
 936     rtEvent.note.note = note;
 937
 938     postRtEvents.appendRT(rtEvent);
 939 }
 940 void CarlaPlugin::ProtectedData::postponeMidiLearnRtEvent(const bool sendCallbackLater,
 941                                                           const uint32_t parameter,
 942                                                           const uint8_t cc,
 943                                                           const uint8_t channel) noexcept
 944 {
 945     PluginPostRtEvent rtEvent = { kPluginPostRtEventMidiLearn, sendCallbackLater, {} };
 946     rtEvent.midiLearn.parameter = parameter;
 947     rtEvent.midiLearn.cc = cc;
 948     rtEvent.midiLearn.channel = channel;
 949
 950     postRtEvents.appendRT(rtEvent);
 951 }
 952
 953 // -----------------------------------------------------------------------
 954 // Library functions
 955
 956 static LibCounter sLibCounter;
 957
 958 const char* CarlaPlugin::ProtectedData::libError(const char* const fname) noexcept
 959 {
 960     return lib_error(fname);
 961 }
 962
 963 bool CarlaPlugin::ProtectedData::libOpen(const char* const fname) noexcept
 964 {
 965     lib = sLibCounter.open(fname);
 966     return (lib != nullptr);
 967 }
 968
 969 bool CarlaPlugin::ProtectedData::libClose() noexcept
 970 {
 971     const bool ret = sLibCounter.close(lib);
 972     lib = nullptr;
 973     return ret;
 974 }
 975
 976 void CarlaPlugin::ProtectedData::setCanDeleteLib(const bool canDelete) noexcept
 977 {
 978     sLibCounter.setCanDelete(lib, canDelete);
 979 }
 980
 981 bool CarlaPlugin::ProtectedData::uiLibOpen(const char* const fname, const bool canDelete) noexcept
 982 {
 983     uiLib = sLibCounter.open(fname, canDelete);
 984     return (uiLib != nullptr);
 985 }
 986
 987 bool CarlaPlugin::ProtectedData::uiLibClose() noexcept
 988 {
 989     const bool ret = sLibCounter.close(uiLib);
 990     uiLib = nullptr;
 991     return ret;
 992 }
 993
 994 // -----------------------------------------------------------------------
 995
 996 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
 997 void CarlaPlugin::ProtectedData::tryTransient() noexcept
 998 {
 999     if (engine->getOptions().frontendWinId != 0)
1000         transientTryCounter = 1;
1001 }
1002 #endif
1003
1004 void CarlaPlugin::ProtectedData::updateParameterValues(CarlaPlugin* const plugin,
1005                                                        const bool sendCallback,
1006                                                        const bool sendOsc,
1007                                                        const bool useDefault) noexcept
1008 {
1009     CARLA_SAFE_ASSERT_RETURN(sendOsc || sendCallback || useDefault,);
1010
1011     for (uint32_t i=0; i < param.count; ++i)
1012     {
1013         const float value(param.ranges[i].getFixedValue(plugin->getParameterValue(i)));
1014
1015         if (useDefault)
1016             param.ranges[i].def = value;
1017
1018         if (useDefault) {
1019             engine->callback(sendCallback, sendOsc,
1020                              ENGINE_CALLBACK_PARAMETER_DEFAULT_CHANGED,
1021                              id,
1022                              static_cast<int>(i),
1023                              0, 0,
1024                              value,
1025                              nullptr);
1026         }
1027
1028         engine->callback(sendCallback, sendOsc,
1029                          ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED,
1030                          id,
1031                          static_cast<int>(i),
1032                          0, 0,
1033                          value,
1034                          nullptr);
1035     }
1036 }
1037
1038 void CarlaPlugin::ProtectedData::updateDefaultParameterValues(CarlaPlugin* const plugin) noexcept
1039 {
1040     for (uint32_t i=0; i < param.count; ++i)
1041         param.ranges[i].def = param.ranges[i].getFixedValue(plugin->getParameterValue(i));
1042 }
1043
1044 // -----------------------------------------------------------------------
1045
1046 CARLA_BACKEND_END_NAMESPACE