falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 43 Activity
Audio plugin host https://kx.studio/carla
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
7035 Commits
17 Branches
243MB
Tree: 12bc40fd6c
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '12bc40fd6c'
${ noResults }
Carla/source/backend/plugin/CarlaPluginAU.cpp

1122 lines
42KB
Raw Blame History 

  1. // SPDX-FileCopyrightText: 2011-2025 Filipe Coelho <falktx@falktx.com>

  2. // SPDX-License-Identifier: GPL-2.0-or-later

  3. 

  4. #include "CarlaPluginInternal.hpp"

  5. #include "CarlaEngine.hpp"

  6. 

  7. #ifdef CARLA_OS_MAC

  8. # include "CarlaBackendUtils.hpp"

  9. # include "CarlaPluginUI.hpp"

  10. # include "CarlaMacUtils.hpp"

  11. # include "CarlaMathUtils.hpp"

  12. # include <AudioToolbox/AudioUnit.h>

  13. # include <Foundation/Foundation.h>

  14. #endif

  15. 

  16. CARLA_BACKEND_START_NAMESPACE

  17. 

  18. // --------------------------------------------------------------------------------------------------------------------

  19. 

  20. #ifdef CARLA_OS_MAC

  21. typedef AudioComponentPlugInInterface* (*FactoryFn)(const AudioComponentDescription*);

  22. typedef OSStatus (*InitializeFn)(void*);

  23. typedef OSStatus (*UninitializeFn)(void*);

  24. typedef OSStatus (*GetPropertyInfoFn)(void*, AudioUnitPropertyID, AudioUnitScope, AudioUnitElement, UInt32*, Boolean*);

  25. typedef OSStatus (*GetPropertyFn)(void*, AudioUnitPropertyID, AudioUnitScope, AudioUnitElement, void*, UInt32*);

  26. typedef OSStatus (*SetPropertyFn)(void*, AudioUnitPropertyID, AudioUnitScope, AudioUnitElement, const void*, UInt32);

  27. typedef OSStatus (*GetParameterFn)(void*, AudioUnitParameterID, AudioUnitScope, AudioUnitElement, AudioUnitParameterValue*);

  28. typedef OSStatus (*SetParameterFn)(void*, AudioUnitParameterID, AudioUnitScope, AudioUnitElement, AudioUnitParameterValue, UInt32);

  29. typedef OSStatus (*ScheduleParametersFn)(void*, const AudioUnitParameterEvent*, UInt32);

  30. typedef OSStatus (*ResetFn)(void*, AudioUnitScope, AudioUnitElement);

  31. typedef OSStatus (*RenderFn)(void*, AudioUnitRenderActionFlags*, const AudioTimeStamp*, UInt32, UInt32, AudioBufferList*);

  32. typedef OSStatus (*MIDIEventFn)(void*, UInt32, UInt32, UInt32, UInt32);

  33. 

  34. static constexpr FourCharCode getFourCharCodeFromString(const char str[4])

  35. {

  36.     return (str[0] << 24) + (str[1] << 16) + (str[2] << 8) + str[3];

  37. }

  38. 

  39. class CarlaPluginAU : public CarlaPlugin,

  40.                       private CarlaPluginUI::Callback

  41. {

  42. public:

  43.     CarlaPluginAU(CarlaEngine* const engine, const uint id)

  44.         : CarlaPlugin(engine, id),

  45.           fInterface(nullptr),

  46.           fAudioBufferData(nullptr)

  47.     {

  48.         carla_stdout("CarlaPluginAU::CarlaPluginAU(%p, %i)", engine, id);

  49.     }

  50. 

  51.     ~CarlaPluginAU() override

  52.     {

  53.         carla_stdout("CarlaPluginAU::~CarlaPluginAU()");

  54. 

  55.         // close UI

  56.         showCustomUI(false);

  57. 

  58.         pData->singleMutex.lock();

  59.         pData->masterMutex.lock();

  60. 

  61.         if (pData->client != nullptr && pData->client->isActive())

  62.             pData->client->deactivate(true);

  63. 

  64.         if (pData->active)

  65.         {

  66.             deactivate();

  67.             pData->active = false;

  68.         }

  69. 

  70.         if (fInterface != nullptr)

  71.         {

  72.             fInterface->Close(fInterface);

  73.             fInterface = nullptr;

  74.         }

  75. 

  76.         if (fAudioBufferData != nullptr)

  77.         {

  78.             std::free(fAudioBufferData);

  79.             fAudioBufferData = nullptr;

  80.         }

  81. 

  82.         // if (fLastChunk != nullptr)

  83.         // {

  84.         //     std::free(fLastChunk);

  85.         //     fLastChunk = nullptr;

  86.         // }

  87. 

  88.         clearBuffers();

  89.     }

  90. 

  91.     // -------------------------------------------------------------------

  92.     // Information (base)

  93. 

  94.     PluginType getType() const noexcept override

  95.     {

  96.         return PLUGIN_AU;

  97.     }

  98. 

  99.     PluginCategory getCategory() const noexcept override

  100.     {

  101.         // TODO

  102.         return PLUGIN_CATEGORY_NONE;

  103.     }

  104. 

  105.     uint32_t getLatencyInFrames() const noexcept override

  106.     {

  107.         // TODO

  108.         return 0;

  109.     }

  110. 

  111.     // -------------------------------------------------------------------

  112.     // Information (count)

  113. 

  114.     // -------------------------------------------------------------------

  115.     // Information (current data)

  116. 

  117.     // -------------------------------------------------------------------

  118.     // Information (per-plugin data)

  119. 

  120.     uint getOptionsAvailable() const noexcept override

  121.     {

  122.         // TODO

  123.         return 0x0;

  124.     }

  125. 

  126.     float getParameterValue(const uint32_t parameterId) const noexcept override

  127.     {

  128.         CARLA_SAFE_ASSERT_RETURN(fInterface != nullptr, 0.f);

  129.         CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count, 0.f);

  130. 

  131.         const AudioUnitParameterID paramId = pData->param.data[parameterId].rindex;

  132.         AudioUnitParameterValue value = 0.f;

  133.         if (fFunctions.getParameter(fInterface, paramId, kAudioUnitScope_Global, 0, &value) == noErr)

  134.             return value;

  135. 

  136.         return 0.f;

  137.     }

  138. 

  139.     bool getLabel(char* const strBuf) const noexcept override

  140.     {

  141.         std::strncpy(strBuf, fLabel.buffer(), STR_MAX);

  142.         return true;

  143.     }

  144. 

  145.     bool getMaker(char* const strBuf) const noexcept override

  146.     {

  147.         std::strncpy(strBuf, fMaker.buffer(), STR_MAX);

  148.         return true;

  149.     }

  150. 

  151.     bool getRealName(char* const strBuf) const noexcept override

  152.     {

  153.         std::strncpy(strBuf, fName.buffer(), STR_MAX);

  154.         return true;

  155.     }

  156. 

  157.     bool getParameterName(const uint32_t parameterId, char* const strBuf) const noexcept override

  158.     {

  159.         CARLA_SAFE_ASSERT_RETURN(fInterface != nullptr, false);

  160.         CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count, false);

  161. 

  162.         const AudioUnitParameterID paramId = pData->param.data[parameterId].rindex;

  163.         AudioUnitParameterInfo info = {};

  164.         UInt32 outDataSize = sizeof(AudioUnitParameterInfo);

  165. 

  166.         if (fFunctions.getProperty(fInterface, kAudioUnitProperty_ParameterInfo, kAudioUnitScope_Global, paramId, &info, &outDataSize) == noErr)

  167.         {

  168.             if (info.flags & kAudioUnitParameterFlag_HasCFNameString)

  169.             {

  170.                 *strBuf = '\0';

  171.                 if (! CFStringGetCString(info.cfNameString, strBuf, std::min<int>(STR_MAX, CFStringGetLength(info.cfNameString) + 1), kCFStringEncodingUTF8))

  172.                 {

  173.                     carla_stdout("CFStringGetCString fail '%s'", info.name);

  174.                     std::strncpy(strBuf, info.name, STR_MAX);

  175.                 }

  176.                 else

  177.                 {

  178.                     carla_stdout("CFStringGetCString ok '%s' '%s'", info.name, strBuf);

  179.                     std::strncpy(strBuf, info.name, STR_MAX);

  180.                 }

  181. 

  182.                 if (info.flags & kAudioUnitParameterFlag_CFNameRelease)

  183.                     CFRelease(info.cfNameString);

  184. 

  185.                 return true;

  186.             }

  187. 

  188.                     carla_stdout("CFStringGetCString not used '%s'", info.name);

  189.             std::strncpy(strBuf, info.name, STR_MAX);

  190.             return true;

  191.         }

  192. 

  193.         carla_safe_assert("fFunctions.getProperty(...)", __FILE__, __LINE__);

  194.         return CarlaPlugin::getParameterName(parameterId, strBuf);

  195.     }

  196. 

  197.     // -------------------------------------------------------------------

  198.     // Set data (plugin-specific stuff)

  199. 

  200.     void setParameterValue(const uint32_t parameterId, const float value, const bool sendGui, const bool sendOsc, const bool sendCallback) noexcept override

  201.     {

  202.         CARLA_SAFE_ASSERT_RETURN(fInterface != nullptr,);

  203.         CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count,);

  204. 

  205.         const AudioUnitParameterID paramId = pData->param.data[parameterId].rindex;

  206.         const float fixedValue = pData->param.getFixedValue(parameterId, value);

  207. 

  208.         fFunctions.setParameter(fInterface, paramId, kAudioUnitScope_Global, 0, value, 0);

  209. 

  210.         CarlaPlugin::setParameterValue(parameterId, fixedValue, sendGui, sendOsc, sendCallback);

  211.     }

  212. 

  213.     void setParameterValueRT(const uint32_t parameterId, const float value, const uint32_t frameOffset, const bool sendCallbackLater) noexcept override

  214.     {

  215.         CARLA_SAFE_ASSERT_RETURN(fInterface != nullptr,);

  216.         CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count,);

  217. 

  218.         const AudioUnitParameterID paramId = pData->param.data[parameterId].rindex;

  219.         const float fixedValue = pData->param.getFixedValue(parameterId, value);

  220. 

  221.         // TODO use scheduled events

  222.         fFunctions.setParameter(fInterface, paramId, kAudioUnitScope_Global, 0, value, frameOffset);

  223. 

  224.         CarlaPlugin::setParameterValueRT(parameterId, fixedValue, frameOffset, sendCallbackLater);

  225.     }

  226. 

  227.     // ----------------------------------------------------------------------------------------------------------------

  228.     // Plugin state

  229. 

  230.     void reload() override

  231.     {

  232.         CARLA_SAFE_ASSERT_RETURN(pData->engine != nullptr,);

  233.         CARLA_SAFE_ASSERT_RETURN(fInterface != nullptr,);

  234.         carla_debug("CarlaPluginAU::reload() - start");

  235. 

  236.         const EngineProcessMode processMode = pData->engine->getProccessMode();

  237. 

  238.         // Safely disable plugin for reload

  239.         const ScopedDisabler sd(this);

  240. 

  241.         if (pData->active)

  242.             deactivate();

  243. 

  244.         clearBuffers();

  245. 

  246.         uint32_t audioIns, audioOuts, parametersIns, parametersOuts;

  247.         audioIns = audioOuts = parametersIns = parametersOuts = 0;

  248. 

  249.         bool needsCtrlIn, needsCtrlOut, hasMidiIn, hasMidiOut;

  250.         needsCtrlIn = needsCtrlOut = hasMidiIn = hasMidiOut = false;

  251. 

  252.         String portName;

  253.         const uint portNameSize = pData->engine->getMaxPortNameSize();

  254. 

  255.         UInt32 outDataSize;

  256.         Boolean outWritable = false;

  257. 

  258.         // audio ports

  259.         outDataSize = 0;

  260.         if (fFunctions.getPropertyInfo(fInterface,

  261.                                        kAudioUnitProperty_SupportedNumChannels,

  262.                                        kAudioUnitScope_Global,

  263.                                        0, &outDataSize, &outWritable) == noErr

  264.             && outDataSize != 0

  265.             && outDataSize % sizeof(AUChannelInfo) == 0)

  266.         {

  267.             const uint32_t numChannels = outDataSize / sizeof(AUChannelInfo);

  268.             AUChannelInfo* const channelInfo = new AUChannelInfo[numChannels];

  269. 

  270.             carla_stdout("kAudioUnitProperty_SupportedNumChannels returns %u configs", numChannels);

  271. 

  272.             if (fFunctions.getProperty(fInterface,

  273.                                        kAudioUnitProperty_SupportedNumChannels,

  274.                                        kAudioUnitScope_Global,

  275.                                        0, channelInfo, &outDataSize) == noErr

  276.                 && outDataSize == numChannels * sizeof(AUChannelInfo))

  277.             {

  278.                 AUChannelInfo* highestInfo = &channelInfo[0];

  279. 

  280.                 carla_stdout("kAudioUnitProperty_SupportedNumChannels returns {%d,%d}... config",

  281.                              channelInfo[0].inChannels,

  282.                              channelInfo[0].outChannels);

  283. 

  284.                 for (uint32_t i=0; i<numChannels; ++i)

  285.                 {

  286.                     if (channelInfo[i].inChannels < 0)

  287.                         channelInfo[i].inChannels = 2;

  288.                     if (channelInfo[i].outChannels < 0)

  289.                         channelInfo[i].outChannels = 2;

  290. 

  291.                     if (channelInfo[i].inChannels > highestInfo->inChannels

  292.                         && channelInfo[i].outChannels > highestInfo->outChannels)

  293.                     {

  294.                         highestInfo = &channelInfo[i];

  295.                     }

  296.                 }

  297. 

  298.                 audioIns = std::min<int16_t>(64, highestInfo->inChannels);

  299.                 audioOuts = std::min<int16_t>(64, highestInfo->outChannels);

  300.             }

  301.             else

  302.             {

  303.                 carla_stdout("kAudioUnitProperty_SupportedNumChannels failed");

  304.             }

  305. 

  306.             delete[] channelInfo;

  307.         }

  308.         else

  309.         {

  310.             outDataSize = 0;

  311.             if (fFunctions.getPropertyInfo(fInterface,

  312.                                            kAudioUnitProperty_ElementCount,

  313.                                            kAudioUnitScope_Input,

  314.                                            0, &outDataSize, &outWritable) == noErr

  315.                 && outDataSize == sizeof(UInt32))

  316.             {

  317.                 UInt32 count = 0;

  318.                 if (fFunctions.getProperty(fInterface,

  319.                                            kAudioUnitProperty_ElementCount,

  320.                                            kAudioUnitScope_Input,

  321.                                            0, &count, &outDataSize) == noErr

  322.                     && outDataSize == sizeof(UInt32) && count != 0)

  323.                 {

  324.                     AudioStreamBasicDescription desc;

  325.                     std::memset(&desc, 0, sizeof(desc));

  326.                     outDataSize = sizeof(AudioStreamBasicDescription);

  327. 

  328.                     if (fFunctions.getProperty(fInterface,

  329.                                                kAudioUnitProperty_StreamFormat,

  330.                                                kAudioUnitScope_Input,

  331.                                                0, &desc, &outDataSize) == noErr)

  332.                         audioIns = std::min<uint32_t>(64, desc.mChannelsPerFrame);

  333.                 }

  334.             }

  335. 

  336.             outDataSize = 0;

  337.             if (fFunctions.getPropertyInfo(fInterface,

  338.                                            kAudioUnitProperty_ElementCount,

  339.                                            kAudioUnitScope_Output,

  340.                                            0, &outDataSize, &outWritable) == noErr

  341.                 && outDataSize == sizeof(UInt32))

  342.             {

  343.                 UInt32 count = 0;

  344.                 if (fFunctions.getProperty(fInterface,

  345.                                            kAudioUnitProperty_ElementCount,

  346.                                            kAudioUnitScope_Output,

  347.                                            0, &count, &outDataSize) == noErr

  348.                     && outDataSize == sizeof(UInt32) && count != 0)

  349.                 {

  350.                     AudioStreamBasicDescription desc;

  351.                     std::memset(&desc, 0, sizeof(desc));

  352.                     outDataSize = sizeof(AudioStreamBasicDescription);

  353. 

  354.                     if (fFunctions.getProperty(fInterface,

  355.                                                kAudioUnitProperty_StreamFormat,

  356.                                                kAudioUnitScope_Output,

  357.                                                0, &desc, &outDataSize) == noErr)

  358.                         audioOuts = std::min<uint32_t>(64, desc.mChannelsPerFrame);

  359.                 }

  360.             }

  361.         }

  362. 

  363.         if (audioIns > 0)

  364.         {

  365.             pData->audioIn.createNew(audioIns);

  366.         }

  367. 

  368.         if (audioOuts > 0)

  369.         {

  370.             pData->audioOut.createNew(audioOuts);

  371.             needsCtrlIn = true;

  372.         }

  373. 

  374.         std::free(fAudioBufferData);

  375. 

  376.         if (const uint32_t numBuffers = std::max(audioIns, audioOuts))

  377.         {

  378.             fAudioBufferData = static_cast<AudioBufferList*>(std::malloc(sizeof(uint32_t) + sizeof(AudioBuffer) * numBuffers));

  379.             fAudioBufferData->mNumberBuffers = numBuffers;

  380. 

  381.             for (uint32_t i = 0; i < numBuffers; ++i)

  382.                 fAudioBufferData->mBuffers[i].mNumberChannels = 1;

  383.         }

  384.         else

  385.         {

  386.             fAudioBufferData = static_cast<AudioBufferList*>(std::malloc(sizeof(uint32_t)));

  387.             fAudioBufferData->mNumberBuffers = 0;

  388.         }

  389. 

  390.         // Audio Ins

  391.         for (uint32_t i=0; i < audioIns; ++i)

  392.         {

  393.             portName.clear();

  394. 

  395.             if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  396.             {

  397.                 portName  = pData->name;

  398.                 portName += ":";

  399.             }

  400. 

  401.             if (audioIns > 1)

  402.             {

  403.                 portName += "input_";

  404.                 portName += String(i + 1);

  405.             }

  406.             else

  407.                 portName += "input";

  408. 

  409.             portName.truncate(portNameSize);

  410. 

  411.             pData->audioIn.ports[i].port = (CarlaEngineAudioPort*)pData->client->addPort(kEnginePortTypeAudio, portName, true, i);

  412.             pData->audioIn.ports[i].rindex = i;

  413.         }

  414. 

  415.         // Audio Outs

  416.         for (uint32_t i=0; i < audioOuts; ++i)

  417.         {

  418.             portName.clear();

  419. 

  420.             if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  421.             {

  422.                 portName  = pData->name;

  423.                 portName += ":";

  424.             }

  425. 

  426.             if (audioOuts > 1)

  427.             {

  428.                 portName += "output_";

  429.                 portName += String(i + 1);

  430.             }

  431.             else

  432.                 portName += "output";

  433. 

  434.             portName.truncate(portNameSize);

  435. 

  436.             pData->audioOut.ports[i].port   = (CarlaEngineAudioPort*)pData->client->addPort(kEnginePortTypeAudio, portName, false, i);

  437.             pData->audioOut.ports[i].rindex = i;

  438.         }

  439. 

  440.         // parameters

  441.         outDataSize = 0;

  442.         if (fFunctions.getPropertyInfo(fInterface,

  443.                                        kAudioUnitProperty_ParameterList,

  444.                                        kAudioUnitScope_Global,

  445.                                        0, &outDataSize, &outWritable) == noErr

  446.             && outDataSize != 0

  447.             && outDataSize % sizeof(AudioUnitParameterID) == 0)

  448.         {

  449.             const uint32_t numParams = outDataSize / sizeof(AudioUnitParameterID);

  450.             AudioUnitParameterID* const paramIds = new AudioUnitParameterID[numParams];

  451. 

  452.             if (fFunctions.getProperty(fInterface, kAudioUnitProperty_ParameterList, kAudioUnitScope_Global, 0, paramIds, &outDataSize) == noErr && outDataSize == numParams * sizeof(AudioUnitParameterID))

  453.             {

  454.                 pData->param.createNew(numParams, false);

  455. 

  456.                 AudioUnitParameterInfo info;

  457.                 float min, max, def, step, stepSmall, stepLarge;

  458. 

  459.                 for (uint32_t i=0; i<numParams; ++i)

  460.                 {

  461.                     carla_zeroStruct(info);

  462. 

  463.                     outDataSize = 0;

  464.                     if (fFunctions.getPropertyInfo(fInterface, kAudioUnitProperty_ParameterInfo, kAudioUnitScope_Global, paramIds[i], &outDataSize, &outWritable) != noErr)

  465.                         break;

  466.                     if (outDataSize != sizeof(AudioUnitParameterInfo))

  467.                         break;

  468.                     if (fFunctions.getProperty(fInterface, kAudioUnitProperty_ParameterInfo, kAudioUnitScope_Global, paramIds[i], &info, &outDataSize) != noErr)

  469.                         break;

  470. 

  471.                     if (info.flags & kAudioUnitParameterFlag_CFNameRelease)

  472.                         CFRelease(info.cfNameString);

  473. 

  474.                     pData->param.data[i].index  = static_cast<int32_t>(i);

  475.                     pData->param.data[i].rindex = static_cast<int32_t>(paramIds[i]);

  476. 

  477.                     if (info.flags & kAudioUnitParameterFlag_IsWritable)

  478.                     {

  479.                         pData->param.data[i].type = PARAMETER_INPUT;

  480.                         needsCtrlIn = true;

  481.                     }

  482.                     else if (info.flags & (kAudioUnitParameterFlag_IsReadable|kAudioUnitParameterFlag_MeterReadOnly))

  483.                     {

  484.                         pData->param.data[i].type = PARAMETER_OUTPUT;

  485.                         needsCtrlOut = true;

  486.                     }

  487.                     else

  488.                     {

  489.                         pData->param.data[i].type = PARAMETER_UNKNOWN;

  490.                         continue;

  491.                     }

  492. 

  493.                     min = info.minValue;

  494.                     max = info.maxValue;

  495.                     def = info.defaultValue;

  496. 

  497.                     if (min > max)

  498.                         max = min;

  499. 

  500.                     if (d_isEqual(min, max))

  501.                     {

  502.                         carla_stderr2("WARNING - Broken plugin parameter '%s': max == min", info.name);

  503.                         max = min + 0.1f;

  504.                     }

  505. 

  506.                     if (def < min)

  507.                         def = min;

  508.                     else if (def > max)

  509.                         def = max;

  510. 

  511.                     pData->param.data[i].hints |= PARAMETER_IS_ENABLED;

  512. 

  513.                     if ((info.flags & kAudioUnitParameterFlag_NonRealTime) == 0)

  514.                     {

  515.                         pData->param.data[i].hints |= PARAMETER_IS_AUTOMATABLE;

  516.                         pData->param.data[i].hints |= PARAMETER_CAN_BE_CV_CONTROLLED;

  517.                     }

  518. 

  519.                     if (info.unit == kAudioUnitParameterUnit_Boolean)

  520.                     {

  521.                         step = max - min;

  522.                         stepSmall = step;

  523.                         stepLarge = step;

  524.                         pData->param.data[i].hints |= PARAMETER_IS_BOOLEAN;

  525.                     }

  526.                     else if (info.unit == kAudioUnitParameterUnit_Indexed)

  527.                     {

  528.                         step = 1.0f;

  529.                         stepSmall = 1.0f;

  530.                         stepLarge = 10.0f;

  531.                         pData->param.data[i].hints |= PARAMETER_IS_INTEGER;

  532.                     }

  533.                     else

  534.                     {

  535.                         float range = max - min;

  536.                         step = range/100.0f;

  537.                         stepSmall = range/1000.0f;

  538.                         stepLarge = range/10.0f;

  539.                     }

  540. 

  541.                     pData->param.ranges[i].min = min;

  542.                     pData->param.ranges[i].max = max;

  543.                     pData->param.ranges[i].def = def;

  544.                     pData->param.ranges[i].step = step;

  545.                     pData->param.ranges[i].stepSmall = stepSmall;

  546.                     pData->param.ranges[i].stepLarge = stepLarge;

  547.                 }

  548.             }

  549. 

  550.             delete[] paramIds;

  551.         }

  552. 

  553.         if (needsCtrlIn || hasMidiIn)

  554.         {

  555.             portName.clear();

  556. 

  557.             if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  558.             {

  559.                 portName  = pData->name;

  560.                 portName += ":";

  561.             }

  562. 

  563.             portName += "events-in";

  564.             portName.truncate(portNameSize);

  565. 

  566.             pData->event.portIn = (CarlaEngineEventPort*)pData->client->addPort(kEnginePortTypeEvent, portName, true, 0);

  567. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  568.             pData->event.cvSourcePorts = pData->client->createCVSourcePorts();

  569. #endif

  570.         }

  571. 

  572.         if (needsCtrlOut || hasMidiOut)

  573.         {

  574.             portName.clear();

  575. 

  576.             if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  577.             {

  578.                 portName  = pData->name;

  579.                 portName += ":";

  580.             }

  581. 

  582.             portName += "events-out";

  583.             portName.truncate(portNameSize);

  584. 

  585.             pData->event.portOut = (CarlaEngineEventPort*)pData->client->addPort(kEnginePortTypeEvent, portName, false, 0);

  586.         }

  587. 

  588.         // plugin hints

  589.         pData->hints = 0x0;

  590. 

  591.         if (audioOuts > 0 && (audioIns == audioOuts || audioIns == 1))

  592.             pData->hints |= PLUGIN_CAN_DRYWET;

  593. 

  594.         if (audioOuts > 0)

  595.             pData->hints |= PLUGIN_CAN_VOLUME;

  596. 

  597.         if (audioOuts >= 2 && audioOuts % 2 == 0)

  598.             pData->hints |= PLUGIN_CAN_BALANCE;

  599. 

  600.         // extra plugin hints

  601.         pData->extraHints = 0x0;

  602. 

  603.         bufferSizeChanged(pData->engine->getBufferSize());

  604.         reloadPrograms(true);

  605. 

  606.         if (pData->active)

  607.             activate();

  608. 

  609.         carla_debug("CarlaPluginAU::reload() - end");

  610.     }

  611. 

  612.     // -------------------------------------------------------------------

  613.     // Plugin processing

  614. 

  615.     void activate() noexcept override

  616.     {

  617.         CARLA_SAFE_ASSERT_RETURN(fInterface != nullptr,);

  618. 

  619.         AudioStreamBasicDescription streamFormat = {

  620.             .mFormatID         = kAudioFormatLinearPCM,

  621.             .mBitsPerChannel   = 32,

  622.             .mBytesPerFrame    = sizeof(float),

  623.             .mBytesPerPacket   = sizeof(float),

  624.             .mFramesPerPacket  = 1,

  625.             .mFormatFlags      = kAudioFormatFlagsNativeFloatPacked | kAudioFormatFlagIsNonInterleaved,

  626.             .mChannelsPerFrame = 0,

  627.             .mSampleRate       = pData->engine->getSampleRate(),

  628.         };

  629. 

  630.         if (pData->audioIn.count != 0)

  631.         {

  632.             streamFormat.mChannelsPerFrame = pData->audioIn.count;

  633.             CARLA_SAFE_ASSERT_RETURN(fFunctions.setProperty(fInterface,

  634.                                                             kAudioUnitProperty_StreamFormat,

  635.                                                             kAudioUnitScope_Input,

  636.                                                             0, &streamFormat, sizeof(streamFormat)) == noErr,);

  637.         }

  638. 

  639.         if (pData->audioOut.count != 0)

  640.         {

  641.             streamFormat.mChannelsPerFrame = pData->audioOut.count;

  642.             CARLA_SAFE_ASSERT_RETURN(fFunctions.setProperty(fInterface,

  643.                                                             kAudioUnitProperty_StreamFormat,

  644.                                                             kAudioUnitScope_Output,

  645.                                                             0, &streamFormat, sizeof(streamFormat)) == noErr,);

  646.         }

  647. 

  648.         fFunctions.initialize(fInterface);

  649.     }

  650. 

  651.     void deactivate() noexcept override

  652.     {

  653.         CARLA_SAFE_ASSERT_RETURN(fInterface != nullptr,);

  654. 

  655.         fFunctions.uninitialize(fInterface);

  656.     }

  657. 

  658.     void process(const float* const* const audioIn,

  659.                  float** const audioOut,

  660.                  const float* const* const,

  661.                  float** const,

  662.                  const uint32_t frames) override

  663.     {

  664.         // ------------------------------------------------------------------------------------------------------------

  665.         // Check if active

  666. 

  667.         if (! pData->active)

  668.         {

  669.             // disable any output sound

  670.             for (uint32_t i=0; i < pData->audioOut.count; ++i)

  671.                 carla_zeroFloats(audioOut[i], frames);

  672.             return;

  673.         }

  674. 

  675.         // ------------------------------------------------------------------------------------------------------------

  676.         // Check buffers

  677. 

  678.         CARLA_SAFE_ASSERT_RETURN(frames > 0,);

  679. 

  680.         if (pData->audioIn.count > 0)

  681.         {

  682.             CARLA_SAFE_ASSERT_RETURN(audioIn != nullptr,);

  683.         }

  684.         if (pData->audioOut.count > 0)

  685.         {

  686.             CARLA_SAFE_ASSERT_RETURN(audioOut != nullptr,);

  687.         }

  688. 

  689.         // ------------------------------------------------------------------------------------------------------------

  690.         // Try lock, silence otherwise

  691. 

  692.         if (pData->engine->isOffline())

  693.         {

  694.             pData->singleMutex.lock();

  695.         }

  696.         else if (! pData->singleMutex.tryLock())

  697.         {

  698.             for (uint32_t i=0; i < pData->audioOut.count; ++i)

  699.                 carla_zeroFloats(audioOut[i], frames);

  700.             return;

  701.         }

  702. 

  703.         // ------------------------------------------------------------------------------------------------------------

  704.         // Check if needs reset

  705. 

  706.         if (pData->needsReset)

  707.         {

  708.             // TODO

  709.         }

  710. 

  711.         // ------------------------------------------------------------------------------------------------------------

  712.         // Event Input (main port)

  713. 

  714.         if (pData->event.portIn != nullptr)

  715.         {

  716.             // TODO

  717.         }

  718. 

  719.         // ------------------------------------------------------------------------------------------------------------

  720.         // Plugin processing

  721. 

  722.         const EngineTimeInfo timeInfo(pData->engine->getTimeInfo());

  723. 

  724.         AudioUnitRenderActionFlags actionFlags = kAudioUnitRenderAction_DoNotCheckRenderArgs;

  725.         AudioTimeStamp timeStamp = {};

  726.         timeStamp.mFlags = kAudioTimeStampSampleTimeValid;

  727.         timeStamp.mSampleTime = timeInfo.frame;

  728.         const UInt32 inBusNumber = 0;

  729. 

  730.         {

  731.             uint32_t i = 0;

  732.             for (; i < pData->audioOut.count; ++i)

  733.             {

  734.                 fAudioBufferData->mBuffers[i].mData = audioOut[i];

  735.                 fAudioBufferData->mBuffers[i].mDataByteSize = sizeof(float) * frames;

  736. 

  737.                 if (audioOut[i] != audioIn[i])

  738.                     std::memcpy(audioOut[i], audioIn[i], sizeof(float) * frames);

  739.             }

  740. 

  741.             for (; i < pData->audioIn.count; ++i)

  742.             {

  743.                 fAudioBufferData->mBuffers[i].mData = audioOut[i];

  744.                 fAudioBufferData->mBuffers[i].mDataByteSize = sizeof(float) * frames;

  745.             }

  746.         }

  747. 

  748.         fFunctions.render(fInterface, &actionFlags, &timeStamp, inBusNumber, frames, fAudioBufferData);

  749. 

  750.         // ------------------------------------------------------------------------------------------------------------

  751. 

  752.         pData->singleMutex.unlock();

  753. 

  754.        #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  755.         // ------------------------------------------------------------------------------------------------------------

  756.         // Control Output

  757. 

  758.         // TODO

  759.        #endif

  760. 

  761.         // ------------------------------------------------------------------------------------------------------------

  762.         // Events/MIDI Output

  763. 

  764.         // TODO

  765.     }

  766. 

  767.     // ----------------------------------------------------------------------------------------------------------------

  768. 

  769. protected:

  770.     void handlePluginUIClosed() override

  771.     {

  772.         carla_stdout("CarlaPluginAU::handlePluginUIClosed()");

  773. 

  774.         // TODO

  775.     }

  776. 

  777.     void handlePluginUIResized(const uint width, const uint height) override

  778.     {

  779.         // TODO

  780.     }

  781. 

  782.     // -------------------------------------------------------------------

  783. 

  784. public:

  785.     bool init(const CarlaPluginPtr plugin,

  786.               const char* const filename,

  787.               const char* const label,

  788.               const char* const name,

  789.               const uint options)

  790.     {

  791.         CARLA_SAFE_ASSERT_RETURN(pData->engine != nullptr, false);

  792. 

  793.         // ---------------------------------------------------------------

  794.         // first checks

  795. 

  796.         if (pData->client != nullptr)

  797.         {

  798.             pData->engine->setLastError("Plugin client is already registered");

  799.             return false;

  800.         }

  801. 

  802.         if (filename == nullptr || filename[0] == '\0')

  803.         {

  804.             pData->engine->setLastError("null filename");

  805.             return false;

  806.         }

  807. 

  808.         // ---------------------------------------------------------------

  809.         // load bundle information

  810. 

  811.         if (! fBundleLoader.load(filename))

  812.         {

  813.             pData->engine->setLastError("Failed to load AU bundle executable");

  814.             return false;

  815.         }

  816. 

  817.         const CFTypeRef componentsRef = CFBundleGetValueForInfoDictionaryKey(fBundleLoader.getRef(), CFSTR("AudioComponents"));

  818. 

  819.         if (componentsRef == nullptr || CFGetTypeID(componentsRef) != CFArrayGetTypeID())

  820.         {

  821.             pData->engine->setLastError("Not an AU component");

  822.             return false;

  823.         }

  824. 

  825.         // ---------------------------------------------------------------

  826.         // find binary matching requested label

  827. 

  828.         CFStringRef componentName;

  829.         AudioComponentDescription desc = {};

  830.         FactoryFn factoryFn;

  831. 

  832.         const CFArrayRef components = static_cast<CFArrayRef>(componentsRef);

  833. 

  834.         for (uint32_t c = 0, count = CFArrayGetCount(components); c < count; ++c)

  835.         {

  836.             // reset

  837.             desc.componentType = 0;

  838. 

  839.             const CFTypeRef componentRef = CFArrayGetValueAtIndex(components, c);

  840.             CARLA_SAFE_ASSERT_CONTINUE(componentRef != nullptr);

  841.             CARLA_SAFE_ASSERT_CONTINUE(CFGetTypeID(componentRef) == CFDictionaryGetTypeID());

  842. 

  843.             const CFDictionaryRef component = static_cast<CFDictionaryRef>(componentRef);

  844. 

  845.             componentName = nullptr;

  846.             CARLA_SAFE_ASSERT_CONTINUE(CFDictionaryGetValueIfPresent(component, CFSTR("name"), (const void **)&componentName));

  847. 

  848.             CFStringRef componentFactoryFunction = nullptr;

  849.             CARLA_SAFE_ASSERT_CONTINUE(CFDictionaryGetValueIfPresent(component, CFSTR("factoryFunction"), (const void **)&componentFactoryFunction));

  850. 

  851.             CFStringRef componentType = nullptr;

  852.             CARLA_SAFE_ASSERT_CONTINUE(CFDictionaryGetValueIfPresent(component, CFSTR("type"), (const void **)&componentType));

  853.             CARLA_SAFE_ASSERT_CONTINUE(CFStringGetLength(componentType) == 4);

  854. 

  855.             CFStringRef componentSubType = nullptr;

  856.             CARLA_SAFE_ASSERT_CONTINUE(CFDictionaryGetValueIfPresent(component, CFSTR("subtype"), (const void **)&componentSubType));

  857.             CARLA_SAFE_ASSERT_CONTINUE(CFStringGetLength(componentSubType) == 4);

  858. 

  859.             CFStringRef componentManufacturer = nullptr;

  860.             CARLA_SAFE_ASSERT_CONTINUE(CFDictionaryGetValueIfPresent(component, CFSTR("manufacturer"), (const void **)&componentManufacturer));

  861.             CARLA_SAFE_ASSERT_CONTINUE(CFStringGetLength(componentManufacturer) == 4);

  862. 

  863.             factoryFn = fBundleLoader.getSymbol<FactoryFn>(componentFactoryFunction);

  864.             CARLA_SAFE_ASSERT_CONTINUE(factoryFn != nullptr);

  865. 

  866.             char clabel[15] = {};

  867.             CFStringGetCString(componentType, clabel, 5, kCFStringEncodingASCII);

  868.             CFStringGetCString(componentSubType, clabel + 5, 5, kCFStringEncodingASCII);

  869.             CFStringGetCString(componentManufacturer, clabel + 10, 5, kCFStringEncodingASCII);

  870. 

  871.             desc.componentType = getFourCharCodeFromString(clabel);

  872.             desc.componentSubType = getFourCharCodeFromString(clabel + 5);

  873.             desc.componentManufacturer = getFourCharCodeFromString(clabel + 10);

  874. 

  875.             CARLA_SAFE_ASSERT_CONTINUE(desc.componentType != 0);

  876.             CARLA_SAFE_ASSERT_CONTINUE(desc.componentSubType != 0);

  877.             CARLA_SAFE_ASSERT_CONTINUE(desc.componentManufacturer != 0);

  878. 

  879.             clabel[4] = clabel[9] = ',';

  880. 

  881.             if (label == nullptr || label[0] == '\0' || std::strcmp(label, clabel) == 0)

  882.                 break;

  883.         }

  884. 

  885.         if (desc.componentType == 0)

  886.         {

  887.             pData->engine->setLastError("Failed to find request plugin in Component bundle");

  888.             return false;

  889.         }

  890. 

  891.         // ---------------------------------------------------------------

  892.         // load binary

  893. 

  894.         fInterface = factoryFn(&desc);

  895.         

  896.         if (fInterface == nullptr)

  897.         {

  898.             pData->engine->setLastError("Component failed to create new interface");

  899.             return false;

  900.         }

  901. 

  902.         if (! fFunctions.init(fInterface))

  903.         {

  904.             pData->engine->setLastError("Component does not provide all necessary functions");

  905.             fInterface = nullptr;

  906.             return false;

  907.         }

  908. 

  909.         if (fInterface->Open(fInterface, (AudioUnit)(void*)0x1) != noErr)

  910.         {

  911.             pData->engine->setLastError("Component failed to open");

  912.             fInterface->Close(fInterface);

  913.             fInterface = nullptr;

  914.             return false;

  915.         }

  916. 

  917.         // ---------------------------------------------------------------

  918.         // get info

  919. 

  920.         const CFIndex componentNameLen = CFStringGetLength(componentName);

  921.         char* const nameBuffer = new char[componentNameLen + 1];

  922. 

  923.         if (CFStringGetCString(componentName, nameBuffer, componentNameLen + 1, kCFStringEncodingUTF8))

  924.         {

  925.             if (char* const sep = std::strstr(nameBuffer, ": "))

  926.             {

  927.                 sep[0] = sep[1] = '\0';

  928.                 fName = sep + 2;

  929.                 fMaker = nameBuffer;

  930.             }

  931.             else

  932.             {

  933.                 fName = nameBuffer;

  934.                 fMaker = nameBuffer + componentNameLen;

  935.             }

  936.         }

  937. 

  938.         fLabel = label;

  939.         pData->name = pData->engine->getUniquePluginName(name != nullptr && name[0] != '\0' ? name : fName.buffer());

  940.         pData->filename = carla_strdup(filename);

  941. 

  942.         delete[] nameBuffer;

  943. 

  944.         // ---------------------------------------------------------------

  945.         // register client

  946. 

  947.         pData->client = pData->engine->addClient(plugin);

  948. 

  949.         if (pData->client == nullptr || ! pData->client->isOk())

  950.         {

  951.             pData->engine->setLastError("Failed to register plugin client");

  952.             return false;

  953.         }

  954. 

  955.         // ------------------------------------------------------------------------------------------------------------

  956.         // init component

  957. 

  958.         {

  959.             const UInt32 bufferSize = pData->engine->getBufferSize();

  960. 

  961.             if (fFunctions.setProperty(fInterface,

  962.                                        kAudioUnitProperty_MaximumFramesPerSlice,

  963.                                        kAudioUnitScope_Global,

  964.                                        0, &bufferSize, sizeof(bufferSize)) != noErr)

  965.             {

  966.                 pData->engine->setLastError("Failed to set Component maximum frames per slice");

  967.                 return false;

  968.             }

  969.         }

  970. 

  971.         {

  972.             const Float64 sampleRate = pData->engine->getSampleRate();

  973. 

  974.             // input scope

  975.             UInt32 outDataSize = 0;

  976.             Boolean outWritable = false;

  977.             if (fFunctions.getPropertyInfo(fInterface,

  978.                                            kAudioUnitProperty_ElementCount,

  979.                                            kAudioUnitScope_Input,

  980.                                            0, &outDataSize, &outWritable) == noErr

  981.                 && outDataSize == sizeof(UInt32))

  982.             {

  983.                 UInt32 outData = 0;

  984.                 if (fFunctions.getProperty(fInterface,

  985.                                            kAudioUnitProperty_ElementCount,

  986.                                            kAudioUnitScope_Input,

  987.                                            0, &outData, &outDataSize) == noErr

  988.                     && outData != 0)

  989.                 {

  990.                     if (fFunctions.setProperty(fInterface,

  991.                                                kAudioUnitProperty_SampleRate,

  992.                                                kAudioUnitScope_Input,

  993.                                                0, &sampleRate, sizeof(sampleRate)) != noErr)

  994.                     {

  995.                         pData->engine->setLastError("Failed to set Component input sample rate");

  996.                         return false;

  997.                     }

  998.                 }

  999.             }

  1000. 

  1001.             // output scope

  1002.             outDataSize = 0;

  1003.             outWritable = false;

  1004.             if (fFunctions.getPropertyInfo(fInterface,

  1005.                                            kAudioUnitProperty_ElementCount,

  1006.                                            kAudioUnitScope_Output,

  1007.                                            0, &outDataSize, &outWritable) == noErr

  1008.                 && outDataSize == sizeof(UInt32))

  1009.             {

  1010.                 UInt32 outData = 0;

  1011.                 if (fFunctions.getProperty(fInterface,

  1012.                                            kAudioUnitProperty_ElementCount,

  1013.                                            kAudioUnitScope_Output,

  1014.                                            0, &outData, &outDataSize) == noErr

  1015.                     && outData != 0)

  1016.                 {

  1017.                     if (fFunctions.setProperty(fInterface,

  1018.                                                kAudioUnitProperty_SampleRate,

  1019.                                                kAudioUnitScope_Output,

  1020.                                                0, &sampleRate, sizeof(sampleRate)) != noErr)

  1021.                     {

  1022.                         pData->engine->setLastError("Failed to set Component output sample rate");

  1023.                         return false;

  1024.                     }

  1025.                 }

  1026.             }

  1027.         }

  1028. 

  1029.         // ------------------------------------------------------------------------------------------------------------

  1030.         // set default options

  1031. 

  1032.         pData->options = PLUGIN_OPTION_FIXED_BUFFERS;

  1033. 

  1034.         return true;

  1035.     }

  1036. 

  1037. private:

  1038.     BundleLoader fBundleLoader;

  1039.     AudioComponentPlugInInterface* fInterface;

  1040.     AudioBufferList* fAudioBufferData;

  1041.     String fName;

  1042.     String fLabel;

  1043.     String fMaker;

  1044. 

  1045.     struct Functions {

  1046.         InitializeFn initialize;

  1047.         UninitializeFn uninitialize;

  1048.         GetPropertyInfoFn getPropertyInfo;

  1049.         GetPropertyFn getProperty;

  1050.         SetPropertyFn setProperty;

  1051.         GetParameterFn getParameter;

  1052.         SetParameterFn setParameter;

  1053.         ScheduleParametersFn scheduleParameters;

  1054.         ResetFn reset;

  1055.         RenderFn render;

  1056.         MIDIEventFn midiEvent;

  1057. 

  1058.         Functions()

  1059.             : initialize(nullptr),

  1060.               uninitialize(nullptr),

  1061.               getPropertyInfo(nullptr),

  1062.               getProperty(nullptr),

  1063.               setProperty(nullptr),

  1064.               getParameter(nullptr),

  1065.               setParameter(nullptr),

  1066.               scheduleParameters(nullptr),

  1067.               reset(nullptr),

  1068.               render(nullptr),

  1069.               midiEvent(nullptr) {}

  1070. 

  1071.         bool init(AudioComponentPlugInInterface* const interface)

  1072.         {

  1073.             initialize = (InitializeFn)interface->Lookup(kAudioUnitInitializeSelect);

  1074.             uninitialize = (UninitializeFn)interface->Lookup(kAudioUnitUninitializeSelect);

  1075.             getPropertyInfo = (GetPropertyInfoFn)interface->Lookup(kAudioUnitGetPropertyInfoSelect);

  1076.             getProperty = (GetPropertyFn)interface->Lookup(kAudioUnitGetPropertySelect);

  1077.             setProperty = (SetPropertyFn)interface->Lookup(kAudioUnitSetPropertySelect);

  1078.             getParameter = (GetParameterFn)interface->Lookup(kAudioUnitGetParameterSelect);

  1079.             setParameter = (SetParameterFn)interface->Lookup(kAudioUnitSetParameterSelect);

  1080.             scheduleParameters = (ScheduleParametersFn)interface->Lookup(kAudioUnitScheduleParametersSelect);

  1081.             reset = (ResetFn)interface->Lookup(kAudioUnitResetSelect);

  1082.             render = (RenderFn)interface->Lookup(kAudioUnitRenderSelect);

  1083.             midiEvent = (MIDIEventFn)interface->Lookup(kMusicDeviceMIDIEventSelect);

  1084. 

  1085.             return initialize != nullptr

  1086.                 && uninitialize != nullptr

  1087.                 && getPropertyInfo != nullptr

  1088.                 && getProperty != nullptr

  1089.                 && setProperty != nullptr

  1090.                 && getParameter != nullptr

  1091.                 && setParameter != nullptr

  1092.                 && scheduleParameters != nullptr

  1093.                 && render != nullptr;

  1094.         }

  1095.     } fFunctions;

  1096. };

  1097. #endif

  1098. 

  1099. // --------------------------------------------------------------------------------------------------------------------

  1100. 

  1101. CarlaPluginPtr CarlaPlugin::newAU(const Initializer& init)

  1102. {

  1103.     carla_stdout("CarlaPlugin::newAU({%p, \"%s\", \"%s\", \"%s\", " P_INT64 "})",

  1104.                 init.engine, init.filename, init.label, init.name, init.uniqueId);

  1105. 

  1106.    #ifdef CARLA_OS_MAC

  1107.     std::shared_ptr<CarlaPluginAU> plugin(new CarlaPluginAU(init.engine, init.id));

  1108. 

  1109.     if (! plugin->init(plugin, init.filename, init.label, init.name, init.options))

  1110.         return nullptr;

  1111. 

  1112.     return plugin;

  1113.    #else

  1114.     init.engine->setLastError("AU support not available");

  1115.     return nullptr;

  1116.    #endif

  1117. }

  1118. 

  1119. // --------------------------------------------------------------------------------------------------------------------

  1120. 

  1121. CARLA_BACKEND_END_NAMESPACE