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 <stdbool.h>
 
#include "plugins/plugin_identifier.h"
#include "utils/string.h"
#include "utils/yaml.h"
 
#define PORT_IDENTIFIER_SCHEMA_VERSION 1
 
#define PORT_IDENTIFIER_MAGIC 3411841
#define IS_PORT_IDENTIFIER(tr) \
  (tr && ((PortIdentifier *) tr)->magic == PORT_IDENTIFIER_MAGIC)
 
typedef enum PortFlow
{
  FLOW_UNKNOWN,
  FLOW_INPUT,
  FLOW_OUTPUT
} PortFlow;
 
static const cyaml_strval_t port_flow_strings[] = {
  {"unknown", FLOW_UNKNOWN},
  { "input",  FLOW_INPUT  },
  { "output", FLOW_OUTPUT },
};
 
typedef enum PortType
{
  TYPE_UNKNOWN,
  TYPE_CONTROL,
  TYPE_AUDIO,
  TYPE_EVENT,
  TYPE_CV
} PortType;
 
static const cyaml_strval_t port_type_strings[] = {
  {"unknown",  TYPE_UNKNOWN},
  { "control", TYPE_CONTROL},
  { "audio",   TYPE_AUDIO  },
  { "event",   TYPE_EVENT  },
  { "cv",      TYPE_CV     },
};
 
typedef enum PortUnit
{
  PORT_UNIT_NONE,
  PORT_UNIT_HZ,
  PORT_UNIT_MHZ,
  PORT_UNIT_DB,
  PORT_UNIT_DEGREES,
  PORT_UNIT_SECONDS,
 
  PORT_UNIT_MS,
 
  PORT_UNIT_US,
} PortUnit;
 
static const cyaml_strval_t port_unit_strings[] = {
  {"none", PORT_UNIT_NONE   },
  { "Hz",  PORT_UNIT_HZ     },
  { "MHz", PORT_UNIT_MHZ    },
  { "dB",  PORT_UNIT_DB     },
  { "°",  PORT_UNIT_DEGREES},
  { "s",   PORT_UNIT_SECONDS},
  { "ms",  PORT_UNIT_MS     },
  { "μs", PORT_UNIT_US     },
};
 
typedef enum PortOwnerType
{
  /* PORT_OWNER_TYPE_NONE, */
  PORT_OWNER_TYPE_AUDIO_ENGINE,
 
  PORT_OWNER_TYPE_PLUGIN,
 
  PORT_OWNER_TYPE_TRACK,
 
  PORT_OWNER_TYPE_CHANNEL,
 
  PORT_OWNER_TYPE_FADER,
 
  PORT_OWNER_TYPE_CHANNEL_SEND,
 
  /* TrackProcessor. */
  PORT_OWNER_TYPE_TRACK_PROCESSOR,
 
  PORT_OWNER_TYPE_HW,
 
  PORT_OWNER_TYPE_TRANSPORT,
 
  PORT_OWNER_TYPE_MODULATOR_MACRO_PROCESSOR,
} PortOwnerType;
 
static const cyaml_strval_t port_owner_type_strings[] = {
  {"audio engine",               PORT_OWNER_TYPE_AUDIO_ENGINE             },
  { "plugin",                    PORT_OWNER_TYPE_PLUGIN                   },
  { "track",                     PORT_OWNER_TYPE_TRACK                    },
  { "channel",                   PORT_OWNER_TYPE_CHANNEL                  },
  { "fader",                     PORT_OWNER_TYPE_FADER                    },
  { "channel send",              PORT_OWNER_TYPE_CHANNEL_SEND             },
  { "track processor",           PORT_OWNER_TYPE_TRACK_PROCESSOR          },
  { "hw",                        PORT_OWNER_TYPE_HW                       },
  { "transport",                 PORT_OWNER_TYPE_TRANSPORT                },
  { "modulator macro processor", PORT_OWNER_TYPE_MODULATOR_MACRO_PROCESSOR},
};
 
typedef enum PortFlags
{
  PORT_FLAG_STEREO_L = 1 << 0,
  PORT_FLAG_STEREO_R = 1 << 1,
  PORT_FLAG_PIANO_ROLL = 1 << 2,
  PORT_FLAG_SIDECHAIN = 1 << 3,
  PORT_FLAG_MAIN_PORT = 1 << 4,
  PORT_FLAG_MANUAL_PRESS = 1 << 5,
 
  PORT_FLAG_AMPLITUDE = 1 << 6,
 
  PORT_FLAG_STEREO_BALANCE = 1 << 7,
 
  PORT_FLAG_WANT_POSITION = 1 << 8,
 
  PORT_FLAG_TRIGGER = 1 << 9,
 
  PORT_FLAG_TOGGLE = 1 << 10,
 
  PORT_FLAG_INTEGER = 1 << 11,
 
  PORT_FLAG_FREEWHEEL = 1 << 12,
 
  PORT_FLAG_REPORTS_LATENCY = 1 << 13,
 
  PORT_FLAG_NOT_ON_GUI = 1 << 14,
 
  PORT_FLAG_PLUGIN_ENABLED = 1 << 15,
 
  PORT_FLAG_PLUGIN_CONTROL = 1 << 16,
 
  PORT_FLAG_FADER_MUTE = 1 << 17,
 
  PORT_FLAG_CHANNEL_FADER = 1 << 18,
 
  PORT_FLAG_AUTOMATABLE = 1 << 19,
 
  PORT_FLAG_MIDI_AUTOMATABLE = 1 << 20,
 
  PORT_FLAG_SEND_RECEIVABLE = 1 << 21,
 
  PORT_FLAG_BPM = 1 << 22,
 
  PORT_FLAG_GENERIC_PLUGIN_PORT = 1 << 23,
 
  PORT_FLAG_PLUGIN_GAIN = 1 << 24,
 
  PORT_FLAG_TP_MONO = 1 << 25,
 
  PORT_FLAG_TP_INPUT_GAIN = 1 << 26,
 
  PORT_FLAG_HW = 1 << 27,
 
  PORT_FLAG_MODULATOR_MACRO = 1 << 28,
 
  PORT_FLAG_LOGARITHMIC = 1 << 29,
 
  PORT_FLAG_IS_PROPERTY = 1 << 30,
} PortFlags;
 
static const cyaml_bitdef_t port_flags_bitvals[] = {
  {.name = "stereo_l",             .offset = 0,  .bits = 1},
  { .name = "stereo_r",            .offset = 1,  .bits = 1},
  { .name = "piano_roll",          .offset = 2,  .bits = 1},
  { .name = "sidechain",           .offset = 3,  .bits = 1},
  { .name = "main_port",           .offset = 4,  .bits = 1},
  { .name = "manual_press",        .offset = 5,  .bits = 1},
  { .name = "amplitude",           .offset = 6,  .bits = 1},
  { .name = "stereo_balance",      .offset = 7,  .bits = 1},
  { .name = "want_position",       .offset = 8,  .bits = 1},
  { .name = "trigger",             .offset = 9,  .bits = 1},
  { .name = "toggle",              .offset = 10, .bits = 1},
  { .name = "integer",             .offset = 11, .bits = 1},
  { .name = "freewheel",           .offset = 12, .bits = 1},
  { .name = "reports_latency",     .offset = 13, .bits = 1},
  { .name = "not_on_gui",          .offset = 14, .bits = 1},
  { .name = "plugin_enabled",      .offset = 15, .bits = 1},
  { .name = "plugin_control",      .offset = 16, .bits = 1},
  { .name = "fader_mute",          .offset = 17, .bits = 1},
  { .name = "channel_fader",       .offset = 18, .bits = 1},
  { .name = "automatable",         .offset = 19, .bits = 1},
  { .name = "midi_automatable",    .offset = 20, .bits = 1},
  { .name = "send_receivable",     .offset = 21, .bits = 1},
  { .name = "bpm",                 .offset = 22, .bits = 1},
  { .name = "generic_plugin_port", .offset = 23, .bits = 1},
  { .name = "plugin_gain",         .offset = 24, .bits = 1},
  { .name = "tp_mono",             .offset = 25, .bits = 1},
  { .name = "tp_input_gain",       .offset = 26, .bits = 1},
  { .name = "hw",                  .offset = 27, .bits = 1},
  { .name = "modulator_macro",     .offset = 28, .bits = 1},
  { .name = "logarithmic",         .offset = 29, .bits = 1},
  { .name = "is_property",         .offset = 30, .bits = 1},
};
 
typedef enum PortFlags2
{
  PORT_FLAG2_TRANSPORT_ROLL = 1 << 0,
  PORT_FLAG2_TRANSPORT_STOP = 1 << 1,
  PORT_FLAG2_TRANSPORT_BACKWARD = 1 << 2,
  PORT_FLAG2_TRANSPORT_FORWARD = 1 << 3,
  PORT_FLAG2_TRANSPORT_LOOP_TOGGLE = 1 << 4,
  PORT_FLAG2_TRANSPORT_REC_TOGGLE = 1 << 5,
 
  PORT_FLAG2_SUPPORTS_PATCH_MESSAGE = 1 << 6,
 
  PORT_FLAG2_ENUMERATION = 1 << 7,
 
  PORT_FLAG2_URI_PARAM = 1 << 8,
 
  PORT_FLAG2_SEQUENCE = 1 << 9,
 
  PORT_FLAG2_SUPPORTS_MIDI = 1 << 10,
 
  PORT_FLAG2_TP_OUTPUT_GAIN = 1 << 11,
 
  PORT_FLAG2_MIDI_PITCH_BEND = 1 << 12,
 
  PORT_FLAG2_MIDI_POLY_KEY_PRESSURE = 1 << 13,
 
  PORT_FLAG2_MIDI_CHANNEL_PRESSURE = 1 << 14,
 
  PORT_FLAG2_CHANNEL_SEND_ENABLED = 1 << 15,
 
  PORT_FLAG2_CHANNEL_SEND_AMOUNT = 1 << 16,
 
  PORT_FLAG2_BEATS_PER_BAR = 1 << 17,
 
  PORT_FLAG2_BEAT_UNIT = 1 << 18,
 
  PORT_FLAG2_FADER_SOLO = 1 << 19,
 
  PORT_FLAG2_FADER_LISTEN = 1 << 20,
 
  PORT_FLAG2_FADER_MONO_COMPAT = 1 << 21,
 
  PORT_FLAG2_TRACK_RECORDING = 1 << 22,
 
  PORT_FLAG2_TP_MONITOR_AUDIO = 1 << 23,
 
  PORT_FLAG2_PREFADER = 1 << 24,
 
  PORT_FLAG2_POSTFADER = 1 << 25,
 
  PORT_FLAG2_MONITOR_FADER = 1 << 26,
 
  PORT_FLAG2_SAMPLE_PROCESSOR_FADER = 1 << 27,
 
  PORT_FLAG2_SAMPLE_PROCESSOR_TRACK = 1 << 28,
 
  PORT_FLAG2_FADER_SWAP_PHASE = 1 << 29,
 
  PORT_FLAG2_MIDI_CLOCK = 1 << 30,
} PortFlags2;
 
static const cyaml_bitdef_t port_flags2_bitvals[] = {
  YAML_BITVAL ("transport_roll", 0),
  YAML_BITVAL ("transport_stop", 1),
  YAML_BITVAL ("transport_backward", 2),
  YAML_BITVAL ("transport_forward", 3),
  YAML_BITVAL ("transport_loop_toggle", 4),
  YAML_BITVAL ("transport_rec_toggle", 5),
  YAML_BITVAL ("patch_message", 6),
  YAML_BITVAL ("enumeration", 7),
  YAML_BITVAL ("uri_param", 8),
  YAML_BITVAL ("sequence", 9),
  YAML_BITVAL ("supports_midi", 10),
  YAML_BITVAL ("output_gain", 11),
  YAML_BITVAL ("pitch_bend", 12),
  YAML_BITVAL ("poly_key_pressure", 13),
  YAML_BITVAL ("channel_pressure", 14),
  YAML_BITVAL ("ch_send_enabled", 15),
  YAML_BITVAL ("ch_send_amount", 16),
  YAML_BITVAL ("beats_per_bar", 17),
  YAML_BITVAL ("beat_unit", 18),
  YAML_BITVAL ("fader_solo", 19),
  YAML_BITVAL ("fader_listen", 20),
  YAML_BITVAL ("fader_mono_compat", 21),
  YAML_BITVAL ("track_recording", 22),
  YAML_BITVAL ("tp_monitor_audio", 23),
  YAML_BITVAL ("prefader", 24),
  YAML_BITVAL ("postfader", 25),
  YAML_BITVAL ("monitor_fader", 26),
  YAML_BITVAL ("sample_processor_fader", 27),
  YAML_BITVAL ("sample_processor_track", 28),
  YAML_BITVAL ("fader_swap_phase", 29),
  YAML_BITVAL ("midi_clock", 30),
};
 
typedef struct PortIdentifier
{
  int schema_version;
 
  char * label;
 
  char * sym;
 
  char * uri;
 
  char * comment;
 
  PortOwnerType owner_type;
  PortType type;
  PortFlow flow;
  PortFlags  flags;
  PortFlags2 flags2;
 
  PortUnit unit;
 
  PluginIdentifier plugin_id;
 
  char * port_group;
 
  char * ext_port_id;
 
  unsigned int track_name_hash;
 
  int port_index;
} PortIdentifier;
 
static const cyaml_schema_field_t port_identifier_fields_schema[] = {
  YAML_FIELD_INT (PortIdentifier, schema_version),
  YAML_FIELD_STRING_PTR_OPTIONAL (PortIdentifier, label),
  YAML_FIELD_STRING_PTR_OPTIONAL (PortIdentifier, sym),
  YAML_FIELD_STRING_PTR_OPTIONAL (PortIdentifier, uri),
  YAML_FIELD_STRING_PTR_OPTIONAL (PortIdentifier, comment),
  YAML_FIELD_ENUM (PortIdentifier, owner_type, port_owner_type_strings),
  YAML_FIELD_ENUM (PortIdentifier, type, port_type_strings),
  YAML_FIELD_ENUM (PortIdentifier, flow, port_flow_strings),
  YAML_FIELD_ENUM (PortIdentifier, unit, port_unit_strings),
  YAML_FIELD_BITFIELD (PortIdentifier, flags, port_flags_bitvals),
  YAML_FIELD_BITFIELD (PortIdentifier, flags2, port_flags2_bitvals),
  YAML_FIELD_UINT (PortIdentifier, track_name_hash),
  YAML_FIELD_MAPPING_EMBEDDED (
    PortIdentifier,
    plugin_id,
    plugin_identifier_fields_schema),
  YAML_FIELD_STRING_PTR_OPTIONAL (PortIdentifier, port_group),
  YAML_FIELD_STRING_PTR_OPTIONAL (PortIdentifier, ext_port_id),
  YAML_FIELD_INT (PortIdentifier, port_index),
 
  CYAML_FIELD_END,
};
 
static const cyaml_schema_value_t port_identifier_schema = {
  YAML_VALUE_PTR (PortIdentifier, port_identifier_fields_schema),
};
 
static const cyaml_schema_value_t port_identifier_schema_default = {
  YAML_VALUE_DEFAULT (PortIdentifier, port_identifier_fields_schema),
};
 
void
port_identifier_init (PortIdentifier * self);
 
static inline const char *
port_identifier_get_label (PortIdentifier * self)
{
  return self->label;
}
 
int
port_identifier_port_group_cmp (const void * p1, const void * p2);
 
static inline int
port_identifier_get_midi_channel (const PortIdentifier * self)
{
  if (
    self->flags2 & PORT_FLAG2_MIDI_PITCH_BEND
    || self->flags2 & PORT_FLAG2_MIDI_POLY_KEY_PRESSURE
    || self->flags2 & PORT_FLAG2_MIDI_CHANNEL_PRESSURE)
    {
      return self->port_index + 1;
    }
  else if (self->flags & PORT_FLAG_MIDI_AUTOMATABLE)
    {
      return self->port_index / 128 + 1;
    }
  return -1;
}
 
NONNULL void
port_identifier_copy (PortIdentifier * dest, const PortIdentifier * src);
 
WARN_UNUSED_RESULT NONNULL bool
port_identifier_is_equal (
  const PortIdentifier * src,
  const PortIdentifier * dest);
 
int
port_identifier_is_equal_func (const void * a, const void * b);
 
NONNULL void
port_identifier_print_to_str (
  const PortIdentifier * self,
  char *                 buf,
  size_t                 buf_sz);
 
NONNULL void
port_identifier_print (const PortIdentifier * self);
 
NONNULL bool
port_identifier_validate (PortIdentifier * self);
 
NONNULL uint32_t
port_identifier_get_hash (const void * self);
 
NONNULL PortIdentifier *
port_identifier_clone (const PortIdentifier * src);
 
NONNULL void
port_identifier_free_members (PortIdentifier * self);
 
NONNULL void
port_identifier_free (PortIdentifier * self);
 
void
port_identifier_free_func (void * self);
 
#endif