plugin.h

// SPDX-FileCopyrightText: © 2018-2022, 2024-2026 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#pragma once
 
#include <atomic>
#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 "utils/qt.h"
 
#include <QTimer>
 
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 ("")
 
  Q_DISABLE_COPY_MOVE (Plugin)
public:
  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,
    bool                  generateNewPluginPortsAndParams);
 
  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,
    units::sample_u32_t           max_block_length) final;
 
  [[gnu::hot]] void custom_process_block (
    dsp::graph::EngineProcessTimeInfo time_nfo,
    const dsp::ITransport            &transport,
    const dsp::TempoMap              &tempo_map) noexcept final;
 
  void custom_release_resources () final;
 
  // ============================================================================

  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:
  std::string save_state () const;

  void load_state (const std::string &base64_state);

  void flush_plugin_values ();
 
private:
  virtual void prepare_for_processing_impl (
    units::sample_rate_t sample_rate,
    units::sample_u32_t  max_block_length) { };
 
  virtual void
  process_impl (dsp::graph::EngineProcessTimeInfo time_info) noexcept = 0;
 
  virtual void release_resources_impl () { }

  [[gnu::hot]] virtual void process_passthrough_impl (
    dsp::graph::EngineProcessTimeInfo time_nfo,
    const dsp::ITransport            &transport,
    const dsp::TempoMap              &tempo_map) noexcept;
 
  virtual std::string save_state_impl () const = 0;
  virtual void        load_state_impl (const std::string &base64_state) = 0;
 
  // ============================================================================

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

  dsp::ProcessorParameterUuidReference generate_default_bypass_param () const;

  dsp::ProcessorParameterUuidReference generate_default_gain_param () const;
 
private:
  static constexpr auto kConfigurationKey = "configuration"sv;
  static constexpr auto kProgramIndexKey = "programIndex"sv;
  static constexpr auto kProtocolKey = "protocol"sv;
  static constexpr auto kVisibleKey = "visible"sv;
  friend void           to_json (nlohmann::json &j, const Plugin &p);
  friend void           from_json (const nlohmann::json &j, Plugin &p);
 
protected:
  bool instantiation_failed_ = false;
 
  // ============================================================================
  // 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_{};
 
  // ============================================================================
  // Parameter Synchronization
  // ============================================================================

  struct ParamSync
  {
    struct Entry
    {
      float last_from_plugin = -1.f;

      std::atomic<float> pending_value{ -1.f };
 
      Entry () = default;
      Entry (const Entry &) = delete;
      Entry &operator= (const Entry &) = delete;
      Entry (Entry &&other) noexcept
          : last_from_plugin (other.last_from_plugin),
            pending_value (other.pending_value.load (std::memory_order_relaxed))
      {
      }
      Entry &operator= (Entry &&other) noexcept
      {
        if (this != &other)
          {
            last_from_plugin = other.last_from_plugin;
            pending_value.store (
              other.pending_value.load (std::memory_order_relaxed),
              std::memory_order_relaxed);
          }
        return *this;
      }
    };

    std::vector<Entry> entries;
 
    void prepare (size_t count) { entries.resize (count); }
  };
 
  ParamSync param_sync_;
 
  // ============================================================================
 
private:
  std::unique_ptr<PluginConfiguration> configuration_;

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

  bool visible_ = false;

  bool set_configuration_called_{};

  utils::QObjectUniquePtr<QTimer> param_flush_timer_;
};
 
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);