DISTRHO
/
Ildaeil
mirror of https://github.com/DISTRHO/Ildaeil.git
1
0
Fork 0
Code Issues 0 Releases 4 Wiki Activity
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.
190 Commits
4 Branches
28MB
Tree: 8987b3b7a4
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '8987b3b7a4'
${ noResults }
Ildaeil/plugins/Common/IldaeilPlugin.cpp

855 lines
31KB
Raw Blame History 

  1. /*

  2.  * DISTRHO Ildaeil Plugin

  3.  * Copyright (C) 2021-2024 Filipe Coelho <falktx@falktx.com>

  4.  *

  5.  * This program is free software; you can redistribute it and/or

  6.  * modify it under the terms of the GNU General Public License as

  7.  * published by the Free Software Foundation; either version 2 of

  8.  * the License, or any later version.

  9.  *

  10.  * This program is distributed in the hope that it will be useful,

  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

  13.  * GNU General Public License for more details.

  14.  *

  15.  * For a full copy of the GNU General Public License see the LICENSE file.

  16.  */

  17. 

  18. #include "IldaeilBasePlugin.hpp"

  19. #include "DistrhoPluginUtils.hpp"

  20. 

  21. #include "CarlaEngine.hpp"

  22. #include "water/files/File.h"

  23. #include "water/streams/MemoryOutputStream.h"

  24. #include "water/xml/XmlDocument.h"

  25. 

  26. START_NAMESPACE_DISTRHO

  27. 

  28. using namespace CARLA_BACKEND_NAMESPACE;

  29. 

  30. // --------------------------------------------------------------------------------------------------------------------

  31. 

  32. static uint32_t host_get_buffer_size(NativeHostHandle);

  33. static double host_get_sample_rate(NativeHostHandle);

  34. static bool host_is_offline(NativeHostHandle);

  35. static const NativeTimeInfo* host_get_time_info(NativeHostHandle handle);

  36. static bool host_write_midi_event(NativeHostHandle handle, const NativeMidiEvent* event);

  37. static void host_ui_parameter_changed(NativeHostHandle handle, uint32_t index, float value);

  38. static void host_ui_midi_program_changed(NativeHostHandle handle, uint8_t channel, uint32_t bank, uint32_t program);

  39. static void host_ui_custom_data_changed(NativeHostHandle handle, const char* key, const char* value);

  40. static void host_ui_closed(NativeHostHandle handle);

  41. static const char* host_ui_open_file(NativeHostHandle handle, bool isDir, const char* title, const char* filter);

  42. static const char* host_ui_save_file(NativeHostHandle handle, bool isDir, const char* title, const char* filter);

  43. static intptr_t host_dispatcher(NativeHostHandle h, NativeHostDispatcherOpcode op, int32_t, intptr_t, void*, float);

  44. 

  45. // --------------------------------------------------------------------------------------------------------------------

  46. 

  47. Mutex IldaeilBasePlugin::sPluginInfoLoadMutex;

  48. 

  49. // --------------------------------------------------------------------------------------------------------------------

  50. 

  51. #ifndef CARLA_OS_WIN

  52. static water::String getHomePath()

  53. {

  54.     static water::String path(water::File::getSpecialLocation(water::File::userHomeDirectory).getFullPathName());

  55.     return path;

  56. }

  57. #endif

  58. 

  59. static const char* getPathForLADSPA()

  60. {

  61.     static water::String path;

  62. 

  63.     if (path.isEmpty())

  64.     {

  65.        #if defined(CARLA_OS_HAIKU)

  66.         path = getHomePath() + "/.ladspa:/system/add-ons/media/ladspaplugins:/system/lib/ladspa";

  67.        #elif defined(CARLA_OS_MAC)

  68.         path = getHomePath() + "/Library/Audio/Plug-Ins/LADSPA:/Library/Audio/Plug-Ins/LADSPA";

  69.        #elif defined(CARLA_OS_WASM)

  70.         path = "/ladspa";

  71.        #elif defined(CARLA_OS_WIN)

  72.         path  = water::File::getSpecialLocation(water::File::winAppData).getFullPathName() + "\\LADSPA;";

  73.         path += water::File::getSpecialLocation(water::File::winProgramFiles).getFullPathName() + "\\LADSPA";

  74.        #else

  75.         path  = getHomePath() + "/.ladspa:/usr/lib/ladspa:/usr/local/lib/ladspa";

  76.        #endif

  77.     }

  78. 

  79.     return path.toRawUTF8();

  80. }

  81. 

  82. static const char* getPathForDSSI()

  83. {

  84.     static water::String path;

  85. 

  86.     if (path.isEmpty())

  87.     {

  88.        #if defined(CARLA_OS_HAIKU)

  89.         path = getHomePath() + "/.dssi:/system/add-ons/media/dssiplugins:/system/lib/dssi";

  90.        #elif defined(CARLA_OS_MAC)

  91.         path = getHomePath() + "/Library/Audio/Plug-Ins/DSSI:/Library/Audio/Plug-Ins/DSSI";

  92.        #elif defined(CARLA_OS_WASM)

  93.         path = "/dssi";

  94.        #elif defined(CARLA_OS_WIN)

  95.         path  = water::File::getSpecialLocation(water::File::winAppData).getFullPathName() + "\\DSSI;";

  96.         path += water::File::getSpecialLocation(water::File::winProgramFiles).getFullPathName() + "\\DSSI";

  97.        #else

  98.         path = getHomePath() + "/.dssi:/usr/lib/dssi:/usr/local/lib/dssi";

  99.        #endif

  100.     }

  101. 

  102.     return path.toRawUTF8();

  103. }

  104. 

  105. static const char* getPathForLV2()

  106. {

  107.     static water::String path;

  108. 

  109.     if (path.isEmpty())

  110.     {

  111.        #if defined(CARLA_OS_HAIKU)

  112.         path = getHomePath() + "/.lv2:/system/add-ons/media/lv2plugins";

  113.        #elif defined(CARLA_OS_MAC)

  114.         path = getHomePath() + "/Library/Audio/Plug-Ins/LV2:/Library/Audio/Plug-Ins/LV2";

  115.        #elif defined(CARLA_OS_WASM)

  116.         path = "/lv2";

  117.        #elif defined(CARLA_OS_WIN)

  118.         path  = water::File::getSpecialLocation(water::File::winAppData).getFullPathName() + "\\LV2;";

  119.         path += water::File::getSpecialLocation(water::File::winCommonProgramFiles).getFullPathName() + "\\LV2";

  120.        #else

  121.         path = getHomePath() + "/.lv2:/usr/lib/lv2:/usr/local/lib/lv2";

  122.        #endif

  123.     }

  124. 

  125.     return path.toRawUTF8();

  126. }

  127. 

  128. static const char* getPathForVST2()

  129. {

  130.     static water::String path;

  131. 

  132.     if (path.isEmpty())

  133.     {

  134.        #if defined(CARLA_OS_HAIKU)

  135.         path = getHomePath() + "/.vst:/system/add-ons/media/vstplugins";

  136.        #elif defined(CARLA_OS_MAC)

  137.         path = getHomePath() + "/Library/Audio/Plug-Ins/VST:/Library/Audio/Plug-Ins/VST";

  138.        #elif defined(CARLA_OS_WASM)

  139.         path = "/vst";

  140.        #elif defined(CARLA_OS_WIN)

  141.         path  = water::File::getSpecialLocation(water::File::winProgramFiles).getFullPathName() + "\\VstPlugins;";

  142.         path += water::File::getSpecialLocation(water::File::winProgramFiles).getFullPathName() + "\\Steinberg\\VstPlugins;";

  143.         path += water::File::getSpecialLocation(water::File::winCommonProgramFiles).getFullPathName() + "\\VST2";

  144.        #else

  145.         path = getHomePath() + "/.vst:/usr/lib/vst:/usr/local/lib/vst";

  146. 

  147.         water::String winePrefix;

  148.         if (const char* const envWINEPREFIX = std::getenv("WINEPREFIX"))

  149.             winePrefix = envWINEPREFIX;

  150. 

  151.         if (winePrefix.isEmpty())

  152.             winePrefix = getHomePath() + "/.wine";

  153. 

  154.         if (water::File(winePrefix).exists())

  155.         {

  156.             path += ":" + winePrefix + "/drive_c/Program Files/Common Files/VST2";

  157.             path += ":" + winePrefix + "/drive_c/Program Files/VstPlugins";

  158.             path += ":" + winePrefix + "/drive_c/Program Files/VSTPlugins";

  159.             path += ":" + winePrefix + "/drive_c/Program Files/Steinberg/VstPlugins";

  160.             path += ":" + winePrefix + "/drive_c/Program Files/Steinberg/VSTPlugins";

  161.            #ifdef CARLA_OS_64BIT

  162.             path += ":" + winePrefix + "/drive_c/Program Files (x86)/Common Files/VST2";

  163.             path += ":" + winePrefix + "/drive_c/Program Files (x86)/VstPlugins";

  164.             path += ":" + winePrefix + "/drive_c/Program Files (x86)/VSTPlugins";

  165.             path += ":" + winePrefix + "/drive_c/Program Files (x86)/Steinberg/VstPlugins";

  166.             path += ":" + winePrefix + "/drive_c/Program Files (x86)/Steinberg/VSTPlugins";

  167.            #endif

  168.         }

  169.        #endif

  170.     }

  171. 

  172.     return path.toRawUTF8();

  173. }

  174. 

  175. static const char* getPathForVST3()

  176. {

  177.     static water::String path;

  178. 

  179.     if (path.isEmpty())

  180.     {

  181.        #if defined(CARLA_OS_HAIKU)

  182.         path = getHomePath() + "/.vst3:/system/add-ons/media/vst3plugins";

  183.        #elif defined(CARLA_OS_MAC)

  184.         path = getHomePath() + "/Library/Audio/Plug-Ins/VST3:/Library/Audio/Plug-Ins/VST3";

  185.        #elif defined(CARLA_OS_WASM)

  186.         path = "/vst3";

  187.        #elif defined(CARLA_OS_WIN)

  188.         path  = water::File::getSpecialLocation(water::File::winAppData).getFullPathName() + "\\VST3;";

  189.         path += water::File::getSpecialLocation(water::File::winCommonProgramFiles).getFullPathName() + "\\VST3";

  190.        #else

  191.         path = getHomePath() + "/.vst3:/usr/lib/vst3:/usr/local/lib/vst3";

  192. 

  193.         water::String winePrefix;

  194.         if (const char* const envWINEPREFIX = std::getenv("WINEPREFIX"))

  195.             winePrefix = envWINEPREFIX;

  196. 

  197.         if (winePrefix.isEmpty())

  198.             winePrefix = getHomePath() + "/.wine";

  199. 

  200.         if (water::File(winePrefix).exists())

  201.         {

  202.             path += ":" + winePrefix + "/drive_c/Program Files/Common Files/VST3";

  203.            #ifdef CARLA_OS_64BIT

  204.             path += ":" + winePrefix + "/drive_c/Program Files (x86)/Common Files/VST3";

  205.            #endif

  206.         }

  207.        #endif

  208.     }

  209. 

  210.     return path.toRawUTF8();

  211. }

  212. 

  213. static const char* getPathForCLAP()

  214. {

  215.     static water::String path;

  216. 

  217.     if (path.isEmpty())

  218.     {

  219.        #if defined(CARLA_OS_HAIKU)

  220.         path = getHomePath() + "/.clap:/system/add-ons/media/clapplugins";

  221.        #elif defined(CARLA_OS_MAC)

  222.         path = getHomePath() + "/Library/Audio/Plug-Ins/CLAP:/Library/Audio/Plug-Ins/CLAP";

  223.        #elif defined(CARLA_OS_WASM)

  224.         path = "/clap";

  225.        #elif defined(CARLA_OS_WIN)

  226.         path  = water::File::getSpecialLocation(water::File::winAppData).getFullPathName() + "\\CLAP;";

  227.         path += water::File::getSpecialLocation(water::File::winCommonProgramFiles).getFullPathName() + "\\CLAP";

  228.        #else

  229.         path = getHomePath() + "/.clap:/usr/lib/clap:/usr/local/lib/clap";

  230. 

  231.         water::String winePrefix;

  232.         if (const char* const envWINEPREFIX = std::getenv("WINEPREFIX"))

  233.             winePrefix = envWINEPREFIX;

  234. 

  235.         if (winePrefix.isEmpty())

  236.             winePrefix = getHomePath() + "/.wine";

  237. 

  238.         if (water::File(winePrefix).exists())

  239.         {

  240.             path += ":" + winePrefix + "/drive_c/Program Files/Common Files/CLAP";

  241.            #ifdef CARLA_OS_64BIT

  242.             path += ":" + winePrefix + "/drive_c/Program Files (x86)/Common Files/CLAP";

  243.            #endif

  244.         }

  245.        #endif

  246.     }

  247. 

  248.     return path.toRawUTF8();

  249. }

  250. 

  251. static const char* getPathForJSFX()

  252. {

  253.     static water::String path;

  254. 

  255.     if (path.isEmpty())

  256.     {

  257.        #if defined(CARLA_OS_MAC)

  258.         path = getHomePath()

  259.              + "/Library/Application Support/REAPER/Effects";

  260.         if (! water::File(path).isDirectory())

  261.             path = "/Applications/REAPER.app/Contents/InstallFiles/Effects";

  262.        #elif defined(CARLA_OS_WASM)

  263.         path = "/jsfx";

  264.        #elif defined(CARLA_OS_WIN)

  265.         path = water::File::getSpecialLocation(water::File::winAppData).getFullPathName() + "\\REAPER\\Effects";

  266.         if (! water::File(path).isDirectory())

  267.             path = water::File::getSpecialLocation(water::File::winProgramFiles).getFullPathName()

  268.                  + "\\REAPER\\InstallData\\Effects";

  269.        #else

  270.         if (const char* const configHome = std::getenv("XDG_CONFIG_HOME"))

  271.             path = configHome;

  272.         else

  273.             path = getHomePath() + "/.config";

  274.         path += "/REAPER/Effects";

  275.        #endif

  276.     }

  277. 

  278.     return path.toRawUTF8();

  279. }

  280. 

  281. const char* IldaeilBasePlugin::getPluginPath(const PluginType ptype)

  282. {

  283.     switch (ptype)

  284.     {

  285.     case PLUGIN_LADSPA:

  286.         if (const char* const path = std::getenv("LADSPA_PATH"))

  287.             return path;

  288.         return getPathForLADSPA();

  289.     case PLUGIN_DSSI:

  290.         if (const char* const path = std::getenv("DSSI_PATH"))

  291.             return path;

  292.         return getPathForDSSI();

  293.     case PLUGIN_LV2:

  294.         if (const char* const path = std::getenv("LV2_PATH"))

  295.             return path;

  296.         return getPathForLV2();

  297.     case PLUGIN_VST2:

  298.         if (const char* const path = std::getenv("VST_PATH"))

  299.             return path;

  300.         return getPathForVST2();

  301.     case PLUGIN_VST3:

  302.         if (const char* const path = std::getenv("VST3_PATH"))

  303.             return path;

  304.         return getPathForVST3();

  305.     case PLUGIN_CLAP:

  306.         if (const char* const path = std::getenv("CLAP_PATH"))

  307.             return path;

  308.         return getPathForCLAP();

  309.     case PLUGIN_JSFX:

  310.         return getPathForJSFX();

  311.     default:

  312.         return nullptr;

  313.     }

  314. }

  315. 

  316. // --------------------------------------------------------------------------------------------------------------------

  317. 

  318. const char* ildaeilConfigDir()

  319. {

  320.     static water::String configDir;

  321. 

  322.     if (configDir.isEmpty())

  323.     {

  324.        #if defined(CARLA_OS_WASM)

  325.         configDir = "/userfiles";

  326.        #elif defined(CARLA_OS_MAC)

  327.         configDir = getHomePath() + "/Documents/Ildaeil";

  328.        #elif defined(CARLA_OS_WIN)

  329.         configDir = water::File::getSpecialLocation(water::File::winMyDocuments).getFullPathName() + "\\Ildaeil";

  330.        #else

  331.         if (const char* const xdgEnv = getenv("XDG_CONFIG_HOME"))

  332.             configDir = xdgEnv;

  333.         else

  334.             configDir = getHomePath() + "/.config";

  335.         configDir += "/Ildaeil";

  336.        #endif

  337.     }

  338. 

  339.     return configDir.toRawUTF8();

  340. }

  341. 

  342. // --------------------------------------------------------------------------------------------------------------------

  343. 

  344. class IldaeilPlugin : public IldaeilBasePlugin

  345. {

  346.    #if DISTRHO_PLUGIN_NUM_INPUTS == 0 || DISTRHO_PLUGIN_NUM_OUTPUTS == 0

  347.     float* fDummyBuffer;

  348.     float* fDummyBuffers[2];

  349.    #endif

  350.    #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  351.     static constexpr const uint kMaxMidiEventCount = 512;

  352.     NativeMidiEvent* fMidiEvents;

  353.    #endif

  354. 

  355.     mutable NativeTimeInfo fCarlaTimeInfo;

  356.     mutable water::MemoryOutputStream fLastProjectState;

  357.     uint32_t fLastLatencyValue;

  358. 

  359. public:

  360.     IldaeilPlugin()

  361.         : IldaeilBasePlugin(),

  362.          #if DISTRHO_PLUGIN_NUM_INPUTS == 0 || DISTRHO_PLUGIN_NUM_OUTPUTS == 0

  363.           fDummyBuffer(nullptr),

  364.          #endif

  365.          #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  366.           fMidiEvents(nullptr),

  367.          #endif

  368.           fLastLatencyValue(0)

  369.     {

  370.         fCarlaPluginDescriptor = carla_get_native_rack_plugin();

  371.         DISTRHO_SAFE_ASSERT_RETURN(fCarlaPluginDescriptor != nullptr,);

  372. 

  373.         memset(&fCarlaTimeInfo, 0, sizeof(fCarlaTimeInfo));

  374. 

  375.         fCarlaHostDescriptor.handle = this;

  376.         fCarlaHostDescriptor.resourceDir = carla_get_library_folder();

  377.         fCarlaHostDescriptor.uiName = "Ildaeil";

  378.         fCarlaHostDescriptor.uiParentId = 0;

  379. 

  380.         fCarlaHostDescriptor.get_buffer_size = host_get_buffer_size;

  381.         fCarlaHostDescriptor.get_sample_rate = host_get_sample_rate;

  382.         fCarlaHostDescriptor.is_offline = host_is_offline;

  383. 

  384.         fCarlaHostDescriptor.get_time_info = host_get_time_info;

  385.         fCarlaHostDescriptor.write_midi_event = host_write_midi_event;

  386.         fCarlaHostDescriptor.ui_parameter_changed = host_ui_parameter_changed;

  387.         fCarlaHostDescriptor.ui_midi_program_changed = host_ui_midi_program_changed;

  388.         fCarlaHostDescriptor.ui_custom_data_changed = host_ui_custom_data_changed;

  389.         fCarlaHostDescriptor.ui_closed = host_ui_closed;

  390.         fCarlaHostDescriptor.ui_open_file = host_ui_open_file;

  391.         fCarlaHostDescriptor.ui_save_file = host_ui_save_file;

  392.         fCarlaHostDescriptor.dispatcher = host_dispatcher;

  393. 

  394.         fCarlaPluginHandle = fCarlaPluginDescriptor->instantiate(&fCarlaHostDescriptor);

  395.         DISTRHO_SAFE_ASSERT_RETURN(fCarlaPluginHandle != nullptr,);

  396. 

  397.         fCarlaHostHandle = carla_create_native_plugin_host_handle(fCarlaPluginDescriptor, fCarlaPluginHandle);

  398.         DISTRHO_SAFE_ASSERT_RETURN(fCarlaHostHandle != nullptr,);

  399. 

  400.         const char* const bundlePath = getBundlePath();

  401.        #ifdef CARLA_OS_WIN

  402.         #define EXT ".exe"

  403.        #else

  404.         #define EXT ""

  405.        #endif

  406. 

  407.         if (bundlePath != nullptr

  408.             && water::File(bundlePath + water::String(DISTRHO_OS_SEP_STR "carla-bridge-native" EXT)).existsAsFile())

  409.         {

  410.             fBinaryPath = bundlePath;

  411.             carla_set_engine_option(fCarlaHostHandle, ENGINE_OPTION_PATH_BINARIES, 0, bundlePath);

  412.             carla_set_engine_option(fCarlaHostHandle, ENGINE_OPTION_PATH_RESOURCES, 0, getResourcePath(bundlePath));

  413.         }

  414.        #ifdef CARLA_OS_MAC

  415.         else if (bundlePath != nullptr

  416.             && water::File(bundlePath + water::String("/Contents/MacOS/carla-bridge-native" EXT)).existsAsFile())

  417.         {

  418.             fBinaryPath = bundlePath;

  419.             fBinaryPath += "/Contents/MacOS";

  420.             carla_set_engine_option(fCarlaHostHandle, ENGINE_OPTION_PATH_BINARIES, 0, fBinaryPath);

  421.             carla_set_engine_option(fCarlaHostHandle, ENGINE_OPTION_PATH_RESOURCES, 0, getResourcePath(bundlePath));

  422.         }

  423.        #endif

  424.         else

  425.         {

  426.            #ifdef CARLA_OS_MAC

  427.             fBinaryPath = "/Applications/Carla.app/Contents/MacOS";

  428.             carla_set_engine_option(fCarlaHostHandle, ENGINE_OPTION_PATH_BINARIES, 0, "/Applications/Carla.app/Contents/MacOS");

  429.             carla_set_engine_option(fCarlaHostHandle, ENGINE_OPTION_PATH_RESOURCES, 0, "/Applications/Carla.app/Contents/MacOS/resources");

  430.            #else

  431.             fBinaryPath = "/usr/lib/carla";

  432.             carla_set_engine_option(fCarlaHostHandle, ENGINE_OPTION_PATH_BINARIES, 0, "/usr/lib/carla");

  433.             carla_set_engine_option(fCarlaHostHandle, ENGINE_OPTION_PATH_RESOURCES, 0, "/usr/share/carla/resources");

  434.            #endif

  435.         }

  436. 

  437.         if (fBinaryPath.isNotEmpty())

  438.             carla_stdout("Using binary path for discovery tools: %s", fBinaryPath.buffer());

  439. 

  440.         #undef EXT

  441. 

  442.         carla_set_engine_option(fCarlaHostHandle, ENGINE_OPTION_PLUGIN_PATH, PLUGIN_LADSPA, getPluginPath(PLUGIN_LADSPA));

  443.         carla_set_engine_option(fCarlaHostHandle, ENGINE_OPTION_PLUGIN_PATH, PLUGIN_DSSI, getPluginPath(PLUGIN_DSSI));

  444.         carla_set_engine_option(fCarlaHostHandle, ENGINE_OPTION_PLUGIN_PATH, PLUGIN_LV2, getPluginPath(PLUGIN_LV2));

  445.         carla_set_engine_option(fCarlaHostHandle, ENGINE_OPTION_PLUGIN_PATH, PLUGIN_VST2, getPluginPath(PLUGIN_VST2));

  446.         carla_set_engine_option(fCarlaHostHandle, ENGINE_OPTION_PLUGIN_PATH, PLUGIN_VST3, getPluginPath(PLUGIN_VST3));

  447.         carla_set_engine_option(fCarlaHostHandle, ENGINE_OPTION_PLUGIN_PATH, PLUGIN_CLAP, getPluginPath(PLUGIN_CLAP));

  448.         carla_set_engine_option(fCarlaHostHandle, ENGINE_OPTION_PLUGIN_PATH, PLUGIN_JSFX, getPluginPath(PLUGIN_JSFX));

  449. 

  450.         fCarlaPluginDescriptor->dispatcher(fCarlaPluginHandle, NATIVE_PLUGIN_OPCODE_HOST_USES_EMBED,

  451.                                            0, 0, nullptr, 0.0f);

  452. 

  453.        #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  454.         fMidiEvents = new NativeMidiEvent[kMaxMidiEventCount];

  455.        #endif

  456. 

  457.        #if DISTRHO_PLUGIN_NUM_INPUTS == 0 || DISTRHO_PLUGIN_NUM_OUTPUTS == 0

  458.         // create dummy buffers

  459.         bufferSizeChanged(getBufferSize());

  460.        #endif

  461.     }

  462. 

  463.     ~IldaeilPlugin() override

  464.     {

  465.         if (fCarlaHostHandle != nullptr)

  466.         {

  467.             carla_host_handle_free(fCarlaHostHandle);

  468.            #if DISTRHO_PLUGIN_NUM_INPUTS == 0 || DISTRHO_PLUGIN_NUM_OUTPUTS == 0

  469.             delete[] fDummyBuffer;

  470.            #endif

  471.            #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  472.             delete[] fMidiEvents;

  473.            #endif

  474.         }

  475. 

  476.         if (fCarlaPluginHandle != nullptr)

  477.             fCarlaPluginDescriptor->cleanup(fCarlaPluginHandle);

  478.     }

  479. 

  480.     const NativeTimeInfo* hostGetTimeInfo() const noexcept

  481.     {

  482.         const TimePosition& timePos(getTimePosition());

  483. 

  484.         fCarlaTimeInfo.playing = timePos.playing;

  485.         fCarlaTimeInfo.frame = timePos.frame;

  486.         fCarlaTimeInfo.bbt.valid = timePos.bbt.valid;

  487.         fCarlaTimeInfo.bbt.bar = timePos.bbt.bar;

  488.         fCarlaTimeInfo.bbt.beat = timePos.bbt.beat;

  489.         fCarlaTimeInfo.bbt.tick = timePos.bbt.tick;

  490.         fCarlaTimeInfo.bbt.barStartTick = timePos.bbt.barStartTick;

  491.         fCarlaTimeInfo.bbt.beatsPerBar = timePos.bbt.beatsPerBar;

  492.         fCarlaTimeInfo.bbt.beatType = timePos.bbt.beatType;

  493.         fCarlaTimeInfo.bbt.ticksPerBeat = timePos.bbt.ticksPerBeat;

  494.         fCarlaTimeInfo.bbt.beatsPerMinute = timePos.bbt.beatsPerMinute;

  495. 

  496.         return &fCarlaTimeInfo;

  497.     }

  498. 

  499. #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  500.     bool hostWriteMidiEvent(const NativeMidiEvent* const event)

  501.     {

  502.         MidiEvent midiEvent;

  503.         midiEvent.frame = event->time;

  504.         midiEvent.size = event->size;

  505.         midiEvent.dataExt = nullptr;

  506. 

  507.         uint32_t i = 0;

  508.         for (; i < event->size; ++i)

  509.             midiEvent.data[i] = event->data[i];

  510.         for (; i < MidiEvent::kDataSize; ++i)

  511.             midiEvent.data[i] = 0;

  512. 

  513.         return writeMidiEvent(midiEvent);

  514.     }

  515. #endif

  516. 

  517.     intptr_t hostDispatcher(const NativeHostDispatcherOpcode opcode,

  518.                             const int32_t index, const intptr_t value, void* const ptr, const float opt)

  519.     {

  520.         switch (opcode)

  521.         {

  522.         // cannnot be supported

  523.         case NATIVE_HOST_OPCODE_HOST_IDLE:

  524.             break;

  525.         // other stuff

  526.         case NATIVE_HOST_OPCODE_NULL:

  527.         case NATIVE_HOST_OPCODE_UPDATE_PARAMETER:

  528.         case NATIVE_HOST_OPCODE_UPDATE_MIDI_PROGRAM:

  529.         case NATIVE_HOST_OPCODE_RELOAD_PARAMETERS:

  530.         case NATIVE_HOST_OPCODE_RELOAD_MIDI_PROGRAMS:

  531.         case NATIVE_HOST_OPCODE_RELOAD_ALL:

  532.         case NATIVE_HOST_OPCODE_UI_UNAVAILABLE:

  533.         case NATIVE_HOST_OPCODE_INTERNAL_PLUGIN:

  534.         case NATIVE_HOST_OPCODE_QUEUE_INLINE_DISPLAY:

  535.         case NATIVE_HOST_OPCODE_UI_TOUCH_PARAMETER:

  536.         case NATIVE_HOST_OPCODE_REQUEST_IDLE:

  537.         case NATIVE_HOST_OPCODE_GET_FILE_PATH:

  538.         case NATIVE_HOST_OPCODE_UI_RESIZE:

  539.         case NATIVE_HOST_OPCODE_PREVIEW_BUFFER_DATA:

  540.             // TESTING

  541.             d_stdout("dispatcher %i, %i, %li, %p, %f", opcode, index, value, ptr, opt);

  542.             break;

  543.         }

  544. 

  545.         return 0;

  546.     }

  547. 

  548. protected:

  549.    /* --------------------------------------------------------------------------------------------------------

  550.     * Information */

  551. 

  552.     const char* getLabel() const override

  553.     {

  554. #if ILDAEIL_STANDALONE

  555.         return "Ildaeil";

  556. #elif DISTRHO_PLUGIN_IS_SYNTH

  557.         return "IldaeilSynth";

  558. #elif DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  559.         return "IldaeilMIDI";

  560. #else

  561.         return "IldaeilFX";

  562. #endif

  563.     }

  564. 

  565.     const char* getDescription() const override

  566.     {

  567.         return "Ildaeil is a mini-plugin host working as a plugin, allowing one-to-one plugin format reusage.";

  568.     }

  569. 

  570.     const char* getMaker() const override

  571.     {

  572.         return "DISTRHO";

  573.     }

  574. 

  575.     const char* getHomePage() const override

  576.     {

  577.         return "https://github.com/DISTRHO/Ildaeil";

  578.     }

  579. 

  580.     const char* getLicense() const override

  581.     {

  582.         return "GPLv2+";

  583.     }

  584. 

  585.     uint32_t getVersion() const override

  586.     {

  587.         return d_version(1, 3, 0);

  588.     }

  589. 

  590.     int64_t getUniqueId() const override

  591.     {

  592.        #if ILDAEIL_STANDALONE

  593.         return d_cconst('d', 'I', 'l', 'd');

  594.        #elif DISTRHO_PLUGIN_IS_SYNTH

  595.         return d_cconst('d', 'I', 'l', 'S');

  596.        #elif DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  597.         return d_cconst('d', 'I', 'l', 'M');

  598.        #else

  599.         return d_cconst('d', 'I', 'l', 'F');

  600.        #endif

  601.     }

  602. 

  603.    /* --------------------------------------------------------------------------------------------------------

  604.     * Init */

  605. 

  606.     void initAudioPort(bool input, uint32_t index, AudioPort& port) override

  607.     {

  608.         port.groupId = kPortGroupStereo;

  609.         Plugin::initAudioPort(input, index, port);

  610.     }

  611. 

  612.     void initState(const uint32_t index, State& state) override

  613.     {

  614.         DISTRHO_SAFE_ASSERT_RETURN(index == 0,);

  615. 

  616.         state.hints = kStateIsOnlyForDSP;

  617.         state.key = "project";

  618.         state.defaultValue = ""

  619.         "<?xml version='1.0' encoding='UTF-8'?>\n"

  620.         "<!DOCTYPE CARLA-PROJECT>\n"

  621.         "<CARLA-PROJECT VERSION='" CARLA_VERSION_STRMIN "'>\n"

  622.         "</CARLA-PROJECT>\n";

  623.     }

  624. 

  625.    /* --------------------------------------------------------------------------------------------------------

  626.     * Internal data */

  627. 

  628.     String getState(const char* const key) const override

  629.     {

  630.         if (std::strcmp(key, "project") == 0)

  631.         {

  632.             CarlaEngine* const engine = carla_get_engine_from_handle(fCarlaHostHandle);

  633. 

  634.             fLastProjectState.reset();

  635.             engine->saveProjectInternal(fLastProjectState);

  636.             return String(static_cast<char*>(fLastProjectState.getDataAndRelease()), false);

  637.         }

  638. 

  639.         return String();

  640.     }

  641. 

  642.     void setState(const char* const key, const char* const value) override

  643.     {

  644.         if (std::strcmp(key, "project") == 0)

  645.         {

  646.             CarlaEngine* const engine = carla_get_engine_from_handle(fCarlaHostHandle);

  647. 

  648.             water::XmlDocument xml(value);

  649. 

  650.             {

  651.                 const MutexLocker cml(sPluginInfoLoadMutex);

  652.                 engine->loadProjectInternal(xml, true);

  653.             }

  654. 

  655.             if (fUI != nullptr)

  656.                 ildaeilProjectLoadedFromDSP(fUI);

  657.         }

  658.     }

  659. 

  660.    /* --------------------------------------------------------------------------------------------------------

  661.     * Process */

  662. 

  663.     void checkLatencyChanged()

  664.     {

  665.         if (fCarlaHostHandle == nullptr)

  666.             return;

  667. 

  668.         uint32_t latency = 0;

  669. 

  670.         for (uint32_t i=0; i < carla_get_current_plugin_count(fCarlaHostHandle); ++i)

  671.             latency += carla_get_plugin_latency(fCarlaHostHandle, i);

  672. 

  673.         if (fLastLatencyValue != latency)

  674.         {

  675.             fLastLatencyValue = latency;

  676.             setLatency(latency);

  677.         }

  678.     }

  679. 

  680.     void activate() override

  681.     {

  682.         if (fCarlaPluginHandle != nullptr)

  683.             fCarlaPluginDescriptor->activate(fCarlaPluginHandle);

  684. 

  685.         checkLatencyChanged();

  686.     }

  687. 

  688.     void deactivate() override

  689.     {

  690.         checkLatencyChanged();

  691. 

  692.         if (fCarlaPluginHandle != nullptr)

  693.             fCarlaPluginDescriptor->deactivate(fCarlaPluginHandle);

  694.     }

  695. 

  696. #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  697.     void run(const float** inputs, float** outputs, uint32_t frames,

  698.              const MidiEvent* dpfMidiEvents, uint32_t dpfMidiEventCount) override

  699. #else

  700.     void run(const float** inputs, float** outputs, uint32_t frames) override

  701. #endif

  702.     {

  703.         if (fCarlaPluginHandle != nullptr)

  704.         {

  705.            #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  706.             uint32_t midiEventCount = 0;

  707.             for (uint32_t i=0; i < dpfMidiEventCount; ++i)

  708.             {

  709.                 const MidiEvent& dpfMidiEvent(dpfMidiEvents[i]);

  710.                 if (dpfMidiEvent.size > 4)

  711.                     continue;

  712. 

  713.                 NativeMidiEvent& midiEvent(fMidiEvents[midiEventCount]);

  714. 

  715.                 midiEvent.time = dpfMidiEvent.frame;

  716.                 midiEvent.port = 0;

  717.                 midiEvent.size = dpfMidiEvent.size;

  718.                 std::memcpy(midiEvent.data, dpfMidiEvent.data, midiEvent.size);

  719. 

  720.                 if (++midiEventCount == kMaxMidiEventCount)

  721.                     break;

  722.             }

  723.            #else

  724.             static constexpr const NativeMidiEvent* fMidiEvents = nullptr;

  725.             static constexpr const uint32_t midiEventCount = 0;

  726.            #endif

  727. 

  728.            #if DISTRHO_PLUGIN_NUM_INPUTS == 0

  729.             inputs = (const float**)fDummyBuffers;

  730.            #endif

  731.            #if DISTRHO_PLUGIN_NUM_OUTPUTS == 0

  732.             outputs = fDummyBuffers;

  733.            #endif

  734. 

  735.             fCarlaPluginDescriptor->process(fCarlaPluginHandle, (float**)inputs, outputs, frames,

  736.                                             fMidiEvents, midiEventCount);

  737. 

  738.             checkLatencyChanged();

  739.         }

  740.         else

  741.         {

  742.             std::memset(outputs[0], 0, sizeof(float)*frames);

  743.             std::memset(outputs[1], 0, sizeof(float)*frames);

  744.         }

  745.     }

  746. 

  747.     void bufferSizeChanged(const uint32_t newBufferSize) override

  748.     {

  749.        #if DISTRHO_PLUGIN_NUM_INPUTS == 0 || DISTRHO_PLUGIN_NUM_OUTPUTS == 0

  750.         delete[] fDummyBuffer;

  751.         fDummyBuffer = new float[newBufferSize];

  752.         fDummyBuffers[0] = fDummyBuffer;

  753.         fDummyBuffers[1] = fDummyBuffer;

  754.         std::memset(fDummyBuffer, 0, sizeof(float)*newBufferSize);

  755.        #endif

  756. 

  757.         if (fCarlaPluginHandle != nullptr)

  758.             fCarlaPluginDescriptor->dispatcher(fCarlaPluginHandle, NATIVE_PLUGIN_OPCODE_BUFFER_SIZE_CHANGED,

  759.                                                0, newBufferSize, nullptr, 0.0f);

  760.     }

  761. 

  762.     void sampleRateChanged(const double newSampleRate) override

  763.     {

  764.         if (fCarlaPluginHandle != nullptr)

  765.             fCarlaPluginDescriptor->dispatcher(fCarlaPluginHandle, NATIVE_PLUGIN_OPCODE_SAMPLE_RATE_CHANGED,

  766.                                                0, 0, nullptr, newSampleRate);

  767.     }

  768. 

  769.     // -------------------------------------------------------------------------------------------------------

  770. 

  771.    /**

  772.       Set our plugin class as non-copyable and add a leak detector just in case.

  773.     */

  774.     DISTRHO_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(IldaeilPlugin)

  775. };

  776. 

  777. // -----------------------------------------------------------------------------------------------------------

  778. 

  779. static uint32_t host_get_buffer_size(const NativeHostHandle handle)

  780. {

  781.     return static_cast<IldaeilPlugin*>(handle)->getBufferSize();

  782. }

  783. 

  784. static double host_get_sample_rate(const NativeHostHandle handle)

  785. {

  786.     return static_cast<IldaeilPlugin*>(handle)->getSampleRate();

  787. }

  788. 

  789. static bool host_is_offline(NativeHostHandle)

  790. {

  791.     return false;

  792. }

  793. 

  794. static const NativeTimeInfo* host_get_time_info(const NativeHostHandle handle)

  795. {

  796.     return static_cast<IldaeilPlugin*>(handle)->hostGetTimeInfo();

  797. }

  798. 

  799. static bool host_write_midi_event(const NativeHostHandle handle, const NativeMidiEvent* const event)

  800. {

  801. #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  802.     return static_cast<IldaeilPlugin*>(handle)->hostWriteMidiEvent(event);

  803. #else

  804.     return handle != nullptr && event != nullptr && false;

  805. #endif

  806. }

  807. 

  808. static void host_ui_parameter_changed(const NativeHostHandle handle, const uint32_t index, const float value)

  809. {

  810.     ildaeilParameterChangeForUI(static_cast<IldaeilPlugin*>(handle)->fUI, index, value);

  811. }

  812. 

  813. static void host_ui_midi_program_changed(NativeHostHandle handle, uint8_t channel, uint32_t bank, uint32_t program)

  814. {

  815.     d_stdout("%s %p %u %u %u", __FUNCTION__, handle, channel, bank, program);

  816. }

  817. 

  818. static void host_ui_custom_data_changed(NativeHostHandle handle, const char* key, const char* value)

  819. {

  820.     d_stdout("%s %p %s %s", __FUNCTION__, handle, key, value);

  821. }

  822. 

  823. static void host_ui_closed(NativeHostHandle handle)

  824. {

  825.     ildaeilCloseUI(static_cast<IldaeilPlugin*>(handle));

  826. }

  827. 

  828. static const char* host_ui_open_file(const NativeHostHandle handle, const bool isDir, const char* const title, const char* const filter)

  829. {

  830.     return ildaeilOpenFileForUI(static_cast<IldaeilPlugin*>(handle)->fUI, isDir, title, filter);

  831. }

  832. 

  833. static const char* host_ui_save_file(NativeHostHandle, bool, const char*, const char*)

  834. {

  835.     return nullptr;

  836. }

  837. 

  838. static intptr_t host_dispatcher(const NativeHostHandle handle, const NativeHostDispatcherOpcode opcode,

  839.                                 const int32_t index, const intptr_t value, void* const ptr, const float opt)

  840. {

  841.     return static_cast<IldaeilPlugin*>(handle)->hostDispatcher(opcode, index, value, ptr, opt);

  842. }

  843. 

  844. /* --------------------------------------------------------------------------------------------------------------------

  845.  * Plugin entry point, called by DPF to create a new plugin instance. */

  846. 

  847. Plugin* createPlugin()

  848. {

  849.     return new IldaeilPlugin();

  850. }

  851. 

  852. // --------------------------------------------------------------------------------------------------------------------

  853. 

  854. END_NAMESPACE_DISTRHO