control_port.h

// SPDX-FileCopyrightText: © 2018-2022, 2024-2025 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#pragma once
#include <utility>
 
#include "gui/dsp/port.h"
#include "utils/icloneable.h"
#include "utils/math.h"
#include "utils/monotonic_time_provider.h"

class ControlPort final
    : public QObject,
      public Port,
      public PortConnectionsCacheMixin<CVPort>
{
  Q_OBJECT
  QML_ELEMENT
 
public:
  using AutomationValueGetter =
    std::function<std::optional<float> (signed_frame_t global_frame)>;

  struct ChangeEvent
  {
    PortIdentifier::Flags flag{};

    float real_val = 0.0f;

    int ival = 0;
  };

  struct ScalePoint
  {
    float             val_;
    utils::Utf8String label_;
 
    ScalePoint (float val, utils::Utf8String label)
        : val_ (val), label_ (std::move (label))
    {
    }
 
    friend auto operator<=> (const ScalePoint &lhs, const ScalePoint &rhs)
    {
      return lhs.val_ <=> rhs.val_;
    }
 
    friend bool operator== (const ScalePoint &lhs, const ScalePoint &rhs)
    {
      return utils::math::floats_equal (lhs.val_, rhs.val_);
    }
  };
 
public:
  ControlPort (utils::Utf8String label = {});

  float normalized_val_to_real (float normalized_val) const;

  float real_val_to_normalized (float real_val) const;

  static bool is_val_toggled (float val) { return val > 0.001f; }

  bool is_toggled () const { return is_val_toggled (control_); }

  int get_int () const { return get_int_from_val (control_); }

  void set_unit_from_str (const utils::Utf8String &str);

  static int get_int_from_val (float val)
  {
    const auto s32 = utils::math::round_to_signed_32 (val);
    assert (
      s32 >= std::numeric_limits<int>::min ()
      && s32 <= std::numeric_limits<int>::max ());
    return static_cast<int> (s32);
  }

  float get_snapped_val () const
  {
    return get_snapped_val_from_val (get_val ());
  }

  float get_snapped_val_from_val (float val) const;

  float get_val () const { return control_; }

  float get_normalized_val () const
  {
    return real_val_to_normalized (control_);
  }

  float get_unsnapped_val () const { return unsnapped_control_; }

  float get_default_val () const { return deff_; }

  void set_real_val (float val) { set_control_value (val, false, false); }

  void set_real_val_w_events (float val)
  {
    set_control_value (val, false, true);
  }

  void set_toggled (bool toggled, bool forward_events)
  {
    set_control_value (toggled ? 1.f : 0.f, false, forward_events);
  }

  [[gnu::hot]] void set_val_from_normalized (float val, bool automating);

  void
  set_control_value (float val, bool is_normalized, bool forward_event_to_plugin);

  void set_automation_value_reader (AutomationValueGetter reader)
  {
    automation_reader_ = reader;
  }
 
  RtTimePoint ms_since_last_change () const
  {
    return time_provider_->get_monotonic_time_usecs () - last_change_time_;
  }

  [[gnu::hot]] float get_control_value (bool normalize) const;
 
  [[gnu::hot]] void process_block (EngineProcessTimeInfo time_nfo) override;
 
  void clear_buffer (std::size_t block_length) override { }
 
  friend void init_from (
    ControlPort           &obj,
    const ControlPort     &other,
    utils::ObjectCloneType clone_type);
 
private:
  static constexpr std::string_view kControlKey = "control";
  static constexpr std::string_view kRangeKey = "range";
  static constexpr std::string_view kDefaultValueKey = "defaultValue";
  static constexpr std::string_view kCarlaParameterIdKey = "carlaParameterId";
  static constexpr std::string_view kBaseValueKey = "baseValue";
  friend void to_json (nlohmann::json &j, const ControlPort &p)
  {
    to_json (j, static_cast<const Port &> (p));
    j[kControlKey] = p.control_;
    j[kRangeKey] = p.range_;
    j[kDefaultValueKey] = p.deff_;
    j[kCarlaParameterIdKey] = p.carla_param_id_;
    j[kBaseValueKey] = p.base_value_;
  }
  friend void from_json (const nlohmann::json &j, ControlPort &p)
  {
    from_json (j, static_cast<Port &> (p));
    j.at (kControlKey).get_to (p.control_);
    j.at (kRangeKey).get_to (p.range_);
    j.at (kDefaultValueKey).get_to (p.deff_);
    j.at (kCarlaParameterIdKey).get_to (p.carla_param_id_);
    j.at (kBaseValueKey).get_to (p.base_value_);
  }

  // void forward_control_change_event ();
 
public:
  float control_ = 0.f;

  float base_value_ = 0.f;

  std::vector<ScalePoint> scale_points_;
 
  /* --- MIDI CC info --- */
 
  /*
   * Next 2 objects are MIDI CC info, if MIDI CC in track processor.
   *
   * Used as a cache.
   */

  midi_byte_t midi_channel_ = 0;

  midi_byte_t midi_cc_no_ = 0;
 
  /* --- end MIDI CC info --- */

  float deff_ = 0.f;

  int carla_param_id_ = 0;

  bool automating_ = false;

  float unsnapped_control_ = 0.f;

  bool value_changed_from_reading_{};

  bool received_ui_event_{};
 
private:
  RtTimePoint last_change_time_{};
 
  std::optional<AutomationValueGetter> automation_reader_;
 
  std::unique_ptr<utils::QElapsedTimeProvider> time_provider_;
};