automation_track.h

// SPDX-FileCopyrightText: © 2018-2022, 2024-2025 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#ifndef __AUDIO_AUTOMATION_TRACK_H__
#define __AUDIO_AUTOMATION_TRACK_H__
 
#include "zrythm-config.h"
 
#include "dsp/position.h"
#include "gui/dsp/arranger_object_all.h"
#include "gui/dsp/arranger_object_owner.h"
#include "gui/dsp/automation_point.h"
#include "gui/dsp/port.h"
 
#include <QtQmlIntegration>
 
class AutomatableTrack;
class AutomationTracklist;


constexpr int AUTOMATION_RECORDING_TOUCH_REL_MS = 800;
 
constexpr int AUTOMATION_TRACK_DEFAULT_HEIGHT = 48;
 
enum class AutomationRecordMode
{
  Touch,
  Latch,
  NUM_AUTOMATION_RECORD_MODES,
};
 
DEFINE_ENUM_FORMATTER (
  AutomationRecordMode,
  AutomationRecordMode,
  QT_TR_NOOP_UTF8 ("Touch"),
  QT_TR_NOOP_UTF8 ("Latch"));
 
class AutomationTrack final
    : public QObject,
      public ICloneable<AutomationTrack>,
      public ArrangerObjectOwner<AutomationRegion>
{
  Q_OBJECT
  QML_ELEMENT
  Q_PROPERTY (double height READ getHeight WRITE setHeight NOTIFY heightChanged)
  Q_PROPERTY (QString label READ getLabel NOTIFY labelChanged)
  Q_PROPERTY (
    int automationMode READ getAutomationMode WRITE setAutomationMode NOTIFY
      automationModeChanged)
  Q_PROPERTY (
    int recordMode READ getRecordMode WRITE setRecordMode NOTIFY
      recordModeChanged)
  DEFINE_ARRANGER_OBJECT_OWNER_QML_PROPERTIES (
    AutomationTrack,
    regions,
    AutomationRegion)
 
public:
  using Position = dsp::Position;
  using PortUuid = Port::Uuid;
  using TrackGetter = std::function<TrackPtrVariant ()>;
 
public:
  AutomationTrack (
    PortRegistry            &port_registry,
    ArrangerObjectRegistry  &obj_registry,
    TrackGetter              track_getter,
    const ControlPort::Uuid &port_id);
 
public:
  // ========================================================================
  // QML Interface
  // ========================================================================
 
  QString       getLabel () const;
  Q_SIGNAL void labelChanged (QString label);
 
  double        getHeight () const { return height_; }
  void          setHeight (double height);
  Q_SIGNAL void heightChanged (double height);
 
  int getAutomationMode () const
  {
    return ENUM_VALUE_TO_INT (automation_mode_);
  }
  void          setAutomationMode (int automation_mode);
  Q_SIGNAL void automationModeChanged (int automation_mode);
 
  int  getRecordMode () const { return ENUM_VALUE_TO_INT (record_mode_); }
  void setRecordMode (int record_mode);
  Q_SIGNAL void recordModeChanged (int record_mode);
 
  // ========================================================================
 
  void init_loaded ();
 
  bool validate () const;

  static AutomationTrack *
  find_from_port_id (const PortUuid &id, bool basic_search);

  void set_port_id (const PortUuid &port_id);

  [[gnu::hot]] static AutomationTrack * find_from_port (
    const ControlPort       &port,
    const AutomatableTrack * track,
    bool                     basic_search);
 
  void set_automation_mode (AutomationMode mode, bool fire_events);
 
  void swap_record_mode ()
  {
    record_mode_ = static_cast<AutomationRecordMode> (
      (static_cast<int> (record_mode_) + 1)
      % static_cast<int> (AutomationRecordMode::NUM_AUTOMATION_RECORD_MODES));
  }
 
  AutomationTracklist * get_automation_tracklist () const;

  [[gnu::hot]] bool should_read_automation (RtTimePoint cur_time) const;

  [[gnu::hot]] bool
  should_be_recording (RtTimePoint cur_time, bool record_aps) const;

  void set_index (int index);

  void
  init_after_cloning (const AutomationTrack &other, ObjectCloneType clone_type)
    override;
 
  TrackPtrVariant get_track () const;

  AutomationPoint *
  get_ap_before_pos (const Position &pos, bool ends_after, bool use_snapshots)
    const;

  AutomationRegion *
  get_region_before_pos (const Position &pos, bool ends_after, bool use_snapshots)
    const;
 
  ControlPort &get_port () const;

  float get_val_at_pos (
    const Position &pos,
    bool            normalized,
    bool            ends_after,
    bool            use_snapshots) const;
 
  static int get_y_px_from_height_and_normalized_val (
    const float height,
    const float normalized_val)
  {
    return static_cast<int> (height - normalized_val * height);
  }

  int get_y_px_from_normalized_val (float normalized_val) const
  {
    return get_y_px_from_height_and_normalized_val (
      static_cast<float> (height_), normalized_val);
  }
 
  void set_caches (CacheType types);
 
  bool contains_automation () const { return !get_children_vector ().empty (); }
 
  bool verify () const;
 
  Location get_location (const AutomationRegion &) const override;
 
  std::string
  get_field_name_for_serialization (const AutomationRegion *) const override
  {
    return "regions";
  }
 
private:
  static constexpr std::string_view kIndexKey = "index";
  static constexpr std::string_view kPortIdKey = "portId";
  static constexpr std::string_view kCreatedKey = "created";
  static constexpr std::string_view kAutomationModeKey = "automationMode";
  static constexpr std::string_view kRecordModeKey = "recordMode";
  static constexpr std::string_view kVisibleKey = "visible";
  static constexpr std::string_view kHeightKey = "height";
  friend void to_json (nlohmann::json &j, const AutomationTrack &track)
  {
    to_json (j, static_cast<const ArrangerObjectOwner &> (track));
    j[kIndexKey] = track.index_;
    j[kPortIdKey] = track.port_id_;
    j[kCreatedKey] = track.created_;
    j[kAutomationModeKey] = track.automation_mode_;
    j[kRecordModeKey] = track.record_mode_;
    j[kVisibleKey] = track.visible_;
    j[kHeightKey] = track.height_;
  }
  friend void from_json (const nlohmann::json &j, AutomationTrack &track)
  {
    from_json (j, static_cast<ArrangerObjectOwner &> (track));
    j.at (kIndexKey).get_to (track.index_);
    j.at (kPortIdKey).get_to (track.port_id_);
    j.at (kCreatedKey).get_to (track.created_);
    j.at (kAutomationModeKey).get_to (track.automation_mode_);
    j.at (kRecordModeKey).get_to (track.record_mode_);
    j.at (kVisibleKey).get_to (track.visible_);
    j.at (kHeightKey).get_to (track.height_);
  }
 
public:
  PortRegistry           &port_registry_;
  ArrangerObjectRegistry &object_registry_;
  TrackGetter             track_getter_;

  int index_ = 0;

  PortUuid port_id_;

  bool created_ = false;

  bool visible_ = false;

  int y_ = 0;

  double height_ = AUTOMATION_TRACK_DEFAULT_HEIGHT;

  float last_recorded_value_ = 0.f;

  AutomationMode automation_mode_ = AutomationMode::Read;

  AutomationRecordMode record_mode_ = (AutomationRecordMode) 0;

  bool recording_started_ = false;

  AutomationRegion * recording_region_ = nullptr;

  bool recording_start_sent_ = false;

  bool recording_paused_ = false;
 
private:
  // AutomationTracklist * atl_ = nullptr;

  // std::optional<std::reference_wrapper<ControlPort>> port_;
};
 
#endif // __AUDIO_AUTOMATION_TRACK_H__