port_identifier.h

// SPDX-FileCopyrightText: © 2018-2021, 2023-2025 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#pragma once
 
#include "zrythm-config.h"
 
#include "utils/icloneable.h"
#include "utils/types.h"
#include "utils/uuid_identifiable_object.h"
 
namespace zrythm::structure::tracks
{
class Track;
}
namespace zrythm::gui::old_dsp::plugins
{
class Plugin;
}
 
class Port;
 
namespace zrythm::dsp
{

enum class PortFlow
{
  Unknown,
  Input,
  Output
};

enum class PortType
{
  Unknown,
  Control,
  Audio,
  Event,
  CV
};

enum class PortUnit
{
  None,
  Hz,
  MHz,
  Db,
  Degrees,
  Seconds,

  Ms,

  Us,
};

class PortIdentifier
{
public:
  using TrackUuid =
    utils::UuidIdentifiableObject<zrythm::structure::tracks::Track>::Uuid;
  using PluginUuid =
    utils::UuidIdentifiableObject<gui::old_dsp::plugins::Plugin>::Uuid;
  using PortUuid = utils::UuidIdentifiableObject<Port>::Uuid;

  enum class OwnerType
  {
    /* NONE, */
    AudioEngine,

    Plugin,

    Track,

    Channel,

    Fader,

    ChannelSend,
 
    /* TrackProcessor. */
    TrackProcessor,

    HardwareProcessor,

    Transport,

    ModulatorMacroProcessor,
  };

  enum class Flags : std::uint64_t
  {
    StereoL = UINT64_C (1) << 0,
    StereoR = UINT64_C (1) << 1,
    PianoRoll = UINT64_C (1) << 2,
    Sidechain = UINT64_C (1) << 3,
    MainPort = UINT64_C (1) << 4,

    ManualPress = UINT64_C (1) << 5,

    Amplitude = UINT64_C (1) << 6,

    StereoBalance = UINT64_C (1) << 7,

    WantPosition = UINT64_C (1) << 8,

    Trigger = UINT64_C (1) << 9,

    Toggle = UINT64_C (1) << 10,

    Integer = UINT64_C (1) << 11,

    Freewheel = UINT64_C (1) << 12,

    ReportsLatency = UINT64_C (1) << 13,

    NotOnGui = UINT64_C (1) << 14,

    PluginEnabled = UINT64_C (1) << 15,

    PluginControl = UINT64_C (1) << 16,

    FaderMute = UINT64_C (1) << 17,

    ChannelFader = UINT64_C (1) << 18,

    Automatable = UINT64_C (1) << 19,

    MidiAutomatable = UINT64_C (1) << 20,

    SendReceivable = UINT64_C (1) << 21,

    GenericPluginPort = UINT64_C (1) << 22,

    PluginGain = UINT64_C (1) << 23,

    TpMono = UINT64_C (1) << 24,

    TpInputGain = UINT64_C (1) << 25,

    Hw = UINT64_C (1) << 26,

    ModulatorMacro = UINT64_C (1) << 27,

    Logarithmic = UINT64_C (1) << 28,

    IsProperty = UINT64_C (1) << 29,

    TransportRoll = UINT64_C (1) << 30,
    TransportStop = UINT64_C (1) << 31,
    TransportBackward = UINT64_C (1) << 32,
    TransportForward = UINT64_C (1) << 33,
    TransportLoopToggle = UINT64_C (1) << 34,
    TransportRecToggle = UINT64_C (1) << 35,

    SupportsPatchMessage = UINT64_C (1) << 36,

    Enumeration = UINT64_C (1) << 37,

    UriParam = UINT64_C (1) << 38,

    Sequence = UINT64_C (1) << 39,

    SupportsMidi = UINT64_C (1) << 40,

    TpOutputGain = UINT64_C (1) << 41,

    MidiPitchBend = UINT64_C (1) << 42,

    MidiPolyKeyPressure = UINT64_C (1) << 43,

    MidiChannelPressure = UINT64_C (1) << 44,

    ChannelSendEnabled = UINT64_C (1) << 45,

    ChannelSendAmount = UINT64_C (1) << 46,

    FaderSolo = UINT64_C (1) << 47,

    FaderListen = UINT64_C (1) << 48,

    FaderMonoCompat = UINT64_C (1) << 49,

    TrackRecording = UINT64_C (1) << 50,

    TpMonitorAudio = UINT64_C (1) << 51,

    Prefader = UINT64_C (1) << 52,

    Postfader = UINT64_C (1) << 53,

    MonitorFader = UINT64_C (1) << 54,

    SampleProcessorFader = UINT64_C (1) << 55,

    SampleProcessorTrack = UINT64_C (1) << 56,

    FaderSwapPhase = UINT64_C (1) << 57,

    MidiClock = UINT64_C (1) << 58,
  };
 
  friend bool operator== (const PortIdentifier &lhs, const PortIdentifier &rhs);
 
public:
  // void init ();
 
  utils::Utf8String get_label () const { return label_; }
 
  bool is_control () const { return type_ == PortType::Control; }
  bool is_midi () const { return type_ == PortType::Event; }
  bool is_cv () const { return type_ == PortType::CV; }
  bool is_audio () const { return type_ == PortType::Audio; }
 
  bool is_input () const { return flow_ == PortFlow::Input; }
  bool is_output () const { return flow_ == PortFlow::Output; }
 
  bool is_monitor_fader_stereo_in_or_out_port () const
  {
    return ENUM_BITSET_TEST (flags_, Flags::MonitorFader)
           && (ENUM_BITSET_TEST (flags_, Flags::StereoL) || ENUM_BITSET_TEST (flags_, Flags::StereoR));
  }
 
  auto get_track_id () const { return track_id_; }
  void set_track_id (TrackUuid track_id) { track_id_ = track_id; }
  auto get_plugin_id () const { return plugin_id_; }
  void set_plugin_id (PluginUuid plugin_id) { plugin_id_ = plugin_id; }
  auto get_symbol () const { return sym_; }
 
  std::string print_to_str () const;
  void        print () const;
  size_t      get_hash () const;
 
  static utils::Utf8String port_unit_to_string (PortUnit unit);
 
  friend void init_from (
    PortIdentifier        &obj,
    const PortIdentifier  &other,
    utils::ObjectCloneType clone_type)
  {
    obj = other;
  }
 
public:
  size_t port_index_{};

  std::optional<TrackUuid> track_id_;

  PortIdentifier::OwnerType owner_type_{};
  PortType type_{ PortType::Unknown };
  PortFlow flow_{ PortFlow::Unknown };

  PortUnit unit_{ PortUnit::None };

  PortIdentifier::Flags flags_{};

  std::optional<PluginUuid> plugin_id_;

  utils::Utf8String label_;

  utils::Utf8String sym_;

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

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

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

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

  std::optional<midi_byte_t> midi_channel_;
 
  friend void to_json (nlohmann::json &j, const PortIdentifier &port)
  {
    j = nlohmann::json{
      { "label",          port.label_        },
      { "symbol",         port.sym_          },
      { "uri",            port.uri_          },
      { "comment",        port.comment_      },
      { "ownerType",      port.owner_type_   },
      { "type",           port.type_         },
      { "flow",           port.flow_         },
      { "unit",           port.unit_         },
      { "flags",          port.flags_        },
      { "trackId",        port.track_id_     },
      { "pluginId",       port.plugin_id_    },
      { "portGroup",      port.port_group_   },
      { "externalPortId", port.ext_port_id_  },
      { "portIndex",      port.port_index_   },
      { "midiChannel",    port.midi_channel_ },
    };
  }
  friend void from_json (const nlohmann::json &j, PortIdentifier &port)
  {
    j.at ("label").get_to (port.label_);
    j.at ("symbol").get_to (port.sym_);
    j.at ("uri").get_to (port.uri_);
    j.at ("comment").get_to (port.comment_);
    j.at ("ownerType").get_to (port.owner_type_);
    j.at ("type").get_to (port.type_);
    j.at ("flow").get_to (port.flow_);
    j.at ("unit").get_to (port.unit_);
    j.at ("flags").get_to (port.flags_);
    j.at ("trackId").get_to (port.track_id_);
    j.at ("pluginId").get_to (port.plugin_id_);
    j.at ("portGroup").get_to (port.port_group_);
    j.at ("externalPortId").get_to (port.ext_port_id_);
    j.at ("portIndex").get_to (port.port_index_);
    j.at ("midiChannel").get_to (port.midi_channel_);
  }
};
 
}; // namespace zrythm::dsp
 
ENUM_ENABLE_BITSET (zrythm::dsp::PortIdentifier::Flags);
 
namespace std
{
template <> struct hash<zrythm::utils::UuidIdentifiableObject<Port>::Uuid>
{
  std::size_t
  operator() (const zrythm::utils::UuidIdentifiableObject<Port>::Uuid &uuid) const
  {
    return uuid.hash ();
  }
};
}