processor_base.h

// SPDX-FileCopyrightText: © 2025-2026 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#pragma once
 
#include "dsp/graph.h"
#include "dsp/graph_node.h"
#include "dsp/parameter.h"
#include "dsp/port_all.h"
 
#include <QObject>
 
namespace zrythm::dsp
{

class ProcessorBase : public dsp::graph::IProcessable
{
public:
  struct ParameterChangeTracker
  {
    struct Change
    {
      size_t                    index{};
      float                     base_value{};
      float                     automated_value{};
      float                     modulated_value{};
      dsp::ProcessorParameter * param{};
    };

    const auto &changes () const { return changes_; }
 
  private:
    friend class ProcessorBase;

    std::vector<Change> changes_;

    std::vector<float> prev_values_;

    void prepare (size_t count);

    void record_if_changed (size_t i, dsp::ProcessorParameter * param)
    {
      float modulated = param->currentValue ();
      if (!utils::math::floats_equal (prev_values_[i], modulated))
        {
          changes_.push_back (
            { i, param->baseValue (), param->valueAfterAutomationApplied (),
              modulated, param });
          prev_values_[i] = modulated;
        }
    }

    void clear () { changes_.clear (); }
  };
 
private:
  struct BaseProcessingCache
  {
    units::sample_rate_t sample_rate_;
    units::sample_u32_t  max_block_length_{};
 
    std::vector<dsp::ProcessorParameter *> live_params_;
    std::vector<dsp::PortPtrVariant>       live_input_ports_;
    std::vector<dsp::PortPtrVariant>       live_output_ports_;
 
    ParameterChangeTracker change_tracker_;

    bool is_processing_ = false;
  };
 
public:
  struct ProcessorBaseDependencies
  {
    dsp::PortRegistry               &port_registry_;
    dsp::ProcessorParameterRegistry &param_registry_;
  };
 
  ProcessorBase (
    ProcessorBaseDependencies dependencies,
    utils::Utf8String         name = { u8"ProcessorBase" });
 
  ~ProcessorBase () override;

  void set_name (const utils::Utf8String &name);
 
  void add_input_port (const dsp::PortUuidReference &uuid);
  void add_output_port (const dsp::PortUuidReference &uuid);
  void add_parameter (const dsp::ProcessorParameterUuidReference &uuid);
 
  auto &get_input_ports () const { return input_ports_; }
  auto &get_output_ports () const { return output_ports_; }
  auto &get_parameters () const { return params_; }

  const ParameterChangeTracker &change_tracker () const noexcept
  {
    assert (processing_caches_ && processing_caches_->is_processing_);
    return processing_caches_->change_tracker_;
  }
 
  // ============================================================================
  // IProcessable Interface
  // ============================================================================
 
  utils::Utf8String get_node_name () const final { return name_; }

  void process_block (
    dsp::graph::ProcessBlockInfo time_nfo,
    const dsp::ITransport       &transport,
    const dsp::TempoMap         &tempo_map) noexcept final;
  void prepare_for_processing (
    const graph::GraphNode * node,
    units::sample_rate_t     sample_rate,
    units::sample_u32_t      max_block_length) final;
  void release_resources () final;
 
  // ============================================================================
 
protected:
  virtual void custom_process_block (
    dsp::graph::ProcessBlockInfo time_nfo,
    const dsp::ITransport       &transport,
    const dsp::TempoMap         &tempo_map) noexcept [[clang::nonblocking]];
 
  virtual void custom_prepare_for_processing (
    const graph::GraphNode * node,
    units::sample_rate_t     sample_rate,
    units::sample_u32_t      max_block_length)
  {
  }
 
  virtual void custom_release_resources () { }
 
  auto dependencies () const { return dependencies_; }
 
private:
  static constexpr auto kProcessorNameKey = "processorName"sv;
  static constexpr auto kInputPortsKey = "inputPorts"sv;
  static constexpr auto kOutputPortsKey = "outputPorts"sv;
  static constexpr auto kParametersKey = "parameters"sv;
  friend void           to_json (nlohmann::json &j, const ProcessorBase &p);
  friend void           from_json (const nlohmann::json &j, ProcessorBase &p);
 
private:
  ProcessorBaseDependencies                         dependencies_;
  utils::Utf8String                                 name_;
  std::vector<dsp::PortUuidReference>               input_ports_;
  std::vector<dsp::PortUuidReference>               output_ports_;
  std::vector<dsp::ProcessorParameterUuidReference> params_;
 
  // Caches
  std::unique_ptr<BaseProcessingCache> processing_caches_;
 
  BOOST_DESCRIBE_CLASS (ProcessorBase, (), (), (), (name_))
};

class ProcessorGraphBuilder
{
public:
  static void add_nodes (dsp::graph::Graph &graph, ProcessorBase &processor);
  static void
  add_connections (dsp::graph::Graph &graph, ProcessorBase &processor);
};
} // namespace zrythm::dsp