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

825 lines
30KB
Raw Blame History 

  1. /*

  2.  * DISTRHO Ildaeil Plugin

  3.  * Copyright (C) 2021-2025 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. class IldaeilPlugin : public IldaeilBasePlugin

  320. {

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

  322.     float* fDummyBuffer = nullptr;

  323.     float* fDummyBuffers[2];

  324.    #endif

  325.    #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  326.     static constexpr const uint kMaxMidiEventCount = 512;

  327.     NativeMidiEvent* fMidiEvents = nullptr;

  328.    #endif

  329. 

  330.     mutable NativeTimeInfo fCarlaTimeInfo{};

  331.     mutable water::MemoryOutputStream fLastProjectState;

  332.     uint32_t fLastLatencyValue = 0;

  333. 

  334. public:

  335.     IldaeilPlugin()

  336.         : IldaeilBasePlugin()

  337.     {

  338.         fCarlaPluginDescriptor = carla_get_native_rack_plugin();

  339.         DISTRHO_SAFE_ASSERT_RETURN(fCarlaPluginDescriptor != nullptr,);

  340. 

  341.         fCarlaHostDescriptor.handle = this;

  342.         fCarlaHostDescriptor.resourceDir = carla_get_library_folder();

  343.         fCarlaHostDescriptor.uiName = "Ildaeil";

  344.         fCarlaHostDescriptor.uiParentId = 0;

  345. 

  346.         fCarlaHostDescriptor.get_buffer_size = host_get_buffer_size;

  347.         fCarlaHostDescriptor.get_sample_rate = host_get_sample_rate;

  348.         fCarlaHostDescriptor.is_offline = host_is_offline;

  349. 

  350.         fCarlaHostDescriptor.get_time_info = host_get_time_info;

  351.         fCarlaHostDescriptor.write_midi_event = host_write_midi_event;

  352.         fCarlaHostDescriptor.ui_parameter_changed = host_ui_parameter_changed;

  353.         fCarlaHostDescriptor.ui_midi_program_changed = host_ui_midi_program_changed;

  354.         fCarlaHostDescriptor.ui_custom_data_changed = host_ui_custom_data_changed;

  355.         fCarlaHostDescriptor.ui_closed = host_ui_closed;

  356.         fCarlaHostDescriptor.ui_open_file = host_ui_open_file;

  357.         fCarlaHostDescriptor.ui_save_file = host_ui_save_file;

  358.         fCarlaHostDescriptor.dispatcher = host_dispatcher;

  359. 

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

  361.         DISTRHO_SAFE_ASSERT_RETURN(fCarlaPluginHandle != nullptr,);

  362. 

  363.         fCarlaHostHandle = carla_create_native_plugin_host_handle(fCarlaPluginDescriptor, fCarlaPluginHandle);

  364.         DISTRHO_SAFE_ASSERT_RETURN(fCarlaHostHandle != nullptr,);

  365. 

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

  367.        #ifdef CARLA_OS_WIN

  368.         #define EXT ".exe"

  369.        #else

  370.         #define EXT ""

  371.        #endif

  372. 

  373.         if (bundlePath != nullptr

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

  375.         {

  376.             fBinaryPath = bundlePath;

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

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

  379.         }

  380.        #ifdef CARLA_OS_MAC

  381.         else if (bundlePath != nullptr

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

  383.         {

  384.             fBinaryPath = bundlePath;

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

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

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

  388.         }

  389.        #endif

  390.         else

  391.         {

  392.            #ifdef CARLA_OS_MAC

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

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

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

  396.            #else

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

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

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

  400.            #endif

  401.         }

  402. 

  403.         if (fBinaryPath.isNotEmpty())

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

  405. 

  406.         #undef EXT

  407. 

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

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

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

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

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

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

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

  415. 

  416.         fCarlaPluginDescriptor->dispatcher(fCarlaPluginHandle, NATIVE_PLUGIN_OPCODE_HOST_USES_EMBED,

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

  418. 

  419.        #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  420.         fMidiEvents = new NativeMidiEvent[kMaxMidiEventCount];

  421.        #endif

  422. 

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

  424.         // create dummy buffers

  425.         bufferSizeChanged(getBufferSize());

  426.        #endif

  427.     }

  428. 

  429.     ~IldaeilPlugin() override

  430.     {

  431.         if (fCarlaHostHandle != nullptr)

  432.         {

  433.             carla_host_handle_free(fCarlaHostHandle);

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

  435.             delete[] fDummyBuffer;

  436.            #endif

  437.            #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  438.             delete[] fMidiEvents;

  439.            #endif

  440.         }

  441. 

  442.         if (fCarlaPluginHandle != nullptr)

  443.             fCarlaPluginDescriptor->cleanup(fCarlaPluginHandle);

  444.     }

  445. 

  446.     const NativeTimeInfo* hostGetTimeInfo() const noexcept

  447.     {

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

  449. 

  450.         fCarlaTimeInfo.playing = timePos.playing;

  451.         fCarlaTimeInfo.frame = timePos.frame;

  452.         fCarlaTimeInfo.bbt.valid = timePos.bbt.valid;

  453.         fCarlaTimeInfo.bbt.bar = timePos.bbt.bar;

  454.         fCarlaTimeInfo.bbt.beat = timePos.bbt.beat;

  455.         fCarlaTimeInfo.bbt.tick = timePos.bbt.tick;

  456.         fCarlaTimeInfo.bbt.barStartTick = timePos.bbt.barStartTick;

  457.         fCarlaTimeInfo.bbt.beatsPerBar = timePos.bbt.beatsPerBar;

  458.         fCarlaTimeInfo.bbt.beatType = timePos.bbt.beatType;

  459.         fCarlaTimeInfo.bbt.ticksPerBeat = timePos.bbt.ticksPerBeat;

  460.         fCarlaTimeInfo.bbt.beatsPerMinute = timePos.bbt.beatsPerMinute;

  461. 

  462.         return &fCarlaTimeInfo;

  463.     }

  464. 

  465. #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  466.     bool hostWriteMidiEvent(const NativeMidiEvent* const event)

  467.     {

  468.         MidiEvent midiEvent;

  469.         midiEvent.frame = event->time;

  470.         midiEvent.size = event->size;

  471.         midiEvent.dataExt = nullptr;

  472. 

  473.         uint32_t i = 0;

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

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

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

  477.             midiEvent.data[i] = 0;

  478. 

  479.         return writeMidiEvent(midiEvent);

  480.     }

  481. #endif

  482. 

  483.     intptr_t hostDispatcher(const NativeHostDispatcherOpcode opcode,

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

  485.     {

  486.         switch (opcode)

  487.         {

  488.         // cannnot be supported

  489.         case NATIVE_HOST_OPCODE_HOST_IDLE:

  490.             break;

  491.         // other stuff

  492.         case NATIVE_HOST_OPCODE_NULL:

  493.         case NATIVE_HOST_OPCODE_UPDATE_PARAMETER:

  494.         case NATIVE_HOST_OPCODE_UPDATE_MIDI_PROGRAM:

  495.         case NATIVE_HOST_OPCODE_RELOAD_PARAMETERS:

  496.         case NATIVE_HOST_OPCODE_RELOAD_MIDI_PROGRAMS:

  497.         case NATIVE_HOST_OPCODE_RELOAD_ALL:

  498.         case NATIVE_HOST_OPCODE_UI_UNAVAILABLE:

  499.         case NATIVE_HOST_OPCODE_INTERNAL_PLUGIN:

  500.         case NATIVE_HOST_OPCODE_QUEUE_INLINE_DISPLAY:

  501.         case NATIVE_HOST_OPCODE_UI_TOUCH_PARAMETER:

  502.         case NATIVE_HOST_OPCODE_REQUEST_IDLE:

  503.         case NATIVE_HOST_OPCODE_GET_FILE_PATH:

  504.         case NATIVE_HOST_OPCODE_PREVIEW_BUFFER_DATA:

  505.             // TESTING

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

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

  508.             break;

  509.         case NATIVE_HOST_OPCODE_UI_RESIZE:

  510.             ildaeilResizeUI(fUI, index, value);

  511.             break;

  512.         }

  513. 

  514.         return 0;

  515.     }

  516. 

  517. protected:

  518.    /* --------------------------------------------------------------------------------------------------------

  519.     * Information */

  520. 

  521.     const char* getLabel() const override

  522.     {

  523. #if ILDAEIL_STANDALONE

  524.         return "Ildaeil";

  525. #elif DISTRHO_PLUGIN_IS_SYNTH

  526.         return "IldaeilSynth";

  527. #elif DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

  528.         return "IldaeilMIDI";

  529. #else

  530.         return "IldaeilFX";

  531. #endif

  532.     }

  533. 

  534.     const char* getDescription() const override

  535.     {

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

  537.     }

  538. 

  539.     const char* getMaker() const override

  540.     {

  541.         return "DISTRHO";

  542.     }

  543. 

  544.     const char* getHomePage() const override

  545.     {

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

  547.     }

  548. 

  549.     const char* getLicense() const override

  550.     {

  551.         return "GPLv2+";

  552.     }

  553. 

  554.     uint32_t getVersion() const override

  555.     {

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

  557.     }

  558. 

  559.     int64_t getUniqueId() const override

  560.     {

  561.        #if ILDAEIL_STANDALONE

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

  563.        #elif DISTRHO_PLUGIN_IS_SYNTH

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

  565.        #elif DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

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

  567.        #else

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

  569.        #endif

  570.     }

  571. 

  572.    /* --------------------------------------------------------------------------------------------------------

  573.     * Init */

  574. 

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

  576.     {

  577.         port.groupId = kPortGroupStereo;

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

  579.     }

  580. 

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

  582.     {

  583.         DISTRHO_SAFE_ASSERT_RETURN(index == 0,);

  584. 

  585.         state.hints = kStateIsOnlyForDSP;

  586.         state.key = "project";

  587.         state.defaultValue = ""

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

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

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

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

  592.     }

  593. 

  594.    /* --------------------------------------------------------------------------------------------------------

  595.     * Internal data */

  596. 

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

  598.     {

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

  600.         {

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

  602. 

  603.             fLastProjectState.reset();

  604.             engine->saveProjectInternal(fLastProjectState);

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

  606.         }

  607. 

  608.         return String();

  609.     }

  610. 

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

  612.     {

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

  614.         {

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

  616. 

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

  618.             water::XmlDocument xml(wvalue);

  619. 

  620.             {

  621.                 const MutexLocker cml(sPluginInfoLoadMutex);

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

  623.             }

  624. 

  625.             if (fUI != nullptr)

  626.                 ildaeilProjectLoadedFromDSP(fUI);

  627.         }

  628.     }

  629. 

  630.    /* --------------------------------------------------------------------------------------------------------

  631.     * Process */

  632. 

  633.     void checkLatencyChanged()

  634.     {

  635.         if (fCarlaHostHandle == nullptr)

  636.             return;

  637. 

  638.         uint32_t latency = 0;

  639. 

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

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

  642. 

  643.         if (fLastLatencyValue != latency)

  644.         {

  645.             fLastLatencyValue = latency;

  646.             setLatency(latency);

  647.         }

  648.     }

  649. 

  650.     void activate() override

  651.     {

  652.         if (fCarlaPluginHandle != nullptr)

  653.             fCarlaPluginDescriptor->activate(fCarlaPluginHandle);

  654. 

  655.         checkLatencyChanged();

  656.     }

  657. 

  658.     void deactivate() override

  659.     {

  660.         checkLatencyChanged();

  661. 

  662.         if (fCarlaPluginHandle != nullptr)

  663.             fCarlaPluginDescriptor->deactivate(fCarlaPluginHandle);

  664.     }

  665. 

  666. #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

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

  668.              const MidiEvent* dpfMidiEvents, uint32_t dpfMidiEventCount) override

  669. #else

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

  671. #endif

  672.     {

  673.         if (fCarlaPluginHandle != nullptr)

  674.         {

  675.            #if DISTRHO_PLUGIN_WANT_MIDI_INPUT

  676.             uint32_t midiEventCount = 0;

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

  678.             {

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

  680.                 if (dpfMidiEvent.size > 4)

  681.                     continue;

  682. 

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

  684. 

  685.                 midiEvent.time = dpfMidiEvent.frame;

  686.                 midiEvent.port = 0;

  687.                 midiEvent.size = dpfMidiEvent.size;

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

  689. 

  690.                 if (++midiEventCount == kMaxMidiEventCount)

  691.                     break;

  692.             }

  693.            #else

  694.             static constexpr const NativeMidiEvent* fMidiEvents = nullptr;

  695.             static constexpr const uint32_t midiEventCount = 0;

  696.            #endif

  697. 

  698.            #if DISTRHO_PLUGIN_NUM_INPUTS == 0

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

  700.            #endif

  701.            #if DISTRHO_PLUGIN_NUM_OUTPUTS == 0

  702.             outputs = fDummyBuffers;

  703.            #endif

  704. 

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

  706.                                             fMidiEvents, midiEventCount);

  707. 

  708.             checkLatencyChanged();

  709.         }

  710.         else

  711.         {

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

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

  714.         }

  715.     }

  716. 

  717.     void bufferSizeChanged(const uint32_t newBufferSize) override

  718.     {

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

  720.         delete[] fDummyBuffer;

  721.         fDummyBuffer = new float[newBufferSize];

  722.         fDummyBuffers[0] = fDummyBuffer;

  723.         fDummyBuffers[1] = fDummyBuffer;

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

  725.        #endif

  726. 

  727.         if (fCarlaPluginHandle != nullptr)

  728.             fCarlaPluginDescriptor->dispatcher(fCarlaPluginHandle, NATIVE_PLUGIN_OPCODE_BUFFER_SIZE_CHANGED,

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

  730.     }

  731. 

  732.     void sampleRateChanged(const double newSampleRate) override

  733.     {

  734.         if (fCarlaPluginHandle != nullptr)

  735.             fCarlaPluginDescriptor->dispatcher(fCarlaPluginHandle, NATIVE_PLUGIN_OPCODE_SAMPLE_RATE_CHANGED,

  736.                                                0, 0, nullptr, newSampleRate);

  737.     }

  738. 

  739.     // -------------------------------------------------------------------------------------------------------

  740. 

  741.    /**

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

  743.     */

  744.     DISTRHO_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(IldaeilPlugin)

  745. };

  746. 

  747. // -----------------------------------------------------------------------------------------------------------

  748. 

  749. static uint32_t host_get_buffer_size(const NativeHostHandle handle)

  750. {

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

  752. }

  753. 

  754. static double host_get_sample_rate(const NativeHostHandle handle)

  755. {

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

  757. }

  758. 

  759. static bool host_is_offline(NativeHostHandle)

  760. {

  761.     return false;

  762. }

  763. 

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

  765. {

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

  767. }

  768. 

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

  770. {

  771. #if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT

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

  773. #else

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

  775. #endif

  776. }

  777. 

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

  779. {

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

  781. }

  782. 

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

  784. {

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

  786. }

  787. 

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

  789. {

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

  791. }

  792. 

  793. static void host_ui_closed(NativeHostHandle handle)

  794. {

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

  796. }

  797. 

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

  799. {

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

  801. }

  802. 

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

  804. {

  805.     return nullptr;

  806. }

  807. 

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

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

  810. {

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

  812. }

  813. 

  814. /* --------------------------------------------------------------------------------------------------------------------

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

  816. 

  817. Plugin* createPlugin()

  818. {

  819.     return new IldaeilPlugin();

  820. }

  821. 

  822. // --------------------------------------------------------------------------------------------------------------------

  823. 

  824. END_NAMESPACE_DISTRHO