plugin.h

// SPDX-FileCopyrightText: © 2018-2022, 2024-2025 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#pragma once
 
#include <memory>
#include <vector>
 
#include "dsp/parameter.h"
#include "dsp/port_all.h"
#include "dsp/port_span.h"
#include "dsp/processor_base.h"
#include "plugins/iplugin_host_window.h"
#include "plugins/plugin_configuration.h"
#include "plugins/plugin_descriptor.h"
#include "plugins/plugin_slot.h"
 
namespace zrythm::plugins
{

class Plugin
    : public QObject,
      public dsp::ProcessorBase,
      public utils::UuidIdentifiableObject<Plugin>
{
  Q_OBJECT
  Q_PROPERTY (
    int programIndex READ programIndex WRITE setProgramIndex NOTIFY
      programIndexChanged)
  Q_PROPERTY (
    zrythm::plugins::PluginConfiguration * configuration READ configuration
      NOTIFY configurationChanged)
  Q_PROPERTY (
    zrythm::dsp::ProcessorParameter * bypassParameter READ bypassParameter
      CONSTANT)
  Q_PROPERTY (
    zrythm::dsp::ProcessorParameter * gainParameter READ gainParameter CONSTANT)
  Q_PROPERTY (
    bool uiVisible READ uiVisible WRITE setUiVisible NOTIFY uiVisibleChanged)
  Q_PROPERTY (
    InstantiationStatus instantiationStatus READ instantiationStatus NOTIFY
      instantiationStatusChanged)
  QML_ELEMENT
  QML_UNCREATABLE ("")
 
  Z_DISABLE_COPY_MOVE (Plugin)
public:

  using StateDirectoryParentPathProvider = std::function<fs::path ()>;
 
  enum class InstantiationStatus : std::uint8_t
  {
    Pending,    
    Successful, 
    Failed      
  };
  Q_ENUM (InstantiationStatus)
 
  ~Plugin () override;
 
  // ============================================================================
  // QML Interface
  // ============================================================================

  int  programIndex () const { return program_index_.value_or (-1); }
  void setProgramIndex (int index)
  {
    if (program_index_.value_or (-1) == index)
      return;
 
    if (index >= 0)
      {
        program_index_.emplace (index);
      }
    else
      {
        program_index_.reset ();
      }
 
    Q_EMIT programIndexChanged (index);
  }

  Q_SIGNAL void programIndexChanged (int index);
 
  PluginConfiguration * configuration () const { return configuration_.get (); }
  Q_SIGNAL void configurationChanged (PluginConfiguration * configuration);
 
  dsp::ProcessorParameter * bypassParameter () const
  {
    return std::get<dsp::ProcessorParameter *> (
      dependencies ().param_registry_.find_by_id_or_throw (bypass_id_.value ()));
  }
  dsp::ProcessorParameter * gainParameter () const
  {
    return std::get<dsp::ProcessorParameter *> (
      dependencies ().param_registry_.find_by_id_or_throw (gain_id_.value ()));
  }
 
  bool uiVisible () const { return visible_; }
  void setUiVisible (bool visible)
  {
    if (visible == visible_)
      return;
 
    visible_ = visible;
    Q_EMIT uiVisibleChanged (visible);
  }

  Q_SIGNAL void uiVisibleChanged (bool visible);
 
  InstantiationStatus instantiationStatus () const
  {
    return instantiation_status_;
  }
  Q_SIGNAL void instantiationStatusChanged (InstantiationStatus status);

  Q_SIGNAL void instantiationFinished (bool successful, const QString &error);
 
  // ============================================================================
 
  PluginDescriptor &get_descriptor () const
  {
    return *configuration ()->descr_;
  }
  utils::Utf8String get_name () const
  {
    return configuration ()->descr_->name_;
  }
  Protocol::ProtocolType get_protocol () const
  {
    return configuration ()->descr_->protocol_;
  }

  void set_configuration (const PluginConfiguration &setting);
 
  // ============================================================================
  // IProcessable Interface
  // ============================================================================
 
  void custom_prepare_for_processing (
    const dsp::graph::GraphNode * node,
    units::sample_rate_t          sample_rate,
    nframes_t                     max_block_length) final;
 
  [[gnu::hot]] void custom_process_block (
    EngineProcessTimeInfo  time_nfo,
    const dsp::ITransport &transport) noexcept final;
 
  void custom_release_resources () final;
 
  // ============================================================================
 
  fs::path get_state_directory () const
  {
    return state_dir_parent_path_provider_ ()
           / fs::path (
             type_safe::get (get_uuid ())
               .toString (QUuid::WithoutBraces)
               .toStdString ());
  }

  bool currently_enabled () const
  {
    const auto * bypass = bypassParameter ();
    return !bypass->range ().is_toggled (bypass->currentValue ());
  }
 
  bool currently_enabled_rt () const noexcept [[clang::nonblocking]]
  {
    const auto * bypass = bypass_param_rt_;
    return !bypass->range ().is_toggled (bypass->currentValue ());
  }
 
  // ============================================================================
  // Implementation Interface
  // ============================================================================
 
public:
  virtual void save_state (std::optional<fs::path> abs_state_dir) = 0;

  virtual void load_state (std::optional<fs::path> abs_state_dir) = 0;
 
private:
  virtual void prepare_for_processing_impl (
    units::sample_rate_t sample_rate,
    nframes_t            max_block_length) { };
 
  virtual void process_impl (EngineProcessTimeInfo time_info) noexcept = 0;
 
  virtual void release_resources_impl () { }

  [[gnu::hot]] virtual void process_passthrough_impl (
    EngineProcessTimeInfo  time_nfo,
    const dsp::ITransport &transport) noexcept;
 
  // ============================================================================

  void init_param_caches ();
 
protected:
  Plugin (
    ProcessorBaseDependencies        dependencies,
    StateDirectoryParentPathProvider state_path_provider,
    QObject *                        parent);

  dsp::ProcessorParameterUuidReference generate_default_bypass_param () const;

  dsp::ProcessorParameterUuidReference generate_default_gain_param () const;
 
private:
  static constexpr auto kSettingKey = "setting"sv;
  static constexpr auto kProgramIndexKey = "programIndex"sv;
  static constexpr auto kVisibleKey = "visible"sv;
  friend void           to_json (nlohmann::json &j, const Plugin &p)
  {
    to_json (j, static_cast<const UuidIdentifiableObject &> (p));
    to_json (j, static_cast<const dsp::ProcessorBase &> (p));
    j[kSettingKey] = p.configuration_;
    j[kProgramIndexKey] = p.program_index_;
    j[kVisibleKey] = p.visible_;
  }
  friend void from_json (const nlohmann::json &j, Plugin &p);
 
protected:
  bool instantiation_failed_ = false;

  StateDirectoryParentPathProvider state_dir_parent_path_provider_;
 
  // ============================================================================
  // DSP Caches
  // ============================================================================

  std::optional<dsp::ProcessorParameter::Uuid> bypass_id_;

  std::optional<dsp::ProcessorParameter::Uuid> gain_id_;
 
  /* Realtime caches */
  std::vector<dsp::AudioPort *> audio_in_ports_;
  std::vector<dsp::AudioPort *> audio_out_ports_;
  std::vector<dsp::CVPort *>    cv_in_ports_;
  dsp::MidiPort *               midi_in_port_{};
  dsp::MidiPort *               midi_out_port_{};
  dsp::ProcessorParameter *     bypass_param_rt_{};
 
  // ============================================================================
 
private:
  std::unique_ptr<PluginConfiguration> configuration_;

  std::optional<int> program_index_;
 
  InstantiationStatus instantiation_status_{ InstantiationStatus::Pending };

  bool visible_ = false;

  bool set_configuration_called_{};
};
 
class CarlaNativePlugin;
class JucePlugin;
class ClapPlugin;
class InternalPluginBase;
 
using PluginVariant = std::variant<JucePlugin, ClapPlugin, InternalPluginBase>;
using PluginPtrVariant = to_pointer_variant<PluginVariant>;
 
// TODO: consider having a ProcessorRegistry instead for all
// ProcessorBase-derived classes
using PluginRegistry = utils::OwningObjectRegistry<PluginPtrVariant, Plugin>;
using PluginUuidReference = utils::UuidReference<PluginRegistry>;
 
using PluginHostWindowFactory =
  std::function<std::unique_ptr<plugins::IPluginHostWindow> (Plugin &)>;
 
} // namespace zrythm::plugins
 
DEFINE_UUID_HASH_SPECIALIZATION (zrythm::plugins::Plugin::Uuid)
 
void
from_json (const nlohmann::json &j, zrythm::plugins::PluginRegistry &registry);