parameter.h

// SPDX-FileCopyrightText: © 2025 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#pragma once
 
#include "dsp/audio_port.h"
#include "dsp/cv_port.h"
#include "dsp/graph_node.h"
#include "dsp/midi_port.h"
#include "utils/format.h"
#include "utils/math_utils.h"
#include "utils/units.h"
#include "utils/uuid_identifiable_object.h"
 
#include <nlohmann/json_fwd.hpp>
 
namespace zrythm::dsp
{
 
class ParameterRange
{
  Q_GADGET
 
public:
  enum class Type : std::uint8_t
  {
    Linear,

    Toggle,

    Integer,

    GainAmplitude,

    Logarithmic,

    Enumeration,

    Trigger,
  };

  enum class Unit : std::uint8_t
  {
    None,
    Hz,
    MHz,
    Db,
    Degrees,
    Seconds,

    Ms,

    Us,
  };
 
  static utils::Utf8String unit_to_string (Unit unit)
  {
    constexpr std::array<std::u8string_view, 8> port_unit_strings = {
      u8"none", u8"Hz", u8"MHz", u8"dB", u8"°", u8"s", u8"ms", u8"μs",
    };
    return port_unit_strings.at (ENUM_VALUE_TO_INT (unit));
  }
 
public:
  ParameterRange () = default;
 
  ParameterRange (Type type, float min, float max, float zero = 0.f, float def = 0.f)
      : type_ (type), minf_ (min), maxf_ (max),
        zerof_ (std::clamp (zero, min, max)), deff_ (std::clamp (def, min, max))
  {
  }
 
  static ParameterRange make_toggle (bool default_val)
  {
    return { Type::Toggle, 0.f, 1.f, 0.f, default_val ? 1.f : 0.f };
  }
  static ParameterRange make_gain (float max_val)
  {
    return { Type::GainAmplitude, 0.f, max_val, 0.f, 1.f };
  }
 
  constexpr float clamp_to_range (float val) const
  {
    return std::clamp (val, minf_, maxf_);
  }
 
  Q_INVOKABLE float convertFrom0To1 (float normalized_val) const
  {
    if (type_ == Type::Logarithmic)
      {
        const auto minf =
          utils::math::floats_equal (minf_, 0.f) ? 1e-20f : minf_;
        const auto maxf =
          utils::math::floats_equal (maxf_, 0.f) ? 1e-20f : maxf_;
        normalized_val =
          utils::math::floats_equal (normalized_val, 0.f) ? 1e-20f : normalized_val;
 
        /* see http://lv2plug.in/ns/ext/port-props/port-props.html#rangeSteps */
        return minf * std::pow (maxf / minf, normalized_val);
      }
    if (type_ == Type::Toggle)
      {
        return normalized_val >= 0.001f ? 1.f : 0.f;
      }
    if (type_ == Type::GainAmplitude)
      {
        return utils::math::get_amp_val_from_fader (normalized_val);
      }
 
    return minf_ + (normalized_val * (maxf_ - minf_));
  }
 
  Q_INVOKABLE float convertTo0To1 (float real_val) const
  {
 
    if (type_ == Type::Logarithmic)
      {
        const auto minf =
          utils::math::floats_equal (minf_, 0.f) ? 1e-20f : minf_;
        const auto maxf =
          utils::math::floats_equal (maxf_, 0.f) ? 1e-20f : maxf_;
        real_val = utils::math::floats_equal (real_val, 0.f) ? 1e-20f : real_val;
 
        /* see http://lv2plug.in/ns/ext/port-props/port-props.html#rangeSteps */
        return std::log (real_val / minf) / std::log (maxf / minf);
      }
    if (type_ == Type::Toggle)
      {
        return real_val;
      }
    if (type_ == Type::GainAmplitude)
      {
        return utils::math::get_fader_val_from_amp (real_val);
      }
 
    const auto sizef = maxf_ - minf_;
    return (sizef - (maxf_ - real_val)) / sizef;
  }
 
  bool is_toggled (float normalized_val) const
  {
    assert (type_ == ParameterRange::Type::Toggle);
    return utils::math::floats_equal (convertFrom0To1 (normalized_val), 1.f);
  }
 
  friend void to_json (nlohmann::json &j, const ParameterRange &p);
  friend void from_json (const nlohmann::json &j, ParameterRange &p);
 
public:
  Type type_{ Type::Linear };

  Unit unit_{};

  float minf_{ 0.f };
  float maxf_{ 1.f };

  float zerof_{ 0.f };

  float deff_{ 0.f };
 
  BOOST_DESCRIBE_CLASS (
    ParameterRange,
    (),
    (type_, unit_, minf_, maxf_, zerof_, deff_),
    (),
    ())
};

class ProcessorParameter
    : public QObject,
      public dsp::graph::IProcessable,
      public utils::UuidIdentifiableObject<ProcessorParameter>
{
  Q_OBJECT
  Q_PROPERTY (
    float baseValue READ baseValue WRITE setBaseValue NOTIFY baseValueChanged)
  Q_PROPERTY (QString label READ label CONSTANT)
  Q_PROPERTY (QString description READ description CONSTANT)
  Q_PROPERTY (ParameterRange range READ range CONSTANT)
  Q_PROPERTY (bool automatable READ automatable CONSTANT)
  QML_ELEMENT
  QML_UNCREATABLE ("")
 
public:
  struct UniqueId final
      : type_safe::strong_typedef<UniqueId, utils::Utf8String>,
        type_safe::strong_typedef_op::equality_comparison<UniqueId>,
        type_safe::strong_typedef_op::relational_comparison<UniqueId>
  {
    using type_safe::strong_typedef<UniqueId, utils::Utf8String>::strong_typedef;
 
    explicit UniqueId () = default;
 
    static_assert (StrongTypedef<UniqueId>);
 
    std::size_t hash () const { return qHash (type_safe::get (*this).view ()); }
  };
  static_assert (std::regular<UniqueId>);
 
  using Resolver =
    std::function<QPointer<ProcessorParameter> (const UniqueId &unique_id)>;
 
  ProcessorParameter (
    PortRegistry     &port_registry,
    UniqueId          unique_id,
    ParameterRange    range,
    utils::Utf8String label,
    QObject *         parent = nullptr);

  using AutomationValueProvider =
    std::function<std::optional<float> (units::sample_t sample_position)>;
 
  // ========================================================================
  // QML Interface
  // ========================================================================
 
  QString label () const { return label_.to_qstring (); }
  QString description () const { return description_->to_qstring (); }
  bool    automatable () const { return automatable_; }
 
  ParameterRange range () const { return range_; }
 
  float baseValue () const { return base_value_.load (); }
  void  setBaseValue (float newValue) [[clang::blocking]]
  {
    newValue = std::clamp (newValue, 0.f, 1.f);
    if (qFuzzyCompare (base_value_, newValue))
      return;
    base_value_ = newValue;
    Q_EMIT baseValueChanged (newValue);
  }
  Q_INVOKABLE void resetBaseValueToDefault ()
  {
    setBaseValue (range_.convertTo0To1 (range_.deff_));
  }
  Q_SIGNAL void baseValueChanged (float value);

  Q_INVOKABLE float currentValue () const { return last_modulated_value_; }

   */
  Q_INVOKABLE float valueAfterAutomationApplied () const
  {
    return last_automated_value_.load ();
  }
 
  Q_INVOKABLE void beginUserGesture ()
  {
    during_gesture_.store (true);
    Q_EMIT userGestureStarted ();
  }
  Q_INVOKABLE void endUserGesture ()
  {
    during_gesture_.store (false);
    Q_EMIT userGestureFinished ();
  }
  Q_SIGNAL void userGestureStarted ();
  Q_SIGNAL void userGestureFinished ();
 
  // ========================================================================
 
  // ========================================================================
  // IProcessable Implementation
  // ========================================================================
 
  utils::Utf8String get_node_name () const override;

  void process_block (
    EngineProcessTimeInfo  time_nfo,
    const dsp::ITransport &transport,
    const dsp::TempoMap   &tempo_map) noexcept override;
 
  void prepare_for_processing (
    const graph::GraphNode * node,
    units::sample_rate_t     sample_rate,
    nframes_t                max_block_length) override;
  void release_resources () override;
 
  // ========================================================================
 
  void set_automation_provider (AutomationValueProvider provider)
  {
    automation_value_provider_ = provider;
  }
  void unset_automation_provider () { automation_value_provider_.reset (); }
 
  PortUuidReference get_modulation_input_port_ref () const
  {
    return modulation_input_uuid_;
  }
 
  void set_description (utils::Utf8String descr)
  {
    description_ = std::move (descr);
  }
 
  void set_automatable (bool automatable) { automatable_ = automatable; }
 
  const auto &get_unique_id () const { return unique_id_; }
 
private:
  // Some of these don't need serialization because they'll be created
  // even when loading from json.
  // We just need to serialize IDs, the value, and possibly the label too for
  // debugging.
  static constexpr auto kUniqueIdKey = "uniqueId"sv;
  // static constexpr auto kTypeKey = "type"sv;
  // static constexpr auto kRangeKey = "range"sv;
  // static constexpr auto kUnitKey = "unit"sv;
  static constexpr auto kLabelKey = "label"sv;
  // static constexpr auto kSymbolKey = "symbol"sv;
  // static constexpr auto kDescriptionKey = "description"sv;
  // static constexpr auto kAutomatableKey = "automatable"sv;
  // static constexpr auto kHiddenKey = "hidden"sv;
  static constexpr auto kBaseValueKey = "baseValue"sv;
  static constexpr auto kModulationSourcePortIdKey = "modulationSourcePortId"sv;
  friend void to_json (nlohmann::json &j, const ProcessorParameter &p);
  friend void from_json (const nlohmann::json &j, ProcessorParameter &p);
 
private:
  UniqueId unique_id_;
 
  ParameterRange range_;

  utils::Utf8String label_;

  std::atomic<float> base_value_;

  std::atomic_bool during_gesture_;

  std::atomic<float> last_automated_value_;

  std::atomic<float> last_modulated_value_;

  PortUuidReference modulation_input_uuid_;
 
  // Processing cache
  dsp::CVPort * modulation_input_{};

  std::optional<AutomationValueProvider> automation_value_provider_;

  std::optional<utils::Utf8String> symbol_;

  std::optional<utils::Utf8String> description_;
 
  // Automatable (via automation provider or modulation)
  bool automatable_{ true };
 
  // Not on GUI
  bool hidden_{};
 
  BOOST_DESCRIBE_CLASS (
    ProcessorParameter,
    (utils::UuidIdentifiableObject<ProcessorParameter>),
    (),
    (),
    (unique_id_,
     range_,
     label_,
     base_value_,
     modulation_input_uuid_,
     symbol_,
     description_,
     automatable_,
     hidden_))
};
 
inline auto
format_as (const ProcessorParameter::UniqueId &id)
{
  return type_safe::get (id).view ();
}
 
using ProcessorParameterPtrVariant = std::variant<ProcessorParameter *>;
}
 
DEFINE_UUID_HASH_SPECIALIZATION (zrythm::dsp::ProcessorParameter::Uuid)
 
namespace zrythm::dsp
{
class ProcessorParameterRegistry
    : public utils::
        OwningObjectRegistry<ProcessorParameterPtrVariant, ProcessorParameter>
{
public:
  ProcessorParameterRegistry (
    dsp::PortRegistry &port_registry,
    QObject *          parent = nullptr)
      : utils::OwningObjectRegistry<
          ProcessorParameterPtrVariant,
          ProcessorParameter> (parent),
        port_registry_ (port_registry)
  {
  }
 
  ProcessorParameter *
  find_by_unique_id (const ProcessorParameter::UniqueId &id) const
  {
    const auto &map = get_hash_map ();
    for (const auto &kv : map)
      {
        if (std::get<ProcessorParameter *> (kv.second)->get_unique_id () == id)
          {
            return std::get<ProcessorParameter *> (kv.second);
          }
      }
    return nullptr;
  }
 
  ProcessorParameter *
  find_by_unique_id_or_throw (const ProcessorParameter::UniqueId &id) const
  {
    auto * val = find_by_unique_id (id);
    if (val == nullptr) [[unlikely]]
      {
        throw std::runtime_error (
          fmt::format ("Processor Parameter with unique id {} not found", id));
      }
    return val;
  }
 
private:
  struct ProcessorParameterRegistryBuilder
  {
    ProcessorParameterRegistryBuilder (dsp::PortRegistry &port_registry)
        : port_registry_ (port_registry)
    {
    }
 
    template <typename T> std::unique_ptr<T> build () const
    {
      return std::make_unique<T> (
        port_registry_, ProcessorParameter::UniqueId (u8""), ParameterRange{},
        u8"");
    }
 
    dsp::PortRegistry &port_registry_;
  };
 
  friend void
  from_json (const nlohmann::json &j, ProcessorParameterRegistry &reg)
  {
    from_json_with_builder (
      j, reg, ProcessorParameterRegistryBuilder{ reg.port_registry_ });
  }
 
private:
  dsp::PortRegistry &port_registry_;
};
 
using ProcessorParameterUuidReference = utils::UuidReference<
  utils::OwningObjectRegistry<ProcessorParameterPtrVariant, ProcessorParameter>>;
 
} // namespace zrythm::dsp
 
namespace std
{
template <> struct hash<zrythm::dsp::ProcessorParameter::UniqueId>
{
  size_t operator() (const zrythm::dsp::ProcessorParameter::UniqueId &id) const
  {
    return id.hash ();
  }
};
}