plugin_descriptor.h

// SPDX-FileCopyrightText: © 2018-2021, 2024-2026 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#pragma once
 
#include <filesystem>
 
#include "plugins/plugin_protocol.h"
#include "utils/icloneable.h"
#include "utils/utf8_string.h"
 
#include <QObject>
 
#include <boost/describe.hpp>
#include <juce_audio_processors_headless/juce_audio_processors_headless.h>
#include <nlohmann/json_fwd.hpp>
 
namespace zrythm::plugins
{
using namespace std::string_view_literals;

enum class PluginCategory : std::uint8_t
{
  None,
  Delay,
  REVERB,
  DISTORTION,
  WAVESHAPER,
  DYNAMICS,
  AMPLIFIER,
  COMPRESSOR,
  ENVELOPE,
  EXPANDER,
  GATE,
  LIMITER,
  FILTER,
  ALLPASS_FILTER,
  BANDPASS_FILTER,
  COMB_FILTER,
  EQ,
  MULTI_EQ,
  PARA_EQ,
  HIGHPASS_FILTER,
  LOWPASS_FILTER,
  GENERATOR,
  CONSTANT,
  Instrument,
  OSCILLATOR,
  MIDI,
  MODULATOR,
  CHORUS,
  FLANGER,
  PHASER,
  SIMULATOR,
  SIMULATOR_REVERB,
  SPATIAL,
  SPECTRAL,
  PITCH,
  UTILITY,
  ANALYZER,
  CONVERTER,
  FUNCTION,
  MIXER,
};

enum class PluginArchitecture : std::uint8_t
{
  ARCH_32_BIT,
  ARCH_64_BIT
};

enum class BridgeMode : std::uint8_t
{
  None,
  UI,
  Full,
};

class PluginDescriptor : public QObject
{
  Q_OBJECT
  QML_ELEMENT
  Q_PROPERTY (QString name READ name CONSTANT FINAL)
  Q_PROPERTY (QString vendor READ vendor CONSTANT FINAL)
  Q_PROPERTY (QString format READ format CONSTANT FINAL)
  Q_PROPERTY (QString category READ category CONSTANT FINAL)
  QML_UNCREATABLE ("")
 
public:
  static std::unique_ptr<PluginDescriptor>
  from_juce_description (const juce::PluginDescription &juce_desc);
 
  std::unique_ptr<juce::PluginDescription> to_juce_description () const;
 
  static PluginCategory    string_to_category (const utils::Utf8String &str);
  static utils::Utf8String category_to_string (PluginCategory category);
 
  // =========================================================
  // QML interface
  // =========================================================
 
  [[nodiscard]] QString name () const { return name_.to_qstring (); }
  QString               format () const;
  QString               vendor () const;
  QString               category () const;

  Q_INVOKABLE QString serializeToString () const;
 
  Q_INVOKABLE bool isInstrument () const;
  Q_INVOKABLE bool isEffect () const;
  Q_INVOKABLE bool isModulator () const;
  Q_INVOKABLE bool isMidiModifier () const;
 
  // =========================================================

  bool is_same_plugin (const PluginDescriptor &other) const;

  bool has_custom_ui () const;

  BridgeMode get_min_bridge_mode () const;

  utils::Utf8String get_icon_name () const;
 
  // GMenuModel * generate_context_menu () const;
 
  friend void init_from (
    PluginDescriptor       &obj,
    const PluginDescriptor &other,
    utils::ObjectCloneType  clone_type);
 
private:
  static constexpr auto kAuthorKey = "author"sv;
  static constexpr auto kNameKey = "name"sv;
  static constexpr auto kWebsiteKey = "website"sv;
  static constexpr auto kCategoryKey = "category"sv;
  static constexpr auto kCategoryStringKey = "categoryString"sv;
  static constexpr auto kNumAudioInsKey = "numAudioIns"sv;
  static constexpr auto kNumAudioOutsKey = "numAudioOuts"sv;
  static constexpr auto kNumMidiInsKey = "numMidiIns"sv;
  static constexpr auto kNumMidiOutsKey = "numMidiOuts"sv;
  static constexpr auto kNumCtrlInsKey = "numCtrlIns"sv;
  static constexpr auto kNumCtrlOutsKey = "numCtrlOuts"sv;
  static constexpr auto kNumCvInsKey = "numCvIns"sv;
  static constexpr auto kNumCvOutsKey = "numCvOuts"sv;
  static constexpr auto kUniqueIdKey = "uniqueId"sv;
  static constexpr auto kDeprecatedUniqueIdKey = "deprecatedUniqueId"sv;
  static constexpr auto kArchitectureKey = "architecture"sv;
  static constexpr auto kProtocolKey = "protocol"sv;
  static constexpr auto kPathOrIdKey = "pathOrId"sv;
  static constexpr auto kMinBridgeModeKey = "minBridgeMode"sv;
  static constexpr auto kHasCustomUIKey = "hasCustomUI"sv;
  friend void           to_json (nlohmann::json &j, const PluginDescriptor &p);
  friend void from_json (const nlohmann::json &j, PluginDescriptor &p);
 
  friend bool operator== (const PluginDescriptor &a, const PluginDescriptor &b)
  {
    constexpr auto tie = [] (const auto &p) {
      return std::tie (
        p.arch_, p.protocol_, p.path_or_id_, p.unique_id_,
        p.juce_compat_deprecated_unique_id_, p.min_bridge_mode_,
        p.has_custom_ui_);
    };
    return tie (a) == tie (b);
  }
 
public:
  utils::Utf8String author_;
  utils::Utf8String name_;
  utils::Utf8String website_;
  PluginCategory    category_ = PluginCategory::None;
  utils::Utf8String category_str_;
  int num_audio_ins_ = 0;
  int num_midi_ins_ = 0;
  int num_audio_outs_ = 0;
  int num_midi_outs_ = 0;
  int num_ctrl_ins_ = 0;
  int num_ctrl_outs_ = 0;
  int num_cv_ins_ = 0;
  int num_cv_outs_ = 0;
  PluginArchitecture arch_ = PluginArchitecture::ARCH_64_BIT;
  Protocol::ProtocolType protocol_ = Protocol::ProtocolType::Internal;

  std::variant<std::filesystem::path, utils::Utf8String> path_or_id_;

  int64_t unique_id_{};

  int juce_compat_deprecated_unique_id_{};

  BridgeMode min_bridge_mode_ = BridgeMode::None;
 
  bool has_custom_ui_{};
 
  BOOST_DESCRIBE_CLASS (
    PluginDescriptor,
    (),
    (author_,
     name_,
     website_,
     category_,
     category_str_,
     protocol_,
     path_or_id_,
     unique_id_,
     juce_compat_deprecated_unique_id_,
     num_cv_ins_,
     num_cv_outs_,
     arch_,
     min_bridge_mode_,
     has_custom_ui_),
    (),
    ())
};
 
} // namespace zrythm::plugins
 
namespace std
{
template <> struct hash<zrythm::plugins::PluginDescriptor>
{
  size_t operator() (const zrythm::plugins::PluginDescriptor &d) const
  {
    size_t h{};
    h = h ^ qHash (d.protocol_);
    h = h ^ qHash (d.arch_);
    if (std::holds_alternative<std::filesystem::path> (d.path_or_id_))
      {
        h =
          h ^ qHash (std::get<std::filesystem::path> (d.path_or_id_).string ());
      }
    else
      {
        h =
          h ^ qHash (std::get<zrythm::utils::Utf8String> (d.path_or_id_).str ());
      }
    h = h ^ qHash (d.unique_id_);
    h = h ^ qHash (d.juce_compat_deprecated_unique_id_);
    return h;
  }
};
}