plugin.h

// SPDX-FileCopyrightText: © 2018-2022, 2024-2025 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#pragma once
 
#include "zrythm-config.h"
 
#include <memory>
#include <string>
#include <vector>
 
#include "gui/dsp/port.h"
#include "gui/dsp/port_span.h"
#include "gui/dsp/track_fwd.h"
#include "plugins/plugin_configuration.h"
#include "plugins/plugin_descriptor.h"
#include "plugins/plugin_slot.h"
#include "utils/types.h"
 
namespace zrythm::gui::old_dsp::plugins
{


class Plugin
    : public dsp::IProcessable,
      public IPortOwner,
      public utils::UuidIdentifiableObject<Plugin>
{
public:
  using PortIdentifier = dsp::PortIdentifier;
  using PluginSlot = zrythm::plugins::PluginSlot;
  using PluginSlotType = zrythm::plugins::PluginSlotType;
  using PluginSlotNo = PluginSlot::SlotNo;
  using PluginDescriptor = zrythm::plugins::PluginDescriptor;
  using Protocol = zrythm::plugins::Protocol;
  using PluginCategory = zrythm::plugins::PluginCategory;
  using PluginConfiguration = zrythm::plugins::PluginConfiguration;
 
  using TrackResolver =
    utils::UuidIdentifiablObjectResolver<TrackPtrVariant, TrackUuid>;

  struct PresetIdentifier
  {
    // Rule of 0

    int idx_ = 0;

    int bank_idx_ = 0;

    PluginUuid plugin_id_;
 
    NLOHMANN_DEFINE_TYPE_INTRUSIVE (PresetIdentifier, idx_, bank_idx_, plugin_id_)
  };

  struct Preset
  {
    utils::Utf8String name_;

    utils::Utf8String uri_;

    int carla_program_ = 0;
 
    PresetIdentifier id_;
 
    NLOHMANN_DEFINE_TYPE_INTRUSIVE (Preset, name_, uri_, carla_program_, id_)
  };

  struct Bank
  {
    // Rule of 0
 
    void add_preset (Preset &&preset);

    std::vector<Preset> presets_;

    utils::Utf8String uri_;

    utils::Utf8String name_;
 
    PresetIdentifier id_;
 
    NLOHMANN_DEFINE_TYPE_INTRUSIVE (Bank, name_, presets_, uri_, id_)
  };
 
  constexpr static auto DEFAULT_BANK_URI = "https://lv2.zrythm.org#default-bank";
  constexpr static auto INIT_PRESET_URI = "https://lv2.zrythm.org#init-preset";

  constexpr static float MIN_REFRESH_RATE = 30.f;
  constexpr static float MAX_REFRESH_RATE = 121.f;

  constexpr static float MIN_SCALE_FACTOR = 0.5f;
  constexpr static float MAX_SCALE_FACTOR = 4.f;
 
public:
  ~Plugin () override;
 
  PluginDescriptor      &get_descriptor () { return *setting_->descr_; }
  utils::Utf8String      get_name () const { return setting_->descr_->name_; }
  Protocol::ProtocolType get_protocol () const
  {
    return setting_->descr_->protocol_;
  }
 
  static Plugin * from_variant (const auto &variant)
  {
    return std::visit ([&] (auto &&pl) -> Plugin * { return pl; }, variant);
  }
 
  static auto name_projection (const auto &var)
  {
    return std::visit ([&] (auto &&val) { return val->get_name (); }, var);
  }
 
  auto get_input_port_span () const { return PortSpan{ in_ports_ }; }
  auto get_output_port_span () const { return PortSpan{ out_ports_ }; }

  void init_loaded ();
 
  bool is_in_active_project () const override;
 
  utils::Utf8String
  get_full_designation_for_port (const dsp::PortIdentifier &id) const override;
 
  void set_port_metadata_from_owner (dsp::PortIdentifier &id, PortRange &range)
    const override;
 
  void on_control_change_event (
    const dsp::PortIdentifier::PortUuid &port_uuid,
    const dsp::PortIdentifier           &id,
    float                                val) override;
 
  bool should_bounce_to_master (utils::audio::BounceStep step) const override;

  bool is_auditioner () const;

  void set_ui_refresh_rate ();

  ControlPort * get_enabled_port ();

  bool validate () const;

  std::string print () const;

  void remove_ats_from_automation_tracklist (bool free_ats, bool fire_events);
 
  utils::Utf8String
  get_full_port_group_designation (const utils::Utf8String &port_group) const;
 
  Port *
  get_port_in_group (const utils::Utf8String &port_group, bool left) const;

  Port * get_port_in_same_group (const Port &port);

  void activate (bool activate = true);
 
  auto get_slot_type () const
  {
    const auto slot = get_slot ();
    assert (slot.has_value ());
    if (slot->has_slot_index ())
      {
        return slot->get_slot_with_index ().first;
      }
 
    return slot->get_slot_type_only ();
  }

  void append_ports (std::vector<Port *> &ports);

  void
  expose_ports (AudioEngine &engine, bool expose, bool inputs, bool outputs);

  std::optional<PortPtrVariant>
  get_port_by_symbol (const utils::Utf8String &sym);

  void copy_state_dir (
    const Plugin           &src,
    bool                    is_backup,
    std::optional<fs::path> abs_state_dir);

  fs::path get_abs_state_dir (bool is_backup, bool create_if_not_exists);

  fs::path get_abs_state_dir (bool is_backup) const
  {
    return get_abs_state_dir (state_dir_, is_backup);
  }

  static fs::path
  get_abs_state_dir (const fs::path &plugin_state_dir, bool is_backup);

  void ensure_state_dir (bool is_backup);
 
  std::optional<TrackPtrVariant> get_track () const;
 
  void set_track (const TrackUuid &track_id)
  {
    track_id_ = track_id;
    update_identifier ();
  }
 
  TrackUuid get_track_id () const
  {
    assert (has_track ());
    return *track_id_;
  }
 
  bool has_track () const { return track_id_.has_value (); }

  void update_identifier ();

  // void update_latency ();

  [[gnu::hot]] void prepare_process ();

  void instantiate ();

  auto get_slot () const -> std::optional<PluginSlot>;

  [[gnu::hot]] void process_block (EngineProcessTimeInfo time_nfo) override;
 
  utils::Utf8String get_node_name () const override;
 
  utils::Utf8String generate_window_title () const;

  void open_ui ();
 
  bool is_selected () const { return selected_; }
 
  void set_selected (bool selected) { selected_ = selected; }
 
#if 0
  void select (bool select, bool exclusive);
#endif

  bool is_enabled (bool check_track) const;
 
  void set_enabled (bool enabled, bool fire_events);

  [[gnu::hot]] void process_passthrough (EngineProcessTimeInfo time_nfo);

  void close_ui ();

  void update_automatables ();
 
  void set_selected_bank_from_index (int idx);
 
  void set_selected_preset_from_index (int idx);
 
  void set_selected_preset_by_name (const utils::Utf8String &name);

  void set_caches ();

  void connect_to_plugin (Plugin &dest);

  void disconnect_from_plugin (Plugin &dest);

  void disconnect ();

  void delete_state_files ();

  void cleanup ();
 
protected:
  void add_in_port (const PortUuidReference &port_id);

  void add_out_port (const PortUuidReference &port_id);

  Bank * add_bank_if_not_exists (
    std::optional<utils::Utf8String> uri,
    const utils::Utf8String         &name);

  void copy_members_from (Plugin &other);
 
protected:
  Plugin () = default;
 
private:
  void set_stereo_outs_and_midi_in ();
  void set_enabled_and_gain ();
  void init ();
  void set_port_index (PortUuidReference port_id);
 
  virtual void populate_banks () = 0;

  virtual void set_selected_preset_from_index_impl (int idx) = 0;
 
  virtual void cleanup_impl () = 0;

  virtual void instantiate_impl (bool loading, bool use_state_file) = 0;

  virtual void
  save_state (bool is_backup, std::optional<fs::path> abs_state_dir) = 0;

  virtual void open_custom_ui (bool show) = 0;
 
  virtual void activate_impl (bool activate = true) = 0;
 
  virtual void process_impl (EngineProcessTimeInfo time_info) = 0;

  virtual void close () = 0;
 
protected:
  Plugin (PortRegistry &port_registry, const PluginConfiguration &setting);
 
private:
  static constexpr auto kTrackIdKey = "trackId"sv;
  static constexpr auto kSettingKey = "setting"sv;
  static constexpr auto kInPortsKey = "inPorts"sv;
  static constexpr auto kOutPortsKey = "outPorts"sv;
  static constexpr auto kBanksKey = "banks"sv;
  static constexpr auto kSelectedBankKey = "selectedBank"sv;
  static constexpr auto kSelectedPresetKey = "selectedPreset"sv;
  static constexpr auto kVisibleKey = "visible"sv;
  static constexpr auto kStateDirectoryKey = "stateDir"sv;
  friend void           to_json (nlohmann::json &j, const Plugin &p)
  {
    to_json (j, static_cast<const UuidIdentifiableObject &> (p));
    j[kTrackIdKey] = p.track_id_;
    j[kSettingKey] = p.setting_;
    j[kInPortsKey] = p.in_ports_;
    j[kOutPortsKey] = p.out_ports_;
    j[kBanksKey] = p.banks_;
    j[kSelectedBankKey] = p.selected_bank_;
    j[kSelectedPresetKey] = p.selected_preset_;
    j[kVisibleKey] = p.visible_;
    j[kStateDirectoryKey] = p.state_dir_;
  }
  friend void from_json (const nlohmann::json &j, Plugin &p)
  {
    from_json (j, static_cast<UuidIdentifiableObject &> (p));
    j.at (kTrackIdKey).get_to (p.track_id_);
    j.at (kSettingKey).get_to (p.setting_);
    j.at (kInPortsKey).get_to (p.in_ports_);
    j.at (kOutPortsKey).get_to (p.out_ports_);
    j.at (kBanksKey).get_to (p.banks_);
    j.at (kSelectedBankKey).get_to (p.selected_bank_);
    j.at (kSelectedPresetKey).get_to (p.selected_preset_);
    j.at (kVisibleKey).get_to (p.visible_);
    j.at (kStateDirectoryKey).get_to (p.state_dir_);
  }
 
public:
  OptionalRef<PortRegistry>    port_registry_;
  std::optional<TrackResolver> track_resolver_;
 
  std::optional<TrackUuid> track_id_;

  std::unique_ptr<PluginConfiguration> setting_;

  std::vector<PortUuidReference> in_ports_;
 
  /* Caches - avoid shared_ptr due to performance cost */
  std::vector<ControlPort *> ctrl_in_ports_;
  std::vector<AudioPort *>   audio_in_ports_;
  std::vector<CVPort *>      cv_in_ports_;
  std::vector<MidiPort *>    midi_in_ports_;

  MidiPort * midi_in_port_ = nullptr;

  std::vector<PortUuidReference> out_ports_;

  ControlPort * enabled_ = nullptr;

  ControlPort * own_enabled_port_ = nullptr;

  ControlPort * gain_ = nullptr;

  AudioPort * l_out_ = nullptr;
  AudioPort * r_out_ = nullptr;
 
  std::vector<Bank> banks_;
 
  PresetIdentifier selected_bank_;
  PresetIdentifier selected_preset_;

  bool visible_ = false;

  // nframes_t latency_ = 0;

  bool instantiated_{};

  bool instantiation_failed_ = false;

  bool activated_ = false;

  float ui_update_hz_ = 0.f;

  float ui_scale_factor_ = 0.f;

  fs::path state_dir_;

  bool deleting_ = false;

  ulong destroy_window_id_ = 0;

  ulong close_request_id_ = 0;

  bool selected_{};

  uint update_ui_source_id_ = 0;

  bool deactivating_ = false;

  std::atomic<bool> state_changed_event_sent_ = false;

  bool is_function_ = false;
};
 
inline bool
operator< (const Plugin &lhs, const Plugin &rhs)
{
  return lhs.get_slot () < rhs.get_slot ();
}
 
class CarlaNativePlugin;
 
using PluginVariant = std::variant<CarlaNativePlugin>;
using PluginPtrVariant = to_pointer_variant<PluginVariant>;
using PluginUniquePtrVariant = to_unique_ptr_variant<PluginVariant>;
using PluginRegistry = utils::OwningObjectRegistry<PluginPtrVariant, Plugin>;
using PluginRegistryRef = std::reference_wrapper<PluginRegistry>;
using PluginUuidReference = utils::UuidReference<PluginRegistry>;
 
} // namespace zrythm::gui::old_dsp::plugins
 
void
from_json (
  const nlohmann::json                  &j,
  gui::old_dsp::plugins::PluginRegistry &registry);