port_identifier.h

// SPDX-FileCopyrightText: © 2018-2021, 2023-2024 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#ifndef ZRYTHM_DSP_PORT_IDENTIFIER_H
#define ZRYTHM_DSP_PORT_IDENTIFIER_H
 
#include "zrythm-config.h"
 
#include "utils/icloneable.h"
#include "utils/types.h"
#include "utils/uuid_identifiable_object.h"
 
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 ICloneable<PortIdentifier>
{
public:
  using TrackUuid = utils::UuidIdentifiableObject<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
  {
    StereoL = 1 << 0,
    StereoR = 1 << 1,
    PianoRoll = 1 << 2,
    Sidechain = 1 << 3,
    MainPort = 1 << 4,

    ManualPress = 1 << 5,

    Amplitude = 1 << 6,

    StereoBalance = 1 << 7,

    WantPosition = 1 << 8,

    Trigger = 1 << 9,

    Toggle = 1 << 10,

    Integer = 1 << 11,

    Freewheel = 1 << 12,

    ReportsLatency = 1 << 13,

    NotOnGui = 1 << 14,

    PluginEnabled = 1 << 15,

    PluginControl = 1 << 16,

    FaderMute = 1 << 17,

    ChannelFader = 1 << 18,

    Automatable = 1 << 19,

    MidiAutomatable = 1 << 20,

    SendReceivable = 1 << 21,

    Bpm = 1 << 22,

    GenericPluginPort = 1 << 23,

    PluginGain = 1 << 24,

    TpMono = 1 << 25,

    TpInputGain = 1 << 26,

    Hw = 1 << 27,

    ModulatorMacro = 1 << 28,

    Logarithmic = 1 << 29,

    IsProperty = 1 << 30,
  };
 
  enum class Flags2
  {
    TransportRoll = 1 << 0,
    TransportStop = 1 << 1,
    TransportBackward = 1 << 2,
    TransportForward = 1 << 3,
    TransportLoopToggle = 1 << 4,
    TransportRecToggle = 1 << 5,

    SupportsPatchMessage = 1 << 6,

    Enumeration = 1 << 7,

    UriParam = 1 << 8,

    Sequence = 1 << 9,

    SupportsMidi = 1 << 10,

    TpOutputGain = 1 << 11,

    MidiPitchBend = 1 << 12,

    MidiPolyKeyPressure = 1 << 13,

    MidiChannelPressure = 1 << 14,

    ChannelSendEnabled = 1 << 15,

    ChannelSendAmount = 1 << 16,

    BeatsPerBar = 1 << 17,

    BeatUnit = 1 << 18,

    FaderSolo = 1 << 19,

    FaderListen = 1 << 20,

    FaderMonoCompat = 1 << 21,

    TrackRecording = 1 << 22,

    TpMonitorAudio = 1 << 23,

    Prefader = 1 << 24,

    Postfader = 1 << 25,

    MonitorFader = 1 << 26,

    SampleProcessorFader = 1 << 27,

    SampleProcessorTrack = 1 << 28,

    FaderSwapPhase = 1 << 29,

    MidiClock = 1 << 30,
  };
 
  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 (flags2_, Flags2::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;
  bool        validate () const;
  size_t      get_hash () const;
 
  static utils::Utf8String port_unit_to_string (PortUnit unit);
 
  void
  init_after_cloning (const PortIdentifier &other, ObjectCloneType clone_type)
    override
  {
    *this = 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_{};
  PortIdentifier::Flags2 flags2_{};

  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_        },
      { "flags2",         port.flags2_       },
      { "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 ("flags2").get_to (port.flags2_);
    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);
ENUM_ENABLE_BITSET (zrythm::dsp::PortIdentifier::Flags2);
 
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 ();
  }
};
}
 
#endif