port.h

// SPDX-FileCopyrightText: © 2018-2024 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#ifndef ZRYTHM_GUI_DSP_PORT_H
#define ZRYTHM_GUI_DSP_PORT_H
 
#include "zrythm-config.h"
 
#include "dsp/graph_node.h"
#include "dsp/port_identifier.h"
#include "gui/dsp/port_backend.h"
#include "gui/dsp/port_connection.h"
#include "utils/audio.h"
#include "utils/ring_buffer.h"
#include "utils/types.h"
#include "utils/uuid_identifiable_object.h"
 
class AudioEngine;
class Track;
class PortConnection;
struct EngineProcessTimeInfo;

 
constexpr int TIME_TO_RESET_PEAK = 4800000;
 
template <typename T>
concept FinalPortSubclass = std::derived_from<T, Port> && FinalClass<T>;
 
class PortRange
{
public:
  PortRange () = default;
 
  PortRange (float min, float max, float zero = 0.f)
      : minf_ (min), maxf_ (max), zerof_ (zero)
  {
  }
 
  float clamp_to_range (float val) { return std::clamp (val, minf_, maxf_); }
 
private:
  static constexpr std::string_view kMinKey = "minf";
  static constexpr std::string_view kMaxKey = "maxf";
  static constexpr std::string_view kZeroKey = "zerof";
  friend void to_json (nlohmann::json &j, const PortRange &p)
  {
    j[kMinKey] = p.minf_;
    j[kMaxKey] = p.maxf_;
    j[kZeroKey] = p.zerof_;
  }
  friend void from_json (const nlohmann::json &j, PortRange &p)
  {
    j.at (kMinKey).get_to (p.minf_);
    j.at (kMaxKey).get_to (p.maxf_);
    j.at (kZeroKey).get_to (p.zerof_);
  }
 
public:
  float minf_ = 0.f;
  float maxf_ = 1.f;

  float zerof_ = 0.f;
};
 
class IPortOwner
{
public:
  using TrackUuid = dsp::PortIdentifier::TrackUuid;
  using PluginUuid = dsp::PortIdentifier::PluginUuid;
  using PortUuid = dsp::PortIdentifier::PortUuid;
 
  virtual ~IPortOwner () = default;
 
  virtual bool is_in_active_project () const = 0;

  virtual void
  set_port_metadata_from_owner (dsp::PortIdentifier &id, PortRange &range)
    const = 0;
 
  virtual utils::Utf8String
  get_full_designation_for_port (const dsp::PortIdentifier &id) const
  {
    return id.get_label ();
  };

  virtual void on_control_change_event (
    const PortUuid            &port_uuid,
    const dsp::PortIdentifier &id,
    float                      val) { };

  virtual void on_midi_activity (const dsp::PortIdentifier &id) { }

  virtual bool should_sum_data_from_backend () const { return true; }

  virtual bool should_bounce_to_master (utils::audio::BounceStep step) const
  {
    return false;
  }

  virtual bool are_events_on_midi_channel_approved (midi_byte_t channel) const
  {
    return true;
  }
};
 
class IPortConnectionManager
{
  virtual ~IPortConnectionManager () = default;
};

class Port : public dsp::IProcessable, public utils::UuidIdentifiableObject<Port>
{
  Q_DISABLE_COPY_MOVE (Port)
public:
  using PortIdentifier = dsp::PortIdentifier;
  using PortType = dsp::PortType;
  using PortFlow = dsp::PortFlow;
 
  ~Port () override { disconnect_all (); }
 
  static std::unique_ptr<Port> create_unique_from_type (PortType type);

  void init_loaded (IPortOwner &owner) { set_owner (owner); }

  bool is_in_active_project () const
  {
    return owner_ && owner_->is_in_active_project ();
  }
 
  void set_owner (IPortOwner &owner);
 
  utils::Utf8String get_label () const;
 
  bool is_control () const { return id_->is_control (); }
  bool is_audio () const { return id_->type_ == PortType::Audio; }
  bool is_cv () const { return id_->type_ == PortType::CV; }
  bool is_event () const { return id_->type_ == PortType::Event; }
  bool is_midi () const { return is_event (); }
  bool is_input () const { return id_->flow_ == PortFlow::Input; }
  bool is_output () const { return id_->flow_ == PortFlow::Output; }

  virtual void allocate_bufs () = 0;
 
  utils::Utf8String get_node_name () const override
  {
    return get_full_designation ();
  }
 
  nframes_t get_single_playback_latency () const override { return 0; }
 
  [[gnu::hot]] void process_block (EngineProcessTimeInfo time_nfo) override;

  virtual void clear_buffer (AudioEngine &engine) = 0;

  virtual bool has_sound () const { return false; };

  utils::Utf8String get_full_designation () const
  {
    return (owner_ != nullptr)
             ? owner_->get_full_designation_for_port (*id_)
             : get_label ();
  }
 
  void print_full_designation () const;

  void set_expose_to_backend (AudioEngine &engine, bool expose);

  bool is_exposed_to_backend () const;

  void rename_backend (AudioEngine &engine);

  int get_num_unlocked_srcs () const;

  int get_num_unlocked_dests () const;

  void change_track (IPortOwner::TrackUuid new_track_id);

  [[gnu::hot]] virtual void
  process (EngineProcessTimeInfo time_nfo, bool noroll) = 0;

  virtual void copy_metadata_from_project (const Port &project_port) { };

  virtual void restore_from_non_project (const Port &non_project) { };

  [[gnu::hot]] void clear_external_buffer () override;
 
  bool needs_external_buffer_clear_on_early_return () const override;

  void disconnect_all ();

  size_t get_hash () const;
 
  bool     has_label () const { return !id_->label_.empty (); }
  PortType get_type () const { return id_->type_; }
  PortFlow get_flow () const { return id_->flow_; }
 
protected:
  Port ();
 
  Port (
    utils::Utf8String label,
    PortType          type = {},
    PortFlow          flow = {},
    float             minf = 0.f,
    float             maxf = 1.f,
    float             zerof = 0.f);
 
  void copy_members_from (const Port &other, ObjectCloneType clone_type);
 
  int get_num_unlocked (bool sources) const;
 
private:
  static constexpr std::string_view kIdKey = "id";
  static constexpr std::string_view kExposedToBackendKey = "exposedToBackend";
  friend void                       to_json (nlohmann::json &j, const Port &p)
  {
    j[kIdKey] = p.id_;
    j[kExposedToBackendKey] = p.exposed_to_backend_;
  }
  friend void from_json (const nlohmann::json &j, Port &p)
  {
    j.at (kIdKey).get_to (p.id_);
    j.at (kExposedToBackendKey).get_to (p.exposed_to_backend_);
  }
 
public:
  std::unique_ptr<PortIdentifier> id_;
 
protected:
  bool exposed_to_backend_ = false;
 
public:
  std::vector<Port *> srcs_;

  std::vector<Port *> dests_;

  std::vector<std::unique_ptr<PortConnection>> src_connections_;
  std::vector<std::unique_ptr<PortConnection>> dest_connections_;
 
  PortRange range_;

  long capture_latency_ = 0;

  long playback_latency_ = 0;

  bool deleting_ = false;

  bool write_ring_buffers_ = false;

  std::vector<float> buf_;

  std::unique_ptr<RingBuffer<float>> audio_ring_;

  size_t last_buf_sz_ = 0;

  std::unique_ptr<PortBackend> backend_;
 
  IPortOwner * owner_{};
};
 
class MidiPort;
class AudioPort;
class CVPort;
class ControlPort;
using PortVariant = std::variant<MidiPort, AudioPort, CVPort, ControlPort>;
using PortPtrVariant = to_pointer_variant<PortVariant>;
using PortRefVariant = to_reference_variant<PortVariant>;
 
using PortRegistry = utils::OwningObjectRegistry<PortPtrVariant, Port>;
using PortRegistryRef = std::reference_wrapper<PortRegistry>;
using PortUuidReference = utils::UuidReference<PortRegistry>;
 
void
from_json (const nlohmann::json &j, PortRegistry &registry);

 
#endif