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

849 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. static water::String getHomePath()

  52. {

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

  54.     return path;

  55. }

  56. 

  57. static const char* getPathForLADSPA()

  58. {

  59.     static water::String path;

  60. 

  61.     if (path.isEmpty())

  62.     {

  63.        #if defined(CARLA_OS_HAIKU)

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

  65.        #elif defined(CARLA_OS_MAC)

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

  67.        #elif defined(CARLA_OS_WASM)

  68.         path = "/ladspa";

  69.        #elif defined(CARLA_OS_WIN)

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

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

  72.        #else

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

  74.        #endif

  75.     }

  76. 

  77.     return path.toRawUTF8();

  78. }

  79. 

  80. static const char* getPathForDSSI()

  81. {

  82.     static water::String path;

  83. 

  84.     if (path.isEmpty())

  85.     {

  86.        #if defined(CARLA_OS_HAIKU)

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

  88.        #elif defined(CARLA_OS_MAC)

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

  90.        #elif defined(CARLA_OS_WASM)

  91.         path = "/dssi";

  92.        #elif defined(CARLA_OS_WIN)

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

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

  95.        #else

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

  97.        #endif

  98.     }

  99. 

  100.     return path.toRawUTF8();

  101. }

  102. 

  103. static const char* getPathForLV2()

  104. {

  105.     static water::String path;

  106. 

  107.     if (path.isEmpty())

  108.     {

  109.        #if defined(CARLA_OS_HAIKU)

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

  111.        #elif defined(CARLA_OS_MAC)

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

  113.        #elif defined(CARLA_OS_WASM)

  114.         path = "/lv2";

  115.        #elif defined(CARLA_OS_WIN)

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

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

  118.        #else

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

  120.        #endif

  121.     }

  122. 

  123.     return path.toRawUTF8();

  124. }

  125. 

  126. static const char* getPathForVST2()

  127. {

  128.     static water::String path;

  129. 

  130.     if (path.isEmpty())

  131.     {

  132.        #if defined(CARLA_OS_HAIKU)

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

  134.        #elif defined(CARLA_OS_MAC)

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

  136.        #elif defined(CARLA_OS_WASM)

  137.         path = "/vst";

  138.        #elif defined(CARLA_OS_WIN)

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

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

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

  142.        #else

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

  144. 

  145.         water::String winePrefix;

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

  147.             winePrefix = envWINEPREFIX;

  148. 

  149.         if (winePrefix.isEmpty())

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

  151. 

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

  153.         {

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

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

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

  157.            #ifdef CARLA_OS_64BIT

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

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

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

  161.            #endif

  162.         }

  163.        #endif

  164.     }

  165. 

  166.     return path.toRawUTF8();

  167. }

  168. 

  169. static const char* getPathForVST3()

  170. {

  171.     static water::String path;

  172. 

  173.     if (path.isEmpty())

  174.     {

  175.        #if defined(CARLA_OS_HAIKU)

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

  177.        #elif defined(CARLA_OS_MAC)

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

  179.        #elif defined(CARLA_OS_WASM)

  180.         path = "/vst3";

  181.        #elif defined(CARLA_OS_WIN)

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

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

  184.        #else

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

  186. 

  187.         water::String winePrefix;

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

  189.             winePrefix = envWINEPREFIX;

  190. 

  191.         if (winePrefix.isEmpty())

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

  193. 

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

  195.         {

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

  197.            #ifdef CARLA_OS_64BIT

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

  199.            #endif

  200.         }

  201.        #endif

  202.     }

  203. 

  204.     return path.toRawUTF8();

  205. }

  206. 

  207. static const char* getPathForCLAP()

  208. {

  209.     static water::String path;

  210. 

  211.     if (path.isEmpty())

  212.     {

  213.        #if defined(CARLA_OS_HAIKU)

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

  215.        #elif defined(CARLA_OS_MAC)

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

  217.        #elif defined(CARLA_OS_WASM)

  218.         path = "/clap";

  219.        #elif defined(CARLA_OS_WIN)

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

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

  222.        #else

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

  224. 

  225.         water::String winePrefix;

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

  227.             winePrefix = envWINEPREFIX;

  228. 

  229.         if (winePrefix.isEmpty())

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

  231. 

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

  233.         {

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

  235.            #ifdef CARLA_OS_64BIT

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

  237.            #endif

  238.         }

  239.        #endif

  240.     }

  241. 

  242.     return path.toRawUTF8();

  243. }

  244. 

  245. static const char* getPathForJSFX()

  246. {

  247.     static water::String path;

  248. 

  249.     if (path.isEmpty())

  250.     {

  251.        #if defined(CARLA_OS_MAC)

  252.         path = getHomePath()

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

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

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

  256.        #elif defined(CARLA_OS_WASM)

  257.         path = "/jsfx";

  258.        #elif defined(CARLA_OS_WIN)

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

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

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

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

  263.        #else

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

  265.             path = configHome;

  266.         else

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

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

  269.        #endif

  270.     }

  271. 

  272.     return path.toRawUTF8();

  273. }

  274. 

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

  276. {

  277.     switch (ptype)

  278.     {

  279.     case PLUGIN_LADSPA:

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

  281.             return path;

  282.         return getPathForLADSPA();

  283.     case PLUGIN_DSSI:

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

  285.             return path;

  286.         return getPathForDSSI();

  287.     case PLUGIN_LV2:

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

  289.             return path;

  290.         return getPathForLV2();

  291.     case PLUGIN_VST2:

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

  293.             return path;

  294.         return getPathForVST2();

  295.     case PLUGIN_VST3:

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

  297.             return path;

  298.         return getPathForVST3();

  299.     case PLUGIN_CLAP:

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

  301.             return path;

  302.         return getPathForCLAP();

  303.     case PLUGIN_JSFX:

  304.         return getPathForJSFX();

  305.     default:

  306.         return nullptr;

  307.     }

  308. }

  309. 

  310. // --------------------------------------------------------------------------------------------------------------------

  311. 

  312. const char* ildaeilConfigDir()

  313. {

  314.     static water::String configDir;

  315. 

  316.     if (configDir.isEmpty())

  317.     {

  318.        #if defined(CARLA_OS_WASM)

  319.         configDir = "/userfiles";

  320.        #elif defined(CARLA_OS_MAC)

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

  322.        #elif defined(CARLA_OS_WIN)

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

  324.        #else

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

  326.             configDir = xdgEnv;

  327.         else

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

  329.         configDir += "/Ildaeil";

  330.        #endif

  331.     }

  332. 

  333.     return configDir.toRawUTF8();

  334. }

  335. 

  336. // --------------------------------------------------------------------------------------------------------------------

  337. 

  338. class IldaeilPlugin : public IldaeilBasePlugin

  339. {

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

  341.     float* fDummyBuffer;

  342.     float* fDummyBuffers[2];

  343.    #endif

  344.    #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  345.     static constexpr const uint kMaxMidiEventCount = 512;

  346.     NativeMidiEvent* fMidiEvents;

  347.    #endif

  348. 

  349.     mutable NativeTimeInfo fCarlaTimeInfo;

  350.     mutable water::MemoryOutputStream fLastProjectState;

  351.     uint32_t fLastLatencyValue;

  352. 

  353. public:

  354.     IldaeilPlugin()

  355.         : IldaeilBasePlugin(),

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

  357.           fDummyBuffer(nullptr),

  358.          #endif

  359.          #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  360.           fMidiEvents(nullptr),

  361.          #endif

  362.           fLastLatencyValue(0)

  363.     {

  364.         fCarlaPluginDescriptor = carla_get_native_rack_plugin();

  365.         DISTRHO_SAFE_ASSERT_RETURN(fCarlaPluginDescriptor != nullptr,);

  366. 

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

  368. 

  369.         fCarlaHostDescriptor.handle = this;

  370.         fCarlaHostDescriptor.resourceDir = carla_get_library_folder();

  371.         fCarlaHostDescriptor.uiName = "Ildaeil";

  372.         fCarlaHostDescriptor.uiParentId = 0;

  373. 

  374.         fCarlaHostDescriptor.get_buffer_size = host_get_buffer_size;

  375.         fCarlaHostDescriptor.get_sample_rate = host_get_sample_rate;

  376.         fCarlaHostDescriptor.is_offline = host_is_offline;

  377. 

  378.         fCarlaHostDescriptor.get_time_info = host_get_time_info;

  379.         fCarlaHostDescriptor.write_midi_event = host_write_midi_event;

  380.         fCarlaHostDescriptor.ui_parameter_changed = host_ui_parameter_changed;

  381.         fCarlaHostDescriptor.ui_midi_program_changed = host_ui_midi_program_changed;

  382.         fCarlaHostDescriptor.ui_custom_data_changed = host_ui_custom_data_changed;

  383.         fCarlaHostDescriptor.ui_closed = host_ui_closed;

  384.         fCarlaHostDescriptor.ui_open_file = host_ui_open_file;

  385.         fCarlaHostDescriptor.ui_save_file = host_ui_save_file;

  386.         fCarlaHostDescriptor.dispatcher = host_dispatcher;

  387. 

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

  389.         DISTRHO_SAFE_ASSERT_RETURN(fCarlaPluginHandle != nullptr,);

  390. 

  391.         fCarlaHostHandle = carla_create_native_plugin_host_handle(fCarlaPluginDescriptor, fCarlaPluginHandle);

  392.         DISTRHO_SAFE_ASSERT_RETURN(fCarlaHostHandle != nullptr,);

  393. 

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

  395.        #ifdef CARLA_OS_WIN

  396.         #define EXT ".exe"

  397.        #else

  398.         #define EXT ""

  399.        #endif

  400. 

  401.         if (bundlePath != nullptr

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

  403.         {

  404.             fBinaryPath = bundlePath;

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

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

  407.         }

  408.        #ifdef CARLA_OS_MAC

  409.         else if (bundlePath != nullptr

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

  411.         {

  412.             fBinaryPath = bundlePath;

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

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

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

  416.         }

  417.        #endif

  418.         else

  419.         {

  420.            #ifdef CARLA_OS_MAC

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

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

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

  424.            #else

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

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

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

  428.            #endif

  429.         }

  430. 

  431.         if (fBinaryPath.isNotEmpty())

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

  433. 

  434.         #undef EXT

  435. 

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

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

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

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

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

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

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

  443. 

  444.         fCarlaPluginDescriptor->dispatcher(fCarlaPluginHandle, NATIVE_PLUGIN_OPCODE_HOST_USES_EMBED,

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

  446. 

  447.        #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  448.         fMidiEvents = new NativeMidiEvent[kMaxMidiEventCount];

  449.        #endif

  450. 

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

  452.         // create dummy buffers

  453.         bufferSizeChanged(getBufferSize());

  454.        #endif

  455.     }

  456. 

  457.     ~IldaeilPlugin() override

  458.     {

  459.         if (fCarlaHostHandle != nullptr)

  460.         {

  461.             carla_host_handle_free(fCarlaHostHandle);

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

  463.             delete[] fDummyBuffer;

  464.            #endif

  465.            #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  466.             delete[] fMidiEvents;

  467.            #endif

  468.         }

  469. 

  470.         if (fCarlaPluginHandle != nullptr)

  471.             fCarlaPluginDescriptor->cleanup(fCarlaPluginHandle);

  472.     }

  473. 

  474.     const NativeTimeInfo* hostGetTimeInfo() const noexcept

  475.     {

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

  477. 

  478.         fCarlaTimeInfo.playing = timePos.playing;

  479.         fCarlaTimeInfo.frame = timePos.frame;

  480.         fCarlaTimeInfo.bbt.valid = timePos.bbt.valid;

  481.         fCarlaTimeInfo.bbt.bar = timePos.bbt.bar;

  482.         fCarlaTimeInfo.bbt.beat = timePos.bbt.beat;

  483.         fCarlaTimeInfo.bbt.tick = timePos.bbt.tick;

  484.         fCarlaTimeInfo.bbt.barStartTick = timePos.bbt.barStartTick;

  485.         fCarlaTimeInfo.bbt.beatsPerBar = timePos.bbt.beatsPerBar;

  486.         fCarlaTimeInfo.bbt.beatType = timePos.bbt.beatType;

  487.         fCarlaTimeInfo.bbt.ticksPerBeat = timePos.bbt.ticksPerBeat;

  488.         fCarlaTimeInfo.bbt.beatsPerMinute = timePos.bbt.beatsPerMinute;

  489. 

  490.         return &fCarlaTimeInfo;

  491.     }

  492. 

  493. #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  494.     bool hostWriteMidiEvent(const NativeMidiEvent* const event)

  495.     {

  496.         MidiEvent midiEvent;

  497.         midiEvent.frame = event->time;

  498.         midiEvent.size = event->size;

  499.         midiEvent.dataExt = nullptr;

  500. 

  501.         uint32_t i = 0;

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

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

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

  505.             midiEvent.data[i] = 0;

  506. 

  507.         return writeMidiEvent(midiEvent);

  508.     }

  509. #endif

  510. 

  511.     intptr_t hostDispatcher(const NativeHostDispatcherOpcode opcode,

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

  513.     {

  514.         switch (opcode)

  515.         {

  516.         // cannnot be supported

  517.         case NATIVE_HOST_OPCODE_HOST_IDLE:

  518.             break;

  519.         // other stuff

  520.         case NATIVE_HOST_OPCODE_NULL:

  521.         case NATIVE_HOST_OPCODE_UPDATE_PARAMETER:

  522.         case NATIVE_HOST_OPCODE_UPDATE_MIDI_PROGRAM:

  523.         case NATIVE_HOST_OPCODE_RELOAD_PARAMETERS:

  524.         case NATIVE_HOST_OPCODE_RELOAD_MIDI_PROGRAMS:

  525.         case NATIVE_HOST_OPCODE_RELOAD_ALL:

  526.         case NATIVE_HOST_OPCODE_UI_UNAVAILABLE:

  527.         case NATIVE_HOST_OPCODE_INTERNAL_PLUGIN:

  528.         case NATIVE_HOST_OPCODE_QUEUE_INLINE_DISPLAY:

  529.         case NATIVE_HOST_OPCODE_UI_TOUCH_PARAMETER:

  530.         case NATIVE_HOST_OPCODE_REQUEST_IDLE:

  531.         case NATIVE_HOST_OPCODE_GET_FILE_PATH:

  532.         case NATIVE_HOST_OPCODE_UI_RESIZE:

  533.         case NATIVE_HOST_OPCODE_PREVIEW_BUFFER_DATA:

  534.             // TESTING

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

  536.             break;

  537.         }

  538. 

  539.         return 0;

  540.     }

  541. 

  542. protected:

  543.    /* --------------------------------------------------------------------------------------------------------

  544.     * Information */

  545. 

  546.     const char* getLabel() const override

  547.     {

  548. #if ILDAEIL_STANDALONE

  549.         return "Ildaeil";

  550. #elif DISTRHO_PLUGIN_IS_SYNTH

  551.         return "IldaeilSynth";

  552. #elif DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  553.         return "IldaeilMIDI";

  554. #else

  555.         return "IldaeilFX";

  556. #endif

  557.     }

  558. 

  559.     const char* getDescription() const override

  560.     {

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

  562.     }

  563. 

  564.     const char* getMaker() const override

  565.     {

  566.         return "DISTRHO";

  567.     }

  568. 

  569.     const char* getHomePage() const override

  570.     {

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

  572.     }

  573. 

  574.     const char* getLicense() const override

  575.     {

  576.         return "GPLv2+";

  577.     }

  578. 

  579.     uint32_t getVersion() const override

  580.     {

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

  582.     }

  583. 

  584.     int64_t getUniqueId() const override

  585.     {

  586. #if ILDAEIL_STANDALONE

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

  588. #elif DISTRHO_PLUGIN_IS_SYNTH

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

  590. #elif DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

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

  592. #else

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

  594. #endif

  595.     }

  596. 

  597.    /* --------------------------------------------------------------------------------------------------------

  598.     * Init */

  599. 

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

  601.     {

  602.         port.groupId = kPortGroupStereo;

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

  604.     }

  605. 

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

  607.     {

  608.         DISTRHO_SAFE_ASSERT_RETURN(index == 0,);

  609. 

  610.         state.hints = kStateIsOnlyForDSP;

  611.         state.key = "project";

  612.         state.defaultValue = ""

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

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

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

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

  617.     }

  618. 

  619.    /* --------------------------------------------------------------------------------------------------------

  620.     * Internal data */

  621. 

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

  623.     {

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

  625.         {

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

  627. 

  628.             fLastProjectState.reset();

  629.             engine->saveProjectInternal(fLastProjectState);

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

  631.         }

  632. 

  633.         return String();

  634.     }

  635. 

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

  637.     {

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

  639.         {

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

  641. 

  642.             water::XmlDocument xml(value);

  643. 

  644.             {

  645.                 const MutexLocker cml(sPluginInfoLoadMutex);

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

  647.             }

  648. 

  649.             if (fUI != nullptr)

  650.                 ildaeilProjectLoadedFromDSP(fUI);

  651.         }

  652.     }

  653. 

  654.    /* --------------------------------------------------------------------------------------------------------

  655.     * Process */

  656. 

  657.     void checkLatencyChanged()

  658.     {

  659.         if (fCarlaHostHandle == nullptr)

  660.             return;

  661. 

  662.         uint32_t latency = 0;

  663. 

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

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

  666. 

  667.         if (fLastLatencyValue != latency)

  668.         {

  669.             fLastLatencyValue = latency;

  670.             setLatency(latency);

  671.         }

  672.     }

  673. 

  674.     void activate() override

  675.     {

  676.         if (fCarlaPluginHandle != nullptr)

  677.             fCarlaPluginDescriptor->activate(fCarlaPluginHandle);

  678. 

  679.         checkLatencyChanged();

  680.     }

  681. 

  682.     void deactivate() override

  683.     {

  684.         checkLatencyChanged();

  685. 

  686.         if (fCarlaPluginHandle != nullptr)

  687.             fCarlaPluginDescriptor->deactivate(fCarlaPluginHandle);

  688.     }

  689. 

  690. #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

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

  692.              const MidiEvent* dpfMidiEvents, uint32_t dpfMidiEventCount) override

  693. #else

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

  695. #endif

  696.     {

  697.         if (fCarlaPluginHandle != nullptr)

  698.         {

  699.            #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  700.             uint32_t midiEventCount = 0;

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

  702.             {

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

  704.                 if (dpfMidiEvent.size > 4)

  705.                     continue;

  706. 

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

  708. 

  709.                 midiEvent.time = dpfMidiEvent.frame;

  710.                 midiEvent.port = 0;

  711.                 midiEvent.size = dpfMidiEvent.size;

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

  713. 

  714.                 if (++midiEventCount == kMaxMidiEventCount)

  715.                     break;

  716.             }

  717.            #else

  718.             static constexpr const NativeMidiEvent* fMidiEvents = nullptr;

  719.             static constexpr const uint32_t midiEventCount = 0;

  720.            #endif

  721. 

  722.            #if DISTRHO_PLUGIN_NUM_INPUTS == 0

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

  724.            #endif

  725.            #if DISTRHO_PLUGIN_NUM_OUTPUTS == 0

  726.             outputs = fDummyBuffers;

  727.            #endif

  728. 

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

  730.                                             fMidiEvents, midiEventCount);

  731. 

  732.             checkLatencyChanged();

  733.         }

  734.         else

  735.         {

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

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

  738.         }

  739.     }

  740. 

  741.     void bufferSizeChanged(const uint32_t newBufferSize) override

  742.     {

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

  744.         delete[] fDummyBuffer;

  745.         fDummyBuffer = new float[newBufferSize];

  746.         fDummyBuffers[0] = fDummyBuffer;

  747.         fDummyBuffers[1] = fDummyBuffer;

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

  749.        #endif

  750. 

  751.         if (fCarlaPluginHandle != nullptr)

  752.             fCarlaPluginDescriptor->dispatcher(fCarlaPluginHandle, NATIVE_PLUGIN_OPCODE_BUFFER_SIZE_CHANGED,

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

  754.     }

  755. 

  756.     void sampleRateChanged(const double newSampleRate) override

  757.     {

  758.         if (fCarlaPluginHandle != nullptr)

  759.             fCarlaPluginDescriptor->dispatcher(fCarlaPluginHandle, NATIVE_PLUGIN_OPCODE_SAMPLE_RATE_CHANGED,

  760.                                                0, 0, nullptr, newSampleRate);

  761.     }

  762. 

  763.     // -------------------------------------------------------------------------------------------------------

  764. 

  765.    /**

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

  767.     */

  768.     DISTRHO_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(IldaeilPlugin)

  769. };

  770. 

  771. // -----------------------------------------------------------------------------------------------------------

  772. 

  773. static uint32_t host_get_buffer_size(const NativeHostHandle handle)

  774. {

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

  776. }

  777. 

  778. static double host_get_sample_rate(const NativeHostHandle handle)

  779. {

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

  781. }

  782. 

  783. static bool host_is_offline(NativeHostHandle)

  784. {

  785.     return false;

  786. }

  787. 

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

  789. {

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

  791. }

  792. 

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

  794. {

  795. #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

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

  797. #else

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

  799. #endif

  800. }

  801. 

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

  803. {

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

  805. }

  806. 

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

  808. {

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

  810. }

  811. 

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

  813. {

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

  815. }

  816. 

  817. static void host_ui_closed(NativeHostHandle handle)

  818. {

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

  820. }

  821. 

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

  823. {

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

  825. }

  826. 

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

  828. {

  829.     return nullptr;

  830. }

  831. 

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

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

  834. {

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

  836. }

  837. 

  838. /* --------------------------------------------------------------------------------------------------------------------

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

  840. 

  841. Plugin* createPlugin()

  842. {

  843.     return new IldaeilPlugin();

  844. }

  845. 

  846. // --------------------------------------------------------------------------------------------------------------------

  847. 

  848. END_NAMESPACE_DISTRHO