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.
179 Commits
4 Branches
34MB
Tree: 0044a9cca7
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '0044a9cca7'
${ noResults }
Ildaeil/plugins/Common/IldaeilPlugin.cpp

851 lines
31KB
Raw Blame History 

  1. /*

  2.  * DISTRHO Ildaeil Plugin

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

  4.  *

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

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

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

  8.  * the License, or any later version.

  9.  *

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

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

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

  13.  * GNU General Public License for more details.

  14.  *

  15.  * For a full copy of the GNU General Public License see the 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/Steinberg/VstPlugins";

  159.            #ifdef CARLA_OS_64BIT

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

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

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

  163.            #endif

  164.         }

  165.        #endif

  166.     }

  167. 

  168.     return path.toRawUTF8();

  169. }

  170. 

  171. static const char* getPathForVST3()

  172. {

  173.     static water::String path;

  174. 

  175.     if (path.isEmpty())

  176.     {

  177.        #if defined(CARLA_OS_HAIKU)

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

  179.        #elif defined(CARLA_OS_MAC)

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

  181.        #elif defined(CARLA_OS_WASM)

  182.         path = "/vst3";

  183.        #elif defined(CARLA_OS_WIN)

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

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

  186.        #else

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

  188. 

  189.         water::String winePrefix;

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

  191.             winePrefix = envWINEPREFIX;

  192. 

  193.         if (winePrefix.isEmpty())

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

  195. 

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

  197.         {

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

  199.            #ifdef CARLA_OS_64BIT

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

  201.            #endif

  202.         }

  203.        #endif

  204.     }

  205. 

  206.     return path.toRawUTF8();

  207. }

  208. 

  209. static const char* getPathForCLAP()

  210. {

  211.     static water::String path;

  212. 

  213.     if (path.isEmpty())

  214.     {

  215.        #if defined(CARLA_OS_HAIKU)

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

  217.        #elif defined(CARLA_OS_MAC)

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

  219.        #elif defined(CARLA_OS_WASM)

  220.         path = "/clap";

  221.        #elif defined(CARLA_OS_WIN)

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

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

  224.        #else

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

  226. 

  227.         water::String winePrefix;

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

  229.             winePrefix = envWINEPREFIX;

  230. 

  231.         if (winePrefix.isEmpty())

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

  233. 

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

  235.         {

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

  237.            #ifdef CARLA_OS_64BIT

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

  239.            #endif

  240.         }

  241.        #endif

  242.     }

  243. 

  244.     return path.toRawUTF8();

  245. }

  246. 

  247. static const char* getPathForJSFX()

  248. {

  249.     static water::String path;

  250. 

  251.     if (path.isEmpty())

  252.     {

  253.        #if defined(CARLA_OS_MAC)

  254.         path = getHomePath()

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

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

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

  258.        #elif defined(CARLA_OS_WASM)

  259.         path = "/jsfx";

  260.        #elif defined(CARLA_OS_WIN)

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

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

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

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

  265.        #else

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

  267.             path = configHome;

  268.         else

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

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

  271.        #endif

  272.     }

  273. 

  274.     return path.toRawUTF8();

  275. }

  276. 

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

  278. {

  279.     switch (ptype)

  280.     {

  281.     case PLUGIN_LADSPA:

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

  283.             return path;

  284.         return getPathForLADSPA();

  285.     case PLUGIN_DSSI:

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

  287.             return path;

  288.         return getPathForDSSI();

  289.     case PLUGIN_LV2:

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

  291.             return path;

  292.         return getPathForLV2();

  293.     case PLUGIN_VST2:

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

  295.             return path;

  296.         return getPathForVST2();

  297.     case PLUGIN_VST3:

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

  299.             return path;

  300.         return getPathForVST3();

  301.     case PLUGIN_CLAP:

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

  303.             return path;

  304.         return getPathForCLAP();

  305.     case PLUGIN_JSFX:

  306.         return getPathForJSFX();

  307.     default:

  308.         return nullptr;

  309.     }

  310. }

  311. 

  312. // --------------------------------------------------------------------------------------------------------------------

  313. 

  314. const char* ildaeilConfigDir()

  315. {

  316.     static water::String configDir;

  317. 

  318.     if (configDir.isEmpty())

  319.     {

  320.        #if defined(CARLA_OS_WASM)

  321.         configDir = "/userfiles";

  322.        #elif defined(CARLA_OS_MAC)

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

  324.        #elif defined(CARLA_OS_WIN)

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

  326.        #else

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

  328.             configDir = xdgEnv;

  329.         else

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

  331.         configDir += "/Ildaeil";

  332.        #endif

  333.     }

  334. 

  335.     return configDir.toRawUTF8();

  336. }

  337. 

  338. // --------------------------------------------------------------------------------------------------------------------

  339. 

  340. class IldaeilPlugin : public IldaeilBasePlugin

  341. {

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

  343.     float* fDummyBuffer;

  344.     float* fDummyBuffers[2];

  345.    #endif

  346.    #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  347.     static constexpr const uint kMaxMidiEventCount = 512;

  348.     NativeMidiEvent* fMidiEvents;

  349.    #endif

  350. 

  351.     mutable NativeTimeInfo fCarlaTimeInfo;

  352.     mutable water::MemoryOutputStream fLastProjectState;

  353.     uint32_t fLastLatencyValue;

  354. 

  355. public:

  356.     IldaeilPlugin()

  357.         : IldaeilBasePlugin(),

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

  359.           fDummyBuffer(nullptr),

  360.          #endif

  361.          #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  362.           fMidiEvents(nullptr),

  363.          #endif

  364.           fLastLatencyValue(0)

  365.     {

  366.         fCarlaPluginDescriptor = carla_get_native_rack_plugin();

  367.         DISTRHO_SAFE_ASSERT_RETURN(fCarlaPluginDescriptor != nullptr,);

  368. 

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

  370. 

  371.         fCarlaHostDescriptor.handle = this;

  372.         fCarlaHostDescriptor.resourceDir = carla_get_library_folder();

  373.         fCarlaHostDescriptor.uiName = "Ildaeil";

  374.         fCarlaHostDescriptor.uiParentId = 0;

  375. 

  376.         fCarlaHostDescriptor.get_buffer_size = host_get_buffer_size;

  377.         fCarlaHostDescriptor.get_sample_rate = host_get_sample_rate;

  378.         fCarlaHostDescriptor.is_offline = host_is_offline;

  379. 

  380.         fCarlaHostDescriptor.get_time_info = host_get_time_info;

  381.         fCarlaHostDescriptor.write_midi_event = host_write_midi_event;

  382.         fCarlaHostDescriptor.ui_parameter_changed = host_ui_parameter_changed;

  383.         fCarlaHostDescriptor.ui_midi_program_changed = host_ui_midi_program_changed;

  384.         fCarlaHostDescriptor.ui_custom_data_changed = host_ui_custom_data_changed;

  385.         fCarlaHostDescriptor.ui_closed = host_ui_closed;

  386.         fCarlaHostDescriptor.ui_open_file = host_ui_open_file;

  387.         fCarlaHostDescriptor.ui_save_file = host_ui_save_file;

  388.         fCarlaHostDescriptor.dispatcher = host_dispatcher;

  389. 

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

  391.         DISTRHO_SAFE_ASSERT_RETURN(fCarlaPluginHandle != nullptr,);

  392. 

  393.         fCarlaHostHandle = carla_create_native_plugin_host_handle(fCarlaPluginDescriptor, fCarlaPluginHandle);

  394.         DISTRHO_SAFE_ASSERT_RETURN(fCarlaHostHandle != nullptr,);

  395. 

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

  397.        #ifdef CARLA_OS_WIN

  398.         #define EXT ".exe"

  399.        #else

  400.         #define EXT ""

  401.        #endif

  402. 

  403.         if (bundlePath != nullptr

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

  405.         {

  406.             fBinaryPath = bundlePath;

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

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

  409.         }

  410.        #ifdef CARLA_OS_MAC

  411.         else if (bundlePath != nullptr

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

  413.         {

  414.             fBinaryPath = bundlePath;

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

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

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

  418.         }

  419.        #endif

  420.         else

  421.         {

  422.            #ifdef CARLA_OS_MAC

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

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

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

  426.            #else

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

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

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

  430.            #endif

  431.         }

  432. 

  433.         if (fBinaryPath.isNotEmpty())

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

  435. 

  436.         #undef EXT

  437. 

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

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

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

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

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

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

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

  445. 

  446.         fCarlaPluginDescriptor->dispatcher(fCarlaPluginHandle, NATIVE_PLUGIN_OPCODE_HOST_USES_EMBED,

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

  448. 

  449.        #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  450.         fMidiEvents = new NativeMidiEvent[kMaxMidiEventCount];

  451.        #endif

  452. 

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

  454.         // create dummy buffers

  455.         bufferSizeChanged(getBufferSize());

  456.        #endif

  457.     }

  458. 

  459.     ~IldaeilPlugin() override

  460.     {

  461.         if (fCarlaHostHandle != nullptr)

  462.         {

  463.             carla_host_handle_free(fCarlaHostHandle);

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

  465.             delete[] fDummyBuffer;

  466.            #endif

  467.            #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  468.             delete[] fMidiEvents;

  469.            #endif

  470.         }

  471. 

  472.         if (fCarlaPluginHandle != nullptr)

  473.             fCarlaPluginDescriptor->cleanup(fCarlaPluginHandle);

  474.     }

  475. 

  476.     const NativeTimeInfo* hostGetTimeInfo() const noexcept

  477.     {

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

  479. 

  480.         fCarlaTimeInfo.playing = timePos.playing;

  481.         fCarlaTimeInfo.frame = timePos.frame;

  482.         fCarlaTimeInfo.bbt.valid = timePos.bbt.valid;

  483.         fCarlaTimeInfo.bbt.bar = timePos.bbt.bar;

  484.         fCarlaTimeInfo.bbt.beat = timePos.bbt.beat;

  485.         fCarlaTimeInfo.bbt.tick = timePos.bbt.tick;

  486.         fCarlaTimeInfo.bbt.barStartTick = timePos.bbt.barStartTick;

  487.         fCarlaTimeInfo.bbt.beatsPerBar = timePos.bbt.beatsPerBar;

  488.         fCarlaTimeInfo.bbt.beatType = timePos.bbt.beatType;

  489.         fCarlaTimeInfo.bbt.ticksPerBeat = timePos.bbt.ticksPerBeat;

  490.         fCarlaTimeInfo.bbt.beatsPerMinute = timePos.bbt.beatsPerMinute;

  491. 

  492.         return &fCarlaTimeInfo;

  493.     }

  494. 

  495. #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  496.     bool hostWriteMidiEvent(const NativeMidiEvent* const event)

  497.     {

  498.         MidiEvent midiEvent;

  499.         midiEvent.frame = event->time;

  500.         midiEvent.size = event->size;

  501.         midiEvent.dataExt = nullptr;

  502. 

  503.         uint32_t i = 0;

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

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

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

  507.             midiEvent.data[i] = 0;

  508. 

  509.         return writeMidiEvent(midiEvent);

  510.     }

  511. #endif

  512. 

  513.     intptr_t hostDispatcher(const NativeHostDispatcherOpcode opcode,

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

  515.     {

  516.         switch (opcode)

  517.         {

  518.         // cannnot be supported

  519.         case NATIVE_HOST_OPCODE_HOST_IDLE:

  520.             break;

  521.         // other stuff

  522.         case NATIVE_HOST_OPCODE_NULL:

  523.         case NATIVE_HOST_OPCODE_UPDATE_PARAMETER:

  524.         case NATIVE_HOST_OPCODE_UPDATE_MIDI_PROGRAM:

  525.         case NATIVE_HOST_OPCODE_RELOAD_PARAMETERS:

  526.         case NATIVE_HOST_OPCODE_RELOAD_MIDI_PROGRAMS:

  527.         case NATIVE_HOST_OPCODE_RELOAD_ALL:

  528.         case NATIVE_HOST_OPCODE_UI_UNAVAILABLE:

  529.         case NATIVE_HOST_OPCODE_INTERNAL_PLUGIN:

  530.         case NATIVE_HOST_OPCODE_QUEUE_INLINE_DISPLAY:

  531.         case NATIVE_HOST_OPCODE_UI_TOUCH_PARAMETER:

  532.         case NATIVE_HOST_OPCODE_REQUEST_IDLE:

  533.         case NATIVE_HOST_OPCODE_GET_FILE_PATH:

  534.         case NATIVE_HOST_OPCODE_UI_RESIZE:

  535.         case NATIVE_HOST_OPCODE_PREVIEW_BUFFER_DATA:

  536.             // TESTING

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

  538.             break;

  539.         }

  540. 

  541.         return 0;

  542.     }

  543. 

  544. protected:

  545.    /* --------------------------------------------------------------------------------------------------------

  546.     * Information */

  547. 

  548.     const char* getLabel() const override

  549.     {

  550. #if ILDAEIL_STANDALONE

  551.         return "Ildaeil";

  552. #elif DISTRHO_PLUGIN_IS_SYNTH

  553.         return "IldaeilSynth";

  554. #elif DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  555.         return "IldaeilMIDI";

  556. #else

  557.         return "IldaeilFX";

  558. #endif

  559.     }

  560. 

  561.     const char* getDescription() const override

  562.     {

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

  564.     }

  565. 

  566.     const char* getMaker() const override

  567.     {

  568.         return "DISTRHO";

  569.     }

  570. 

  571.     const char* getHomePage() const override

  572.     {

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

  574.     }

  575. 

  576.     const char* getLicense() const override

  577.     {

  578.         return "GPLv2+";

  579.     }

  580. 

  581.     uint32_t getVersion() const override

  582.     {

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

  584.     }

  585. 

  586.     int64_t getUniqueId() const override

  587.     {

  588. #if ILDAEIL_STANDALONE

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

  590. #elif DISTRHO_PLUGIN_IS_SYNTH

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

  592. #elif DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

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

  594. #else

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

  596. #endif

  597.     }

  598. 

  599.    /* --------------------------------------------------------------------------------------------------------

  600.     * Init */

  601. 

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

  603.     {

  604.         port.groupId = kPortGroupStereo;

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

  606.     }

  607. 

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

  609.     {

  610.         DISTRHO_SAFE_ASSERT_RETURN(index == 0,);

  611. 

  612.         state.hints = kStateIsOnlyForDSP;

  613.         state.key = "project";

  614.         state.defaultValue = ""

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

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

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

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

  619.     }

  620. 

  621.    /* --------------------------------------------------------------------------------------------------------

  622.     * Internal data */

  623. 

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

  625.     {

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

  627.         {

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

  629. 

  630.             fLastProjectState.reset();

  631.             engine->saveProjectInternal(fLastProjectState);

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

  633.         }

  634. 

  635.         return String();

  636.     }

  637. 

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

  639.     {

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

  641.         {

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

  643. 

  644.             water::XmlDocument xml(value);

  645. 

  646.             {

  647.                 const MutexLocker cml(sPluginInfoLoadMutex);

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

  649.             }

  650. 

  651.             if (fUI != nullptr)

  652.                 ildaeilProjectLoadedFromDSP(fUI);

  653.         }

  654.     }

  655. 

  656.    /* --------------------------------------------------------------------------------------------------------

  657.     * Process */

  658. 

  659.     void checkLatencyChanged()

  660.     {

  661.         if (fCarlaHostHandle == nullptr)

  662.             return;

  663. 

  664.         uint32_t latency = 0;

  665. 

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

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

  668. 

  669.         if (fLastLatencyValue != latency)

  670.         {

  671.             fLastLatencyValue = latency;

  672.             setLatency(latency);

  673.         }

  674.     }

  675. 

  676.     void activate() override

  677.     {

  678.         if (fCarlaPluginHandle != nullptr)

  679.             fCarlaPluginDescriptor->activate(fCarlaPluginHandle);

  680. 

  681.         checkLatencyChanged();

  682.     }

  683. 

  684.     void deactivate() override

  685.     {

  686.         checkLatencyChanged();

  687. 

  688.         if (fCarlaPluginHandle != nullptr)

  689.             fCarlaPluginDescriptor->deactivate(fCarlaPluginHandle);

  690.     }

  691. 

  692. #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

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

  694.              const MidiEvent* dpfMidiEvents, uint32_t dpfMidiEventCount) override

  695. #else

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

  697. #endif

  698.     {

  699.         if (fCarlaPluginHandle != nullptr)

  700.         {

  701.            #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  702.             uint32_t midiEventCount = 0;

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

  704.             {

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

  706.                 if (dpfMidiEvent.size > 4)

  707.                     continue;

  708. 

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

  710. 

  711.                 midiEvent.time = dpfMidiEvent.frame;

  712.                 midiEvent.port = 0;

  713.                 midiEvent.size = dpfMidiEvent.size;

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

  715. 

  716.                 if (++midiEventCount == kMaxMidiEventCount)

  717.                     break;

  718.             }

  719.            #else

  720.             static constexpr const NativeMidiEvent* fMidiEvents = nullptr;

  721.             static constexpr const uint32_t midiEventCount = 0;

  722.            #endif

  723. 

  724.            #if DISTRHO_PLUGIN_NUM_INPUTS == 0

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

  726.            #endif

  727.            #if DISTRHO_PLUGIN_NUM_OUTPUTS == 0

  728.             outputs = fDummyBuffers;

  729.            #endif

  730. 

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

  732.                                             fMidiEvents, midiEventCount);

  733. 

  734.             checkLatencyChanged();

  735.         }

  736.         else

  737.         {

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

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

  740.         }

  741.     }

  742. 

  743.     void bufferSizeChanged(const uint32_t newBufferSize) override

  744.     {

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

  746.         delete[] fDummyBuffer;

  747.         fDummyBuffer = new float[newBufferSize];

  748.         fDummyBuffers[0] = fDummyBuffer;

  749.         fDummyBuffers[1] = fDummyBuffer;

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

  751.        #endif

  752. 

  753.         if (fCarlaPluginHandle != nullptr)

  754.             fCarlaPluginDescriptor->dispatcher(fCarlaPluginHandle, NATIVE_PLUGIN_OPCODE_BUFFER_SIZE_CHANGED,

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

  756.     }

  757. 

  758.     void sampleRateChanged(const double newSampleRate) override

  759.     {

  760.         if (fCarlaPluginHandle != nullptr)

  761.             fCarlaPluginDescriptor->dispatcher(fCarlaPluginHandle, NATIVE_PLUGIN_OPCODE_SAMPLE_RATE_CHANGED,

  762.                                                0, 0, nullptr, newSampleRate);

  763.     }

  764. 

  765.     // -------------------------------------------------------------------------------------------------------

  766. 

  767.    /**

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

  769.     */

  770.     DISTRHO_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(IldaeilPlugin)

  771. };

  772. 

  773. // -----------------------------------------------------------------------------------------------------------

  774. 

  775. static uint32_t host_get_buffer_size(const NativeHostHandle handle)

  776. {

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

  778. }

  779. 

  780. static double host_get_sample_rate(const NativeHostHandle handle)

  781. {

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

  783. }

  784. 

  785. static bool host_is_offline(NativeHostHandle)

  786. {

  787.     return false;

  788. }

  789. 

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

  791. {

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

  793. }

  794. 

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

  796. {

  797. #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

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

  799. #else

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

  801. #endif

  802. }

  803. 

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

  805. {

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

  807. }

  808. 

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

  810. {

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

  812. }

  813. 

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

  815. {

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

  817. }

  818. 

  819. static void host_ui_closed(NativeHostHandle handle)

  820. {

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

  822. }

  823. 

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

  825. {

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

  827. }

  828. 

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

  830. {

  831.     return nullptr;

  832. }

  833. 

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

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

  836. {

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

  838. }

  839. 

  840. /* --------------------------------------------------------------------------------------------------------------------

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

  842. 

  843. Plugin* createPlugin()

  844. {

  845.     return new IldaeilPlugin();

  846. }

  847. 

  848. // --------------------------------------------------------------------------------------------------------------------

  849. 

  850. END_NAMESPACE_DISTRHO