falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 42 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.
6977 Commits
16 Branches
322MB
Tree: be2f1056ab
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'be2f1056ab'
${ noResults }
Carla/source/backend/plugin/CarlaPluginAU.cpp

1121 lines
42KB
Raw Blame History 

  1. // SPDX-FileCopyrightText: 2011-2024 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 <AudioToolbox/AudioUnit.h>

  12. # include <Foundation/Foundation.h>

  13. #endif

  14. 

  15. CARLA_BACKEND_START_NAMESPACE

  16. 

  17. // --------------------------------------------------------------------------------------------------------------------

  18. 

  19. #ifdef CARLA_OS_MAC

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

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

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

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

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

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

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

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

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

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

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

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

  32. 

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

  34. {

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

  36. }

  37. 

  38. class CarlaPluginAU : public CarlaPlugin,

  39.                       private CarlaPluginUI::Callback

  40. {

  41. public:

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

  43.         : CarlaPlugin(engine, id),

  44.           fInterface(nullptr),

  45.           fAudioBufferData(nullptr)

  46.     {

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

  48.     }

  49. 

  50.     ~CarlaPluginAU() override

  51.     {

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

  53. 

  54.         // close UI

  55.         showCustomUI(false);

  56. 

  57.         pData->singleMutex.lock();

  58.         pData->masterMutex.lock();

  59. 

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

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

  62. 

  63.         if (pData->active)

  64.         {

  65.             deactivate();

  66.             pData->active = false;

  67.         }

  68. 

  69.         if (fInterface != nullptr)

  70.         {

  71.             fInterface->Close(fInterface);

  72.             fInterface = nullptr;

  73.         }

  74. 

  75.         if (fAudioBufferData != nullptr)

  76.         {

  77.             std::free(fAudioBufferData);

  78.             fAudioBufferData = nullptr;

  79.         }

  80. 

  81.         // if (fLastChunk != nullptr)

  82.         // {

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

  84.         //     fLastChunk = nullptr;

  85.         // }

  86. 

  87.         clearBuffers();

  88.     }

  89. 

  90.     // -------------------------------------------------------------------

  91.     // Information (base)

  92. 

  93.     PluginType getType() const noexcept override

  94.     {

  95.         return PLUGIN_AU;

  96.     }

  97. 

  98.     PluginCategory getCategory() const noexcept override

  99.     {

  100.         // TODO

  101.         return PLUGIN_CATEGORY_NONE;

  102.     }

  103. 

  104.     uint32_t getLatencyInFrames() const noexcept override

  105.     {

  106.         // TODO

  107.         return 0;

  108.     }

  109. 

  110.     // -------------------------------------------------------------------

  111.     // Information (count)

  112. 

  113.     // -------------------------------------------------------------------

  114.     // Information (current data)

  115. 

  116.     // -------------------------------------------------------------------

  117.     // Information (per-plugin data)

  118. 

  119.     uint getOptionsAvailable() const noexcept override

  120.     {

  121.         // TODO

  122.         return 0x0;

  123.     }

  124. 

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

  126.     {

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

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

  129. 

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

  131.         AudioUnitParameterValue value = 0.f;

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

  133.             return value;

  134. 

  135.         return 0.f;

  136.     }

  137. 

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

  139.     {

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

  141.         return true;

  142.     }

  143. 

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

  145.     {

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

  147.         return true;

  148.     }

  149. 

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

  151.     {

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

  153.         return true;

  154.     }

  155. 

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

  157.     {

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

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

  160. 

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

  162.         AudioUnitParameterInfo info = {};

  163.         UInt32 outDataSize = sizeof(AudioUnitParameterInfo);

  164. 

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

  166.         {

  167.             if (info.flags & kAudioUnitParameterFlag_HasCFNameString)

  168.             {

  169.                 *strBuf = '\0';

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

  171.                 {

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

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

  174.                 }

  175.                 else

  176.                 {

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

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

  179.                 }

  180. 

  181.                 if (info.flags & kAudioUnitParameterFlag_CFNameRelease)

  182.                     CFRelease(info.cfNameString);

  183. 

  184.                 return true;

  185.             }

  186. 

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

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

  189.             return true;

  190.         }

  191. 

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

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

  194.     }

  195. 

  196.     // -------------------------------------------------------------------

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

  198. 

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

  200.     {

  201.         CARLA_SAFE_ASSERT_RETURN(fInterface != nullptr,);

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

  203. 

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

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

  206. 

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

  208. 

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

  210.     }

  211. 

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

  213.     {

  214.         CARLA_SAFE_ASSERT_RETURN(fInterface != nullptr,);

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

  216. 

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

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

  219. 

  220.         // TODO use scheduled events

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

  222. 

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

  224.     }

  225. 

  226.     // ----------------------------------------------------------------------------------------------------------------

  227.     // Plugin state

  228. 

  229.     void reload() override

  230.     {

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

  232.         CARLA_SAFE_ASSERT_RETURN(fInterface != nullptr,);

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

  234. 

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

  236. 

  237.         // Safely disable plugin for reload

  238.         const ScopedDisabler sd(this);

  239. 

  240.         if (pData->active)

  241.             deactivate();

  242. 

  243.         clearBuffers();

  244. 

  245.         uint32_t audioIns, audioOuts, parametersIns, parametersOuts;

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

  247. 

  248.         bool needsCtrlIn, needsCtrlOut, hasMidiIn, hasMidiOut;

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

  250. 

  251.         CarlaString portName;

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

  253. 

  254.         UInt32 outDataSize;

  255.         Boolean outWritable = false;

  256. 

  257.         // audio ports

  258.         outDataSize = 0;

  259.         if (fFunctions.getPropertyInfo(fInterface,

  260.                                        kAudioUnitProperty_SupportedNumChannels,

  261.                                        kAudioUnitScope_Global,

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

  263.             && outDataSize != 0

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

  265.         {

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

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

  268. 

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

  270. 

  271.             if (fFunctions.getProperty(fInterface,

  272.                                        kAudioUnitProperty_SupportedNumChannels,

  273.                                        kAudioUnitScope_Global,

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

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

  276.             {

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

  278. 

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

  280.                              channelInfo[0].inChannels,

  281.                              channelInfo[0].outChannels);

  282. 

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

  284.                 {

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

  286.                         channelInfo[i].inChannels = 2;

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

  288.                         channelInfo[i].outChannels = 2;

  289. 

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

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

  292.                     {

  293.                         highestInfo = &channelInfo[i];

  294.                     }

  295.                 }

  296. 

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

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

  299.             }

  300.             else

  301.             {

  302.                 carla_stdout("kAudioUnitProperty_SupportedNumChannels failed");

  303.             }

  304. 

  305.             delete[] channelInfo;

  306.         }

  307.         else

  308.         {

  309.             outDataSize = 0;

  310.             if (fFunctions.getPropertyInfo(fInterface,

  311.                                            kAudioUnitProperty_ElementCount,

  312.                                            kAudioUnitScope_Input,

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

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

  315.             {

  316.                 UInt32 count = 0;

  317.                 if (fFunctions.getProperty(fInterface,

  318.                                            kAudioUnitProperty_ElementCount,

  319.                                            kAudioUnitScope_Input,

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

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

  322.                 {

  323.                     AudioStreamBasicDescription desc;

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

  325.                     outDataSize = sizeof(AudioStreamBasicDescription);

  326. 

  327.                     if (fFunctions.getProperty(fInterface,

  328.                                                kAudioUnitProperty_StreamFormat,

  329.                                                kAudioUnitScope_Input,

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

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

  332.                 }

  333.             }

  334. 

  335.             outDataSize = 0;

  336.             if (fFunctions.getPropertyInfo(fInterface,

  337.                                            kAudioUnitProperty_ElementCount,

  338.                                            kAudioUnitScope_Output,

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

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

  341.             {

  342.                 UInt32 count = 0;

  343.                 if (fFunctions.getProperty(fInterface,

  344.                                            kAudioUnitProperty_ElementCount,

  345.                                            kAudioUnitScope_Output,

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

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

  348.                 {

  349.                     AudioStreamBasicDescription desc;

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

  351.                     outDataSize = sizeof(AudioStreamBasicDescription);

  352. 

  353.                     if (fFunctions.getProperty(fInterface,

  354.                                                kAudioUnitProperty_StreamFormat,

  355.                                                kAudioUnitScope_Output,

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

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

  358.                 }

  359.             }

  360.         }

  361. 

  362.         if (audioIns > 0)

  363.         {

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

  365.         }

  366. 

  367.         if (audioOuts > 0)

  368.         {

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

  370.             needsCtrlIn = true;

  371.         }

  372. 

  373.         std::free(fAudioBufferData);

  374. 

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

  376.         {

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

  378.             fAudioBufferData->mNumberBuffers = numBuffers;

  379. 

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

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

  382.         }

  383.         else

  384.         {

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

  386.             fAudioBufferData->mNumberBuffers = 0;

  387.         }

  388. 

  389.         // Audio Ins

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

  391.         {

  392.             portName.clear();

  393. 

  394.             if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  395.             {

  396.                 portName  = pData->name;

  397.                 portName += ":";

  398.             }

  399. 

  400.             if (audioIns > 1)

  401.             {

  402.                 portName += "input_";

  403.                 portName += CarlaString(i + 1);

  404.             }

  405.             else

  406.                 portName += "input";

  407. 

  408.             portName.truncate(portNameSize);

  409. 

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

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

  412.         }

  413. 

  414.         // Audio Outs

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

  416.         {

  417.             portName.clear();

  418. 

  419.             if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  420.             {

  421.                 portName  = pData->name;

  422.                 portName += ":";

  423.             }

  424. 

  425.             if (audioOuts > 1)

  426.             {

  427.                 portName += "output_";

  428.                 portName += CarlaString(i + 1);

  429.             }

  430.             else

  431.                 portName += "output";

  432. 

  433.             portName.truncate(portNameSize);

  434. 

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

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

  437.         }

  438. 

  439.         // parameters

  440.         outDataSize = 0;

  441.         if (fFunctions.getPropertyInfo(fInterface,

  442.                                        kAudioUnitProperty_ParameterList,

  443.                                        kAudioUnitScope_Global,

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

  445.             && outDataSize != 0

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

  447.         {

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

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

  450. 

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

  452.             {

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

  454. 

  455.                 AudioUnitParameterInfo info;

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

  457. 

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

  459.                 {

  460.                     carla_zeroStruct(info);

  461. 

  462.                     outDataSize = 0;

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

  464.                         break;

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

  466.                         break;

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

  468.                         break;

  469. 

  470.                     if (info.flags & kAudioUnitParameterFlag_CFNameRelease)

  471.                         CFRelease(info.cfNameString);

  472. 

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

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

  475. 

  476.                     if (info.flags & kAudioUnitParameterFlag_IsWritable)

  477.                     {

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

  479.                         needsCtrlIn = true;

  480.                     }

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

  482.                     {

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

  484.                         needsCtrlOut = true;

  485.                     }

  486.                     else

  487.                     {

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

  489.                         continue;

  490.                     }

  491. 

  492.                     min = info.minValue;

  493.                     max = info.maxValue;

  494.                     def = info.defaultValue;

  495. 

  496.                     if (min > max)

  497.                         max = min;

  498. 

  499.                     if (carla_isEqual(min, max))

  500.                     {

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

  502.                         max = min + 0.1f;

  503.                     }

  504. 

  505.                     if (def < min)

  506.                         def = min;

  507.                     else if (def > max)

  508.                         def = max;

  509. 

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

  511. 

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

  513.                     {

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

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

  516.                     }

  517. 

  518.                     if (info.unit == kAudioUnitParameterUnit_Boolean)

  519.                     {

  520.                         step = max - min;

  521.                         stepSmall = step;

  522.                         stepLarge = step;

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

  524.                     }

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

  526.                     {

  527.                         step = 1.0f;

  528.                         stepSmall = 1.0f;

  529.                         stepLarge = 10.0f;

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

  531.                     }

  532.                     else

  533.                     {

  534.                         float range = max - min;

  535.                         step = range/100.0f;

  536.                         stepSmall = range/1000.0f;

  537.                         stepLarge = range/10.0f;

  538.                     }

  539. 

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

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

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

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

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

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

  546.                 }

  547.             }

  548. 

  549.             delete[] paramIds;

  550.         }

  551. 

  552.         if (needsCtrlIn || hasMidiIn)

  553.         {

  554.             portName.clear();

  555. 

  556.             if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  557.             {

  558.                 portName  = pData->name;

  559.                 portName += ":";

  560.             }

  561. 

  562.             portName += "events-in";

  563.             portName.truncate(portNameSize);

  564. 

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

  566. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  568. #endif

  569.         }

  570. 

  571.         if (needsCtrlOut || hasMidiOut)

  572.         {

  573.             portName.clear();

  574. 

  575.             if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)

  576.             {

  577.                 portName  = pData->name;

  578.                 portName += ":";

  579.             }

  580. 

  581.             portName += "events-out";

  582.             portName.truncate(portNameSize);

  583. 

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

  585.         }

  586. 

  587.         // plugin hints

  588.         pData->hints = 0x0;

  589. 

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

  591.             pData->hints |= PLUGIN_CAN_DRYWET;

  592. 

  593.         if (audioOuts > 0)

  594.             pData->hints |= PLUGIN_CAN_VOLUME;

  595. 

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

  597.             pData->hints |= PLUGIN_CAN_BALANCE;

  598. 

  599.         // extra plugin hints

  600.         pData->extraHints = 0x0;

  601. 

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

  603.         reloadPrograms(true);

  604. 

  605.         if (pData->active)

  606.             activate();

  607. 

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

  609.     }

  610. 

  611.     // -------------------------------------------------------------------

  612.     // Plugin processing

  613. 

  614.     void activate() noexcept override

  615.     {

  616.         CARLA_SAFE_ASSERT_RETURN(fInterface != nullptr,);

  617. 

  618.         AudioStreamBasicDescription streamFormat = {

  619.             .mFormatID         = kAudioFormatLinearPCM,

  620.             .mBitsPerChannel   = 32,

  621.             .mBytesPerFrame    = sizeof(float),

  622.             .mBytesPerPacket   = sizeof(float),

  623.             .mFramesPerPacket  = 1,

  624.             .mFormatFlags      = kAudioFormatFlagsNativeFloatPacked | kAudioFormatFlagIsNonInterleaved,

  625.             .mChannelsPerFrame = 0,

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

  627.         };

  628. 

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

  630.         {

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

  632.             CARLA_SAFE_ASSERT_RETURN(fFunctions.setProperty(fInterface,

  633.                                                             kAudioUnitProperty_StreamFormat,

  634.                                                             kAudioUnitScope_Input,

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

  636.         }

  637. 

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

  639.         {

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

  641.             CARLA_SAFE_ASSERT_RETURN(fFunctions.setProperty(fInterface,

  642.                                                             kAudioUnitProperty_StreamFormat,

  643.                                                             kAudioUnitScope_Output,

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

  645.         }

  646. 

  647.         fFunctions.initialize(fInterface);

  648.     }

  649. 

  650.     void deactivate() noexcept override

  651.     {

  652.         CARLA_SAFE_ASSERT_RETURN(fInterface != nullptr,);

  653. 

  654.         fFunctions.uninitialize(fInterface);

  655.     }

  656. 

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

  658.                  float** const audioOut,

  659.                  const float* const* const,

  660.                  float** const,

  661.                  const uint32_t frames) override

  662.     {

  663.         // ------------------------------------------------------------------------------------------------------------

  664.         // Check if active

  665. 

  666.         if (! pData->active)

  667.         {

  668.             // disable any output sound

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

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

  671.             return;

  672.         }

  673. 

  674.         // ------------------------------------------------------------------------------------------------------------

  675.         // Check buffers

  676. 

  677.         CARLA_SAFE_ASSERT_RETURN(frames > 0,);

  678. 

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

  680.         {

  681.             CARLA_SAFE_ASSERT_RETURN(audioIn != nullptr,);

  682.         }

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

  684.         {

  685.             CARLA_SAFE_ASSERT_RETURN(audioOut != nullptr,);

  686.         }

  687. 

  688.         // ------------------------------------------------------------------------------------------------------------

  689.         // Try lock, silence otherwise

  690. 

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

  692.         {

  693.             pData->singleMutex.lock();

  694.         }

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

  696.         {

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

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

  699.             return;

  700.         }

  701. 

  702.         // ------------------------------------------------------------------------------------------------------------

  703.         // Check if needs reset

  704. 

  705.         if (pData->needsReset)

  706.         {

  707.             // TODO

  708.         }

  709. 

  710.         // ------------------------------------------------------------------------------------------------------------

  711.         // Event Input (main port)

  712. 

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

  714.         {

  715.             // TODO

  716.         }

  717. 

  718.         // ------------------------------------------------------------------------------------------------------------

  719.         // Plugin processing

  720. 

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

  722. 

  723.         AudioUnitRenderActionFlags actionFlags = kAudioUnitRenderAction_DoNotCheckRenderArgs;

  724.         AudioTimeStamp timeStamp = {};

  725.         timeStamp.mFlags = kAudioTimeStampSampleTimeValid;

  726.         timeStamp.mSampleTime = timeInfo.frame;

  727.         const UInt32 inBusNumber = 0;

  728. 

  729.         {

  730.             uint32_t i = 0;

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

  732.             {

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

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

  735. 

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

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

  738.             }

  739. 

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

  741.             {

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

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

  744.             }

  745.         }

  746. 

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

  748. 

  749.         // ------------------------------------------------------------------------------------------------------------

  750. 

  751.         pData->singleMutex.unlock();

  752. 

  753.        #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  754.         // ------------------------------------------------------------------------------------------------------------

  755.         // Control Output

  756. 

  757.         // TODO

  758.        #endif

  759. 

  760.         // ------------------------------------------------------------------------------------------------------------

  761.         // Events/MIDI Output

  762. 

  763.         // TODO

  764.     }

  765. 

  766.     // ----------------------------------------------------------------------------------------------------------------

  767. 

  768. protected:

  769.     void handlePluginUIClosed() override

  770.     {

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

  772. 

  773.         // TODO

  774.     }

  775. 

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

  777.     {

  778.         // TODO

  779.     }

  780. 

  781.     // -------------------------------------------------------------------

  782. 

  783. public:

  784.     bool init(const CarlaPluginPtr plugin,

  785.               const char* const filename,

  786.               const char* const label,

  787.               const char* const name,

  788.               const uint options)

  789.     {

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

  791. 

  792.         // ---------------------------------------------------------------

  793.         // first checks

  794. 

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

  796.         {

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

  798.             return false;

  799.         }

  800. 

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

  802.         {

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

  804.             return false;

  805.         }

  806. 

  807.         // ---------------------------------------------------------------

  808.         // load bundle information

  809. 

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

  811.         {

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

  813.             return false;

  814.         }

  815. 

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

  817. 

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

  819.         {

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

  821.             return false;

  822.         }

  823. 

  824.         // ---------------------------------------------------------------

  825.         // find binary matching requested label

  826. 

  827.         CFStringRef componentName;

  828.         AudioComponentDescription desc = {};

  829.         FactoryFn factoryFn;

  830. 

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

  832. 

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

  834.         {

  835.             // reset

  836.             desc.componentType = 0;

  837. 

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

  839.             CARLA_SAFE_ASSERT_CONTINUE(componentRef != nullptr);

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

  841. 

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

  843. 

  844.             componentName = nullptr;

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

  846. 

  847.             CFStringRef componentFactoryFunction = nullptr;

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

  849. 

  850.             CFStringRef componentType = nullptr;

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

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

  853. 

  854.             CFStringRef componentSubType = nullptr;

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

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

  857. 

  858.             CFStringRef componentManufacturer = nullptr;

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

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

  861. 

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

  863.             CARLA_SAFE_ASSERT_CONTINUE(factoryFn != nullptr);

  864. 

  865.             char clabel[15] = {};

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

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

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

  869. 

  870.             desc.componentType = getFourCharCodeFromString(clabel);

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

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

  873. 

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

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

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

  877. 

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

  879. 

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

  881.                 break;

  882.         }

  883. 

  884.         if (desc.componentType == 0)

  885.         {

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

  887.             return false;

  888.         }

  889. 

  890.         // ---------------------------------------------------------------

  891.         // load binary

  892. 

  893.         fInterface = factoryFn(&desc);

  894.         

  895.         if (fInterface == nullptr)

  896.         {

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

  898.             return false;

  899.         }

  900. 

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

  902.         {

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

  904.             fInterface = nullptr;

  905.             return false;

  906.         }

  907. 

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

  909.         {

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

  911.             fInterface->Close(fInterface);

  912.             fInterface = nullptr;

  913.             return false;

  914.         }

  915. 

  916.         // ---------------------------------------------------------------

  917.         // get info

  918. 

  919.         const CFIndex componentNameLen = CFStringGetLength(componentName);

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

  921. 

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

  923.         {

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

  925.             {

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

  927.                 fName = sep + 2;

  928.                 fMaker = nameBuffer;

  929.             }

  930.             else

  931.             {

  932.                 fName = nameBuffer;

  933.                 fMaker = nameBuffer + componentNameLen;

  934.             }

  935.         }

  936. 

  937.         fLabel = label;

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

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

  940. 

  941.         delete[] nameBuffer;

  942. 

  943.         // ---------------------------------------------------------------

  944.         // register client

  945. 

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

  947. 

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

  949.         {

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

  951.             return false;

  952.         }

  953. 

  954.         // ------------------------------------------------------------------------------------------------------------

  955.         // init component

  956. 

  957.         {

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

  959. 

  960.             if (fFunctions.setProperty(fInterface,

  961.                                        kAudioUnitProperty_MaximumFramesPerSlice,

  962.                                        kAudioUnitScope_Global,

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

  964.             {

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

  966.                 return false;

  967.             }

  968.         }

  969. 

  970.         {

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

  972. 

  973.             // input scope

  974.             UInt32 outDataSize = 0;

  975.             Boolean outWritable = false;

  976.             if (fFunctions.getPropertyInfo(fInterface,

  977.                                            kAudioUnitProperty_ElementCount,

  978.                                            kAudioUnitScope_Input,

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

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

  981.             {

  982.                 UInt32 outData = 0;

  983.                 if (fFunctions.getProperty(fInterface,

  984.                                            kAudioUnitProperty_ElementCount,

  985.                                            kAudioUnitScope_Input,

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

  987.                     && outData != 0)

  988.                 {

  989.                     if (fFunctions.setProperty(fInterface,

  990.                                                kAudioUnitProperty_SampleRate,

  991.                                                kAudioUnitScope_Input,

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

  993.                     {

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

  995.                         return false;

  996.                     }

  997.                 }

  998.             }

  999. 

  1000.             // output scope

  1001.             outDataSize = 0;

  1002.             outWritable = false;

  1003.             if (fFunctions.getPropertyInfo(fInterface,

  1004.                                            kAudioUnitProperty_ElementCount,

  1005.                                            kAudioUnitScope_Output,

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

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

  1008.             {

  1009.                 UInt32 outData = 0;

  1010.                 if (fFunctions.getProperty(fInterface,

  1011.                                            kAudioUnitProperty_ElementCount,

  1012.                                            kAudioUnitScope_Output,

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

  1014.                     && outData != 0)

  1015.                 {

  1016.                     if (fFunctions.setProperty(fInterface,

  1017.                                                kAudioUnitProperty_SampleRate,

  1018.                                                kAudioUnitScope_Output,

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

  1020.                     {

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

  1022.                         return false;

  1023.                     }

  1024.                 }

  1025.             }

  1026.         }

  1027. 

  1028.         // ------------------------------------------------------------------------------------------------------------

  1029.         // set default options

  1030. 

  1031.         pData->options = PLUGIN_OPTION_FIXED_BUFFERS;

  1032. 

  1033.         return true;

  1034.     }

  1035. 

  1036. private:

  1037.     BundleLoader fBundleLoader;

  1038.     AudioComponentPlugInInterface* fInterface;

  1039.     AudioBufferList* fAudioBufferData;

  1040.     CarlaString fName;

  1041.     CarlaString fLabel;

  1042.     CarlaString fMaker;

  1043. 

  1044.     struct Functions {

  1045.         InitializeFn initialize;

  1046.         UninitializeFn uninitialize;

  1047.         GetPropertyInfoFn getPropertyInfo;

  1048.         GetPropertyFn getProperty;

  1049.         SetPropertyFn setProperty;

  1050.         GetParameterFn getParameter;

  1051.         SetParameterFn setParameter;

  1052.         ScheduleParametersFn scheduleParameters;

  1053.         ResetFn reset;

  1054.         RenderFn render;

  1055.         MIDIEventFn midiEvent;

  1056. 

  1057.         Functions()

  1058.             : initialize(nullptr),

  1059.               uninitialize(nullptr),

  1060.               getPropertyInfo(nullptr),

  1061.               getProperty(nullptr),

  1062.               setProperty(nullptr),

  1063.               getParameter(nullptr),

  1064.               setParameter(nullptr),

  1065.               scheduleParameters(nullptr),

  1066.               reset(nullptr),

  1067.               render(nullptr),

  1068.               midiEvent(nullptr) {}

  1069. 

  1070.         bool init(AudioComponentPlugInInterface* const interface)

  1071.         {

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

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

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

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

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

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

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

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

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

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

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

  1083. 

  1084.             return initialize != nullptr

  1085.                 && uninitialize != nullptr

  1086.                 && getPropertyInfo != nullptr

  1087.                 && getProperty != nullptr

  1088.                 && setProperty != nullptr

  1089.                 && getParameter != nullptr

  1090.                 && setParameter != nullptr

  1091.                 && scheduleParameters != nullptr

  1092.                 && render != nullptr;

  1093.         }

  1094.     } fFunctions;

  1095. };

  1096. #endif

  1097. 

  1098. // --------------------------------------------------------------------------------------------------------------------

  1099. 

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

  1101. {

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

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

  1104. 

  1105.    #ifdef CARLA_OS_MAC

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

  1107. 

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

  1109.         return nullptr;

  1110. 

  1111.     return plugin;

  1112.    #else

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

  1114.     return nullptr;

  1115.    #endif

  1116. }

  1117. 

  1118. // --------------------------------------------------------------------------------------------------------------------

  1119. 

  1120. CARLA_BACKEND_END_NAMESPACE