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

860 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 "CarlaBackendUtils.hpp"

  22. #include "CarlaEngine.hpp"

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

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

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

  26. 

  27. START_NAMESPACE_DISTRHO

  28. 

  29. using namespace CARLA_BACKEND_NAMESPACE;

  30. 

  31. // --------------------------------------------------------------------------------------------------------------------

  32. 

  33. static uint32_t host_get_buffer_size(NativeHostHandle);

  34. static double host_get_sample_rate(NativeHostHandle);

  35. static bool host_is_offline(NativeHostHandle);

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

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

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

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

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

  41. static void host_ui_closed(NativeHostHandle handle);

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

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

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

  45. 

  46. // --------------------------------------------------------------------------------------------------------------------

  47. 

  48. Mutex IldaeilBasePlugin::sPluginInfoLoadMutex;

  49. 

  50. // --------------------------------------------------------------------------------------------------------------------

  51. 

  52. #ifndef CARLA_OS_WIN

  53. static water::String getHomePath()

  54. {

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

  56.     return path;

  57. }

  58. #endif

  59. 

  60. static const char* getPathForLADSPA()

  61. {

  62.     static water::String path;

  63. 

  64.     if (path.isEmpty())

  65.     {

  66.        #if defined(CARLA_OS_HAIKU)

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

  68.        #elif defined(CARLA_OS_MAC)

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

  70.        #elif defined(CARLA_OS_WASM)

  71.         path = "/ladspa";

  72.        #elif defined(CARLA_OS_WIN)

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

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

  75.        #else

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

  77.        #endif

  78.     }

  79. 

  80.     return path.toRawUTF8();

  81. }

  82. 

  83. static const char* getPathForDSSI()

  84. {

  85.     static water::String path;

  86. 

  87.     if (path.isEmpty())

  88.     {

  89.        #if defined(CARLA_OS_HAIKU)

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

  91.        #elif defined(CARLA_OS_MAC)

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

  93.        #elif defined(CARLA_OS_WASM)

  94.         path = "/dssi";

  95.        #elif defined(CARLA_OS_WIN)

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

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

  98.        #else

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

  100.        #endif

  101.     }

  102. 

  103.     return path.toRawUTF8();

  104. }

  105. 

  106. static const char* getPathForLV2()

  107. {

  108.     static water::String path;

  109. 

  110.     if (path.isEmpty())

  111.     {

  112.        #if defined(CARLA_OS_HAIKU)

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

  114.        #elif defined(CARLA_OS_MAC)

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

  116.        #elif defined(CARLA_OS_WASM)

  117.         path = "/lv2";

  118.        #elif defined(CARLA_OS_WIN)

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

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

  121.        #else

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

  123.        #endif

  124.     }

  125. 

  126.     return path.toRawUTF8();

  127. }

  128. 

  129. static const char* getPathForVST2()

  130. {

  131.     static water::String path;

  132. 

  133.     if (path.isEmpty())

  134.     {

  135.        #if defined(CARLA_OS_HAIKU)

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

  137.        #elif defined(CARLA_OS_MAC)

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

  139.        #elif defined(CARLA_OS_WASM)

  140.         path = "/vst";

  141.        #elif defined(CARLA_OS_WIN)

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

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

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

  145.        #else

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

  147. 

  148.         water::String winePrefix;

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

  150.             winePrefix = envWINEPREFIX;

  151. 

  152.         if (winePrefix.isEmpty())

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

  154. 

  155.         if (water::File(winePrefix.toRawUTF8()).exists())

  156.         {

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

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

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

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

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

  162.            #ifdef CARLA_OS_64BIT

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

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

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

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

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

  168.            #endif

  169.         }

  170.        #endif

  171.     }

  172. 

  173.     return path.toRawUTF8();

  174. }

  175. 

  176. static const char* getPathForVST3()

  177. {

  178.     static water::String path;

  179. 

  180.     if (path.isEmpty())

  181.     {

  182.        #if defined(CARLA_OS_HAIKU)

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

  184.        #elif defined(CARLA_OS_MAC)

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

  186.        #elif defined(CARLA_OS_WASM)

  187.         path = "/vst3";

  188.        #elif defined(CARLA_OS_WIN)

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

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

  191.        #else

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

  193. 

  194.         water::String winePrefix;

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

  196.             winePrefix = envWINEPREFIX;

  197. 

  198.         if (winePrefix.isEmpty())

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

  200. 

  201.         if (water::File(winePrefix.toRawUTF8()).exists())

  202.         {

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

  204.            #ifdef CARLA_OS_64BIT

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

  206.            #endif

  207.         }

  208.        #endif

  209.     }

  210. 

  211.     return path.toRawUTF8();

  212. }

  213. 

  214. static const char* getPathForCLAP()

  215. {

  216.     static water::String path;

  217. 

  218.     if (path.isEmpty())

  219.     {

  220.        #if defined(CARLA_OS_HAIKU)

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

  222.        #elif defined(CARLA_OS_MAC)

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

  224.        #elif defined(CARLA_OS_WASM)

  225.         path = "/clap";

  226.        #elif defined(CARLA_OS_WIN)

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

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

  229.        #else

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

  231. 

  232.         water::String winePrefix;

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

  234.             winePrefix = envWINEPREFIX;

  235. 

  236.         if (winePrefix.isEmpty())

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

  238. 

  239.         if (water::File(winePrefix.toRawUTF8()).exists())

  240.         {

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

  242.            #ifdef CARLA_OS_64BIT

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

  244.            #endif

  245.         }

  246.        #endif

  247.     }

  248. 

  249.     return path.toRawUTF8();

  250. }

  251. 

  252. static const char* getPathForJSFX()

  253. {

  254.     static water::String path;

  255. 

  256.     if (path.isEmpty())

  257.     {

  258.        #if defined(CARLA_OS_MAC)

  259.         path = getHomePath()

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

  261.         if (! water::File(path.toRawUTF8()).isDirectory())

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

  263.        #elif defined(CARLA_OS_WASM)

  264.         path = "/jsfx";

  265.        #elif defined(CARLA_OS_WIN)

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

  267.         if (! water::File(path.toRawUTF8()).isDirectory())

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

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

  270.        #else

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

  272.             path = configHome;

  273.         else

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

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

  276.        #endif

  277.     }

  278. 

  279.     return path.toRawUTF8();

  280. }

  281. 

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

  283. {

  284.     switch (ptype)

  285.     {

  286.     case PLUGIN_LADSPA:

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

  288.             return path;

  289.         return getPathForLADSPA();

  290.     case PLUGIN_DSSI:

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

  292.             return path;

  293.         return getPathForDSSI();

  294.     case PLUGIN_LV2:

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

  296.             return path;

  297.         return getPathForLV2();

  298.     case PLUGIN_VST2:

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

  300.             return path;

  301.         return getPathForVST2();

  302.     case PLUGIN_VST3:

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

  304.             return path;

  305.         return getPathForVST3();

  306.     case PLUGIN_CLAP:

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

  308.             return path;

  309.         return getPathForCLAP();

  310.     case PLUGIN_JSFX:

  311.         return getPathForJSFX();

  312.     default:

  313.         return nullptr;

  314.     }

  315. }

  316. 

  317. // --------------------------------------------------------------------------------------------------------------------

  318. 

  319. const char* ildaeilConfigDir()

  320. {

  321.     static water::String configDir;

  322. 

  323.     if (configDir.isEmpty())

  324.     {

  325.        #if defined(CARLA_OS_WASM)

  326.         configDir = "/userfiles";

  327.        #elif defined(CARLA_OS_MAC)

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

  329.        #elif defined(CARLA_OS_WIN)

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

  331.        #else

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

  333.             configDir = xdgEnv;

  334.         else

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

  336.         configDir += "/Ildaeil";

  337.        #endif

  338.     }

  339. 

  340.     return configDir.toRawUTF8();

  341. }

  342. 

  343. // --------------------------------------------------------------------------------------------------------------------

  344. 

  345. class IldaeilPlugin : public IldaeilBasePlugin

  346. {

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

  348.     float* fDummyBuffer;

  349.     float* fDummyBuffers[2];

  350.    #endif

  351.    #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  352.     static constexpr const uint kMaxMidiEventCount = 512;

  353.     NativeMidiEvent* fMidiEvents;

  354.    #endif

  355. 

  356.     mutable NativeTimeInfo fCarlaTimeInfo;

  357.     mutable water::MemoryOutputStream fLastProjectState;

  358.     uint32_t fLastLatencyValue;

  359. 

  360. public:

  361.     IldaeilPlugin()

  362.         : IldaeilBasePlugin(),

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

  364.           fDummyBuffer(nullptr),

  365.          #endif

  366.          #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  367.           fMidiEvents(nullptr),

  368.          #endif

  369.           fLastLatencyValue(0)

  370.     {

  371.         fCarlaPluginDescriptor = carla_get_native_rack_plugin();

  372.         DISTRHO_SAFE_ASSERT_RETURN(fCarlaPluginDescriptor != nullptr,);

  373. 

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

  375. 

  376.         fCarlaHostDescriptor.handle = this;

  377.         fCarlaHostDescriptor.resourceDir = carla_get_library_folder();

  378.         fCarlaHostDescriptor.uiName = "Ildaeil";

  379.         fCarlaHostDescriptor.uiParentId = 0;

  380. 

  381.         fCarlaHostDescriptor.get_buffer_size = host_get_buffer_size;

  382.         fCarlaHostDescriptor.get_sample_rate = host_get_sample_rate;

  383.         fCarlaHostDescriptor.is_offline = host_is_offline;

  384. 

  385.         fCarlaHostDescriptor.get_time_info = host_get_time_info;

  386.         fCarlaHostDescriptor.write_midi_event = host_write_midi_event;

  387.         fCarlaHostDescriptor.ui_parameter_changed = host_ui_parameter_changed;

  388.         fCarlaHostDescriptor.ui_midi_program_changed = host_ui_midi_program_changed;

  389.         fCarlaHostDescriptor.ui_custom_data_changed = host_ui_custom_data_changed;

  390.         fCarlaHostDescriptor.ui_closed = host_ui_closed;

  391.         fCarlaHostDescriptor.ui_open_file = host_ui_open_file;

  392.         fCarlaHostDescriptor.ui_save_file = host_ui_save_file;

  393.         fCarlaHostDescriptor.dispatcher = host_dispatcher;

  394. 

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

  396.         DISTRHO_SAFE_ASSERT_RETURN(fCarlaPluginHandle != nullptr,);

  397. 

  398.         fCarlaHostHandle = carla_create_native_plugin_host_handle(fCarlaPluginDescriptor, fCarlaPluginHandle);

  399.         DISTRHO_SAFE_ASSERT_RETURN(fCarlaHostHandle != nullptr,);

  400. 

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

  402.        #ifdef CARLA_OS_WIN

  403.         #define EXT ".exe"

  404.        #else

  405.         #define EXT ""

  406.        #endif

  407. 

  408.         if (bundlePath != nullptr

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

  410.         {

  411.             fBinaryPath = bundlePath;

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

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

  414.         }

  415.        #ifdef CARLA_OS_MAC

  416.         else if (bundlePath != nullptr

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

  418.         {

  419.             fBinaryPath = bundlePath;

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

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

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

  423.         }

  424.        #endif

  425.         else

  426.         {

  427.            #ifdef CARLA_OS_MAC

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

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

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

  431.            #else

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

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

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

  435.            #endif

  436.         }

  437. 

  438.         if (fBinaryPath.isNotEmpty())

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

  440. 

  441.         #undef EXT

  442. 

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

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

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

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

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

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

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

  450. 

  451.         fCarlaPluginDescriptor->dispatcher(fCarlaPluginHandle, NATIVE_PLUGIN_OPCODE_HOST_USES_EMBED,

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

  453. 

  454.        #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  455.         fMidiEvents = new NativeMidiEvent[kMaxMidiEventCount];

  456.        #endif

  457. 

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

  459.         // create dummy buffers

  460.         bufferSizeChanged(getBufferSize());

  461.        #endif

  462.     }

  463. 

  464.     ~IldaeilPlugin() override

  465.     {

  466.         if (fCarlaHostHandle != nullptr)

  467.         {

  468.             carla_host_handle_free(fCarlaHostHandle);

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

  470.             delete[] fDummyBuffer;

  471.            #endif

  472.            #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  473.             delete[] fMidiEvents;

  474.            #endif

  475.         }

  476. 

  477.         if (fCarlaPluginHandle != nullptr)

  478.             fCarlaPluginDescriptor->cleanup(fCarlaPluginHandle);

  479.     }

  480. 

  481.     const NativeTimeInfo* hostGetTimeInfo() const noexcept

  482.     {

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

  484. 

  485.         fCarlaTimeInfo.playing = timePos.playing;

  486.         fCarlaTimeInfo.frame = timePos.frame;

  487.         fCarlaTimeInfo.bbt.valid = timePos.bbt.valid;

  488.         fCarlaTimeInfo.bbt.bar = timePos.bbt.bar;

  489.         fCarlaTimeInfo.bbt.beat = timePos.bbt.beat;

  490.         fCarlaTimeInfo.bbt.tick = timePos.bbt.tick;

  491.         fCarlaTimeInfo.bbt.barStartTick = timePos.bbt.barStartTick;

  492.         fCarlaTimeInfo.bbt.beatsPerBar = timePos.bbt.beatsPerBar;

  493.         fCarlaTimeInfo.bbt.beatType = timePos.bbt.beatType;

  494.         fCarlaTimeInfo.bbt.ticksPerBeat = timePos.bbt.ticksPerBeat;

  495.         fCarlaTimeInfo.bbt.beatsPerMinute = timePos.bbt.beatsPerMinute;

  496. 

  497.         return &fCarlaTimeInfo;

  498.     }

  499. 

  500. #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  501.     bool hostWriteMidiEvent(const NativeMidiEvent* const event)

  502.     {

  503.         MidiEvent midiEvent;

  504.         midiEvent.frame = event->time;

  505.         midiEvent.size = event->size;

  506.         midiEvent.dataExt = nullptr;

  507. 

  508.         uint32_t i = 0;

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

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

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

  512.             midiEvent.data[i] = 0;

  513. 

  514.         return writeMidiEvent(midiEvent);

  515.     }

  516. #endif

  517. 

  518.     intptr_t hostDispatcher(const NativeHostDispatcherOpcode opcode,

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

  520.     {

  521.         switch (opcode)

  522.         {

  523.         // cannnot be supported

  524.         case NATIVE_HOST_OPCODE_HOST_IDLE:

  525.             break;

  526.         // other stuff

  527.         case NATIVE_HOST_OPCODE_NULL:

  528.         case NATIVE_HOST_OPCODE_UPDATE_PARAMETER:

  529.         case NATIVE_HOST_OPCODE_UPDATE_MIDI_PROGRAM:

  530.         case NATIVE_HOST_OPCODE_RELOAD_PARAMETERS:

  531.         case NATIVE_HOST_OPCODE_RELOAD_MIDI_PROGRAMS:

  532.         case NATIVE_HOST_OPCODE_RELOAD_ALL:

  533.         case NATIVE_HOST_OPCODE_UI_UNAVAILABLE:

  534.         case NATIVE_HOST_OPCODE_INTERNAL_PLUGIN:

  535.         case NATIVE_HOST_OPCODE_QUEUE_INLINE_DISPLAY:

  536.         case NATIVE_HOST_OPCODE_UI_TOUCH_PARAMETER:

  537.         case NATIVE_HOST_OPCODE_REQUEST_IDLE:

  538.         case NATIVE_HOST_OPCODE_GET_FILE_PATH:

  539.         case NATIVE_HOST_OPCODE_PREVIEW_BUFFER_DATA:

  540.             // TESTING

  541.             d_stdout("dispatcher %i:%s, %i, %li, %p, %f",

  542.                       opcode, NativeHostDispatcherOpcode2Str(opcode), index, value, ptr, opt);

  543.             break;

  544.         case NATIVE_HOST_OPCODE_UI_RESIZE:

  545.             ildaeilResizeUI(fUI, index, value);

  546.             break;

  547.         }

  548. 

  549.         return 0;

  550.     }

  551. 

  552. protected:

  553.    /* --------------------------------------------------------------------------------------------------------

  554.     * Information */

  555. 

  556.     const char* getLabel() const override

  557.     {

  558. #if ILDAEIL_STANDALONE

  559.         return "Ildaeil";

  560. #elif DISTRHO_PLUGIN_IS_SYNTH

  561.         return "IldaeilSynth";

  562. #elif DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  563.         return "IldaeilMIDI";

  564. #else

  565.         return "IldaeilFX";

  566. #endif

  567.     }

  568. 

  569.     const char* getDescription() const override

  570.     {

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

  572.     }

  573. 

  574.     const char* getMaker() const override

  575.     {

  576.         return "DISTRHO";

  577.     }

  578. 

  579.     const char* getHomePage() const override

  580.     {

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

  582.     }

  583. 

  584.     const char* getLicense() const override

  585.     {

  586.         return "GPLv2+";

  587.     }

  588. 

  589.     uint32_t getVersion() const override

  590.     {

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

  592.     }

  593. 

  594.     int64_t getUniqueId() const override

  595.     {

  596.        #if ILDAEIL_STANDALONE

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

  598.        #elif DISTRHO_PLUGIN_IS_SYNTH

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

  600.        #elif DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

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

  602.        #else

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

  604.        #endif

  605.     }

  606. 

  607.    /* --------------------------------------------------------------------------------------------------------

  608.     * Init */

  609. 

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

  611.     {

  612.         port.groupId = kPortGroupStereo;

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

  614.     }

  615. 

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

  617.     {

  618.         DISTRHO_SAFE_ASSERT_RETURN(index == 0,);

  619. 

  620.         state.hints = kStateIsOnlyForDSP;

  621.         state.key = "project";

  622.         state.defaultValue = ""

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

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

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

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

  627.     }

  628. 

  629.    /* --------------------------------------------------------------------------------------------------------

  630.     * Internal data */

  631. 

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

  633.     {

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

  635.         {

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

  637. 

  638.             fLastProjectState.reset();

  639.             engine->saveProjectInternal(fLastProjectState);

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

  641.         }

  642. 

  643.         return String();

  644.     }

  645. 

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

  647.     {

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

  649.         {

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

  651. 

  652.             const water::String wvalue(value);

  653.             water::XmlDocument xml(wvalue);

  654. 

  655.             {

  656.                 const MutexLocker cml(sPluginInfoLoadMutex);

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

  658.             }

  659. 

  660.             if (fUI != nullptr)

  661.                 ildaeilProjectLoadedFromDSP(fUI);

  662.         }

  663.     }

  664. 

  665.    /* --------------------------------------------------------------------------------------------------------

  666.     * Process */

  667. 

  668.     void checkLatencyChanged()

  669.     {

  670.         if (fCarlaHostHandle == nullptr)

  671.             return;

  672. 

  673.         uint32_t latency = 0;

  674. 

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

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

  677. 

  678.         if (fLastLatencyValue != latency)

  679.         {

  680.             fLastLatencyValue = latency;

  681.             setLatency(latency);

  682.         }

  683.     }

  684. 

  685.     void activate() override

  686.     {

  687.         if (fCarlaPluginHandle != nullptr)

  688.             fCarlaPluginDescriptor->activate(fCarlaPluginHandle);

  689. 

  690.         checkLatencyChanged();

  691.     }

  692. 

  693.     void deactivate() override

  694.     {

  695.         checkLatencyChanged();

  696. 

  697.         if (fCarlaPluginHandle != nullptr)

  698.             fCarlaPluginDescriptor->deactivate(fCarlaPluginHandle);

  699.     }

  700. 

  701. #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

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

  703.              const MidiEvent* dpfMidiEvents, uint32_t dpfMidiEventCount) override

  704. #else

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

  706. #endif

  707.     {

  708.         if (fCarlaPluginHandle != nullptr)

  709.         {

  710.            #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  711.             uint32_t midiEventCount = 0;

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

  713.             {

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

  715.                 if (dpfMidiEvent.size > 4)

  716.                     continue;

  717. 

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

  719. 

  720.                 midiEvent.time = dpfMidiEvent.frame;

  721.                 midiEvent.port = 0;

  722.                 midiEvent.size = dpfMidiEvent.size;

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

  724. 

  725.                 if (++midiEventCount == kMaxMidiEventCount)

  726.                     break;

  727.             }

  728.            #else

  729.             static constexpr const NativeMidiEvent* fMidiEvents = nullptr;

  730.             static constexpr const uint32_t midiEventCount = 0;

  731.            #endif

  732. 

  733.            #if DISTRHO_PLUGIN_NUM_INPUTS == 0

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

  735.            #endif

  736.            #if DISTRHO_PLUGIN_NUM_OUTPUTS == 0

  737.             outputs = fDummyBuffers;

  738.            #endif

  739. 

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

  741.                                             fMidiEvents, midiEventCount);

  742. 

  743.             checkLatencyChanged();

  744.         }

  745.         else

  746.         {

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

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

  749.         }

  750.     }

  751. 

  752.     void bufferSizeChanged(const uint32_t newBufferSize) override

  753.     {

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

  755.         delete[] fDummyBuffer;

  756.         fDummyBuffer = new float[newBufferSize];

  757.         fDummyBuffers[0] = fDummyBuffer;

  758.         fDummyBuffers[1] = fDummyBuffer;

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

  760.        #endif

  761. 

  762.         if (fCarlaPluginHandle != nullptr)

  763.             fCarlaPluginDescriptor->dispatcher(fCarlaPluginHandle, NATIVE_PLUGIN_OPCODE_BUFFER_SIZE_CHANGED,

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

  765.     }

  766. 

  767.     void sampleRateChanged(const double newSampleRate) override

  768.     {

  769.         if (fCarlaPluginHandle != nullptr)

  770.             fCarlaPluginDescriptor->dispatcher(fCarlaPluginHandle, NATIVE_PLUGIN_OPCODE_SAMPLE_RATE_CHANGED,

  771.                                                0, 0, nullptr, newSampleRate);

  772.     }

  773. 

  774.     // -------------------------------------------------------------------------------------------------------

  775. 

  776.    /**

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

  778.     */

  779.     DISTRHO_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(IldaeilPlugin)

  780. };

  781. 

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

  783. 

  784. static uint32_t host_get_buffer_size(const NativeHostHandle handle)

  785. {

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

  787. }

  788. 

  789. static double host_get_sample_rate(const NativeHostHandle handle)

  790. {

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

  792. }

  793. 

  794. static bool host_is_offline(NativeHostHandle)

  795. {

  796.     return false;

  797. }

  798. 

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

  800. {

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

  802. }

  803. 

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

  805. {

  806. #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

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

  808. #else

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

  810. #endif

  811. }

  812. 

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

  814. {

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

  816. }

  817. 

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

  819. {

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

  821. }

  822. 

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

  824. {

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

  826. }

  827. 

  828. static void host_ui_closed(NativeHostHandle handle)

  829. {

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

  831. }

  832. 

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

  834. {

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

  836. }

  837. 

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

  839. {

  840.     return nullptr;

  841. }

  842. 

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

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

  845. {

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

  847. }

  848. 

  849. /* --------------------------------------------------------------------------------------------------------------------

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

  851. 

  852. Plugin* createPlugin()

  853. {

  854.     return new IldaeilPlugin();

  855. }

  856. 

  857. // --------------------------------------------------------------------------------------------------------------------

  858. 

  859. END_NAMESPACE_DISTRHO