port_identifier.h

Go to the documentation of this file.

// clang-format off
// SPDX-FileCopyrightText: © 2018-2021, 2023 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
// clang-format on
 
#ifndef __AUDIO_PORT_IDENTIFIER_H__
#define __AUDIO_PORT_IDENTIFIER_H__
 
#include "zrythm-config.h"
 
#include <cstddef>
#include <cstdint>
 
#include "plugins/plugin_identifier.h"
#include "utils/types.h"
 
#define PORT_IDENTIFIER_SCHEMA_VERSION 1
 
#define PORT_IDENTIFIER_MAGIC 3411841
#define IS_PORT_IDENTIFIER(tr) \
  (tr && ((PortIdentifier *) tr)->magic == PORT_IDENTIFIER_MAGIC)
 
enum class ZPortFlow
{
  Z_PORT_FLOW_UNKNOWN,
  Z_PORT_FLOW_INPUT,
  Z_PORT_FLOW_OUTPUT
};
 
enum class ZPortType
{
  Z_PORT_TYPE_UNKNOWN,
  Z_PORT_TYPE_CONTROL,
  Z_PORT_TYPE_AUDIO,
  Z_PORT_TYPE_EVENT,
  Z_PORT_TYPE_CV
};
 
enum class PortUnit
{
  Z_PORT_UNIT_NONE,
  Z_PORT_UNIT_HZ,
  Z_PORT_UNIT_MHZ,
  Z_PORT_UNIT_DB,
  Z_PORT_UNIT_DEGREES,
  Z_PORT_UNIT_SECONDS,
 
  Z_PORT_UNIT_MS,
 
  Z_PORT_UNIT_US,
};
 
const char *
port_unit_to_str (const PortUnit unit);
 
typedef struct PortIdentifier
{
  enum class OwnerType
  {
    /* NONE, */
    PORT_OWNER_TYPE_AUDIO_ENGINE,
 
    PLUGIN,
 
    TRACK,
 
    CHANNEL,
 
    FADER,
 
    CHANNEL_SEND,
 
    /* TrackProcessor. */
    TRACK_PROCESSOR,
 
    HW,
 
    PORT_OWNER_TYPE_TRANSPORT,
 
    MODULATOR_MACRO_PROCESSOR,
  };
 
  enum class Flags
  {
    STEREO_L = 1 << 0,
    STEREO_R = 1 << 1,
    PianoRoll = 1 << 2,
    SIDECHAIN = 1 << 3,
    MAIN_PORT = 1 << 4,
    MANUAL_PRESS = 1 << 5,
 
    AMPLITUDE = 1 << 6,
 
    STEREO_BALANCE = 1 << 7,
 
    WANT_POSITION = 1 << 8,
 
    TRIGGER = 1 << 9,
 
    TOGGLE = 1 << 10,
 
    INTEGER = 1 << 11,
 
    FREEWHEEL = 1 << 12,
 
    REPORTS_LATENCY = 1 << 13,
 
    NOT_ON_GUI = 1 << 14,
 
    PLUGIN_ENABLED = 1 << 15,
 
    PLUGIN_CONTROL = 1 << 16,
 
    FADER_MUTE = 1 << 17,
 
    CHANNEL_FADER = 1 << 18,
 
    AUTOMATABLE = 1 << 19,
 
    MIDI_AUTOMATABLE = 1 << 20,
 
    SEND_RECEIVABLE = 1 << 21,
 
    BPM = 1 << 22,
 
    GENERIC_PLUGIN_PORT = 1 << 23,
 
    PLUGIN_GAIN = 1 << 24,
 
    TP_MONO = 1 << 25,
 
    TP_INPUT_GAIN = 1 << 26,
 
    HW = 1 << 27,
 
    MODULATOR_MACRO = 1 << 28,
 
    LOGARITHMIC = 1 << 29,
 
    IS_PROPERTY = 1 << 30,
  };
 
  enum class Flags2
  {
    TRANSPORT_ROLL = 1 << 0,
    TRANSPORT_STOP = 1 << 1,
    TRANSPORT_BACKWARD = 1 << 2,
    TRANSPORT_FORWARD = 1 << 3,
    TRANSPORT_LOOP_TOGGLE = 1 << 4,
    TRANSPORT_REC_TOGGLE = 1 << 5,
 
    SUPPORTS_PATCH_MESSAGE = 1 << 6,
 
    ENUMERATION = 1 << 7,
 
    URI_PARAM = 1 << 8,
 
    SEQUENCE = 1 << 9,
 
    SUPPORTS_MIDI = 1 << 10,
 
    TP_OUTPUT_GAIN = 1 << 11,
 
    MIDI_PITCH_BEND = 1 << 12,
 
    MIDI_POLY_KEY_PRESSURE = 1 << 13,
 
    MIDI_CHANNEL_PRESSURE = 1 << 14,
 
    CHANNEL_SEND_ENABLED = 1 << 15,
 
    CHANNEL_SEND_AMOUNT = 1 << 16,
 
    BEATS_PER_BAR = 1 << 17,
 
    BEAT_UNIT = 1 << 18,
 
    FADER_SOLO = 1 << 19,
 
    FADER_LISTEN = 1 << 20,
 
    FADER_MONO_COMPAT = 1 << 21,
 
    TRACK_RECORDING = 1 << 22,
 
    TP_MONITOR_AUDIO = 1 << 23,
 
    PREFADER = 1 << 24,
 
    POSTFADER = 1 << 25,
 
    MonitorFader = 1 << 26,
 
    SAMPLE_PROCESSOR_FADER = 1 << 27,
 
    SAMPLE_PROCESSOR_TRACK = 1 << 28,
 
    FADER_SWAP_PHASE = 1 << 29,
 
    MIDI_CLOCK = 1 << 30,
  };
 
  int schema_version = PORT_IDENTIFIER_SCHEMA_VERSION;
 
  char * label = nullptr;
 
  char * sym = nullptr;
 
  char * uri = nullptr;
 
  char * comment = nullptr;
 
  PortIdentifier::OwnerType owner_type = (OwnerType) 0;
  ZPortType type = (ZPortType) 0;
  ZPortFlow flow = (ZPortFlow) 0;
  PortIdentifier::Flags  flags = (Flags) 0;
  PortIdentifier::Flags2 flags2 = (Flags2) 0;
 
  PortUnit unit = (PortUnit) 0;
 
  PluginIdentifier plugin_id = {};
 
  char * port_group = nullptr;
 
  char * ext_port_id = nullptr;
 
  unsigned int track_name_hash = 0;
 
  int port_index = 0;
 
public:
  PortIdentifier () = default;
  PortIdentifier (const PortIdentifier &other);
  ~PortIdentifier ();
 
  PortIdentifier &operator= (const PortIdentifier &other);
 
  void init ();
 
  inline const char * get_label () const { return label; }
 
  inline int get_midi_channel () const
  {
    if (
      static_cast<int> (flags2 & PortIdentifier::Flags2::MIDI_PITCH_BEND) != 0
      || static_cast<int> (flags2 & PortIdentifier::Flags2::MIDI_POLY_KEY_PRESSURE)
           != 0
      || static_cast<int> (flags2 & PortIdentifier::Flags2::MIDI_CHANNEL_PRESSURE)
           != 0)
      {
        return port_index + 1;
      }
    else if (
      static_cast<int> (flags & PortIdentifier::Flags::MIDI_AUTOMATABLE) != 0)
      {
        return port_index / 128 + 1;
      }
    return -1;
  }
 
  WARN_UNUSED_RESULT bool is_equal (const PortIdentifier &other) const;
 
  NONNULL void print_to_str (char * buf, size_t buf_sz) const;
  void         print () const;
  bool         validate () const;
  uint32_t     get_hash () const;
} PortIdentifier;
 
ENUM_ENABLE_BITSET (PortIdentifier::Flags);
ENUM_ENABLE_BITSET (PortIdentifier::Flags2);
 
int
port_identifier_port_group_cmp (const void * p1, const void * p2);
 
const char *
port_identifier_get_label (void * data);
 
uint32_t
port_identifier_get_hash (const void * data);
 
void
port_identifier_destroy_notify (void * data);
 
int
port_identifier_is_equal_func (const void * a, const void * b);
 
#endif