port.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: © 2018-2023 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#ifndef __AUDIO_PORTS_H__
#define __AUDIO_PORTS_H__
 
#include "zrythm-config.h"
 
#include <stdbool.h>
 
#include "dsp/port_identifier.h"
#include "plugins/lv2/lv2_evbuf.h"
#include "utils/types.h"
 
#include "zix/sem.h"
#include <lilv/lilv.h>
 
#ifdef HAVE_JACK
#  include "weak_libjack.h"
#endif
 
#ifdef HAVE_RTMIDI
#  include <rtmidi_c.h>
#endif
 
#ifdef HAVE_RTAUDIO
#  include <rtaudio_c.h>
#endif
 
typedef struct Plugin           Plugin;
typedef struct MidiEvents       MidiEvents;
typedef struct Fader            Fader;
typedef struct ZixRingImpl      ZixRing;
typedef struct WindowsMmeDevice WindowsMmeDevice;
typedef struct Channel          Channel;
typedef struct AudioEngine      AudioEngine;
typedef struct Track            Track;
typedef struct PortConnection   PortConnection;
typedef struct TrackProcessor   TrackProcessor;
typedef struct ModulatorMacroProcessor ModulatorMacroProcessor;
typedef struct RtMidiDevice          RtMidiDevice;
typedef struct RtAudioDevice         RtAudioDevice;
typedef struct AutomationTrack       AutomationTrack;
typedef struct TruePeakDsp           TruePeakDsp;
typedef struct ExtPort               ExtPort;
typedef struct AudioClip             AudioClip;
typedef struct ChannelSend           ChannelSend;
typedef struct Transport             Transport;
typedef struct PluginGtkController   PluginGtkController;
typedef struct EngineProcessTimeInfo EngineProcessTimeInfo;
typedef enum PanAlgorithm            PanAlgorithm;
typedef enum PanLaw                  PanLaw;
 
#define PORT_SCHEMA_VERSION 1
#define STEREO_PORTS_SCHEMA_VERSION 1
 
#define PORT_MAGIC 456861194
#define IS_PORT(_p) (((Port *) (_p))->magic == PORT_MAGIC)
#define IS_PORT_AND_NONNULL(x) ((x) && IS_PORT (x))
 
#define TIME_TO_RESET_PEAK 4800000
 
#define PORT_NOT_OWNED -1
 
#define port_is_owner_active(self, _owner_type, owner) \
  ((self->id.owner_type == _owner_type) \
   && (self->owner != NULL) \
   && owner##_is_in_active_project (self->owner))
 
#define port_is_in_active_project(self) \
  (port_is_owner_active ( \
     self, PORT_OWNER_TYPE_AUDIO_ENGINE, engine) \
   || port_is_owner_active ( \
     self, PORT_OWNER_TYPE_PLUGIN, plugin) \
   || port_is_owner_active ( \
     self, PORT_OWNER_TYPE_TRACK, track) \
   || port_is_owner_active ( \
     self, PORT_OWNER_TYPE_CHANNEL, track) \
   || port_is_owner_active ( \
     self, PORT_OWNER_TYPE_FADER, fader) \
   || port_is_owner_active ( \
     self, PORT_OWNER_TYPE_CHANNEL_SEND, channel_send) \
   || port_is_owner_active ( \
     self, PORT_OWNER_TYPE_TRACK_PROCESSOR, track) \
   || port_is_owner_active ( \
     self, PORT_OWNER_TYPE_MODULATOR_MACRO_PROCESSOR, \
     modulator_macro_processor) \
   || port_is_owner_active ( \
     self, PORT_OWNER_TYPE_HW, ext_port))
 
typedef enum PortInternalType
{
  INTERNAL_NONE,
 
  INTERNAL_LV2_PORT,
 
  INTERNAL_JACK_PORT,
 
  INTERNAL_PA_PORT,
 
  INTERNAL_ALSA_SEQ_PORT,
} PortInternalType;
 
typedef struct PortScalePoint
{
  float  val;
  char * label;
} PortScalePoint;
 
PURE int
port_scale_point_cmp (const void * _a, const void * _b);
 
NONNULL PortScalePoint *
port_scale_point_new (const float val, const char * label);
 
NONNULL void
port_scale_point_free (PortScalePoint * self);
 
typedef struct Port
{
  int schema_version;
 
  PortIdentifier id;
 
  int exposed_to_backend;
 
  float * buf;
 
  MidiEvents * midi_events;
 
  struct Port ** srcs;
  int            num_srcs;
  size_t         srcs_size;
 
  struct Port ** dests;
  int            num_dests;
  size_t         dests_size;
 
  const PortConnection ** src_connections;
  int                     num_src_connections;
  size_t                  src_connections_size;
 
  const PortConnection ** dest_connections;
  int                     num_dest_connections;
  size_t                  dest_connections_size;
 
  PortInternalType internal_type;
 
  float minf;
  float maxf;
 
  float zerof;
 
  float deff;
 
  int carla_param_id;
 
  void * data;
 
#ifdef _WOE32
  WindowsMmeDevice * mme_connections[40];
  int                num_mme_connections;
#else
  void * mme_connections[40];
  int    num_mme_connections;
#endif
 
  ZixSem mme_connections_sem;
 
  gint64 last_midi_dequeue;
 
#ifdef HAVE_RTMIDI
  RtMidiDevice * rtmidi_ins[128];
  int            num_rtmidi_ins;
 
  RtMidiDevice * rtmidi_outs[128];
  int            num_rtmidi_outs;
#else
  void * rtmidi_ins[128];
  int    num_rtmidi_ins;
  void * rtmidi_outs[128];
  int    num_rtmidi_outs;
#endif
 
#ifdef HAVE_RTAUDIO
  RtAudioDevice * rtaudio_ins[128];
  int             num_rtaudio_ins;
#else
  void * rtaudio_ins[128];
  int    num_rtaudio_ins;
#endif
 
  PortScalePoint ** scale_points;
  int               num_scale_points;
 
  float control;
 
  float unsnapped_control;
 
  bool value_changed_from_reading;
 
  gint64 last_change;
 
  Plugin * plugin;
 
  Transport * transport;
 
  ChannelSend * channel_send;
 
  AudioEngine * engine;
 
  Fader * fader;
 
  Track * track;
 
  ModulatorMacroProcessor * modulator_macro_processor;
 
  /* ====== flags to indicate port owner ====== */
 
  Plugin * tmp_plugin;
 
  int initialized;
 
  float base_value;
 
  long capture_latency;
 
  long playback_latency;
 
  int deleting;
 
  bool write_ring_buffers;
 
  volatile int has_midi_events;
 
  gint64 last_midi_event_time;
 
  ZixRing * audio_ring;
 
  ZixRing * midi_ring;
 
  float peak;
 
  gint64 peak_timestamp;
 
  midi_byte_t last_midi_status;
 
  /* --- ported from Lv2Port --- */
 
  const LilvPort * lilv_port;
 
  LV2_URID value_type;
 
  LV2_Evbuf * evbuf;
 
  PluginGtkController * widget;
 
  size_t min_buf_size;
 
  int lilv_port_index;
 
  bool received_ui_event;
 
  float last_sent_control;
 
  bool automating;
 
  bool old_api;
 
  /* --- end Lv2Port --- */
 
  AutomationTrack * at;
 
  ExtPort * ext_port;
 
  int magic;
 
  size_t last_buf_sz;
} Port;
 
static const cyaml_schema_field_t port_fields_schema[] = {
  YAML_FIELD_INT (Port, schema_version),
  YAML_FIELD_MAPPING_EMBEDDED (
    Port,
    id,
    port_identifier_fields_schema),
  YAML_FIELD_INT (Port, exposed_to_backend),
  YAML_FIELD_FLOAT (Port, control),
  YAML_FIELD_FLOAT (Port, minf),
  YAML_FIELD_FLOAT (Port, maxf),
  YAML_FIELD_FLOAT (Port, zerof),
  YAML_FIELD_FLOAT (Port, deff),
  YAML_FIELD_INT (Port, carla_param_id),
 
  CYAML_FIELD_END
};
 
static const cyaml_schema_value_t port_schema = {
  YAML_VALUE_PTR_NULLABLE (Port, port_fields_schema),
};
 
typedef struct StereoPorts
{
  int    schema_version;
  Port * l;
  Port * r;
} StereoPorts;
 
static const cyaml_schema_field_t stereo_ports_fields_schema[] = {
  YAML_FIELD_INT (StereoPorts, schema_version),
  YAML_FIELD_MAPPING_PTR (StereoPorts, l, port_fields_schema),
  YAML_FIELD_MAPPING_PTR (StereoPorts, r, port_fields_schema),
 
  CYAML_FIELD_END
};
 
static const cyaml_schema_value_t stereo_ports_schema = {
  YAML_VALUE_PTR (StereoPorts, stereo_ports_fields_schema),
};
 
NONNULL void
port_init_loaded (Port * self, void * owner);
 
void
port_set_owner (
  Port *        self,
  PortOwnerType owner_type,
  void *        owner);
 
NONNULL Port *
port_find_from_identifier (const PortIdentifier * const id);
 
NONNULL static inline void
stereo_ports_init_loaded (StereoPorts * sp, void * owner)
{
  port_init_loaded (sp->l, owner);
  port_init_loaded (sp->r, owner);
}
 
NONNULL_ARGS (1)
static inline void stereo_ports_set_owner (
  StereoPorts * sp,
  PortOwnerType owner_type,
  void *        owner)
{
  port_set_owner (sp->l, owner_type, owner);
  port_set_owner (sp->r, owner_type, owner);
}
 
WARN_UNUSED_RESULT NONNULL Port *
port_new_with_type (
  PortType     type,
  PortFlow     flow,
  const char * label);
 
WARN_UNUSED_RESULT NONNULL Port *
port_new_with_type_and_owner (
  PortType      type,
  PortFlow      flow,
  const char *  label,
  PortOwnerType owner_type,
  void *        owner);
 
NONNULL void
port_allocate_bufs (Port * self);
 
NONNULL void
port_free_bufs (Port * self);
 
NONNULL StereoPorts *
stereo_ports_new_from_existing (Port * l, Port * r);
 
StereoPorts *
stereo_ports_new_generic (
  int           in,
  const char *  name,
  const char *  symbol,
  PortOwnerType owner_type,
  void *        owner);
 
NONNULL void
stereo_ports_connect (
  StereoPorts * src,
  StereoPorts * dest,
  int           locked);
 
NONNULL void
stereo_ports_disconnect (StereoPorts * self);
 
StereoPorts *
stereo_ports_clone (const StereoPorts * src);
 
NONNULL void
stereo_ports_free (StereoPorts * self);
 
const void *
port_get_value_from_symbol (
  const char * port_sym,
  void *       user_data,
  uint32_t *   size,
  uint32_t *   type);
 
#ifdef HAVE_JACK
NONNULL void
port_receive_midi_events_from_jack (
  Port *          self,
  const nframes_t start_frames,
  const nframes_t nframes);
 
NONNULL void
port_receive_audio_data_from_jack (
  Port *          self,
  const nframes_t start_frames,
  const nframes_t nframes);
#endif
 
NONNULL bool
port_has_sound (Port * self);
 
NONNULL void
port_get_full_designation (Port * const self, char * buf);
 
NONNULL void
port_print_full_designation (Port * const self);
 
void
port_get_all (GPtrArray * ports);
 
NONNULL Track *
port_get_track (const Port * const self, int warn_if_fail);
 
NONNULL Plugin *
port_get_plugin (Port * const self, const bool warn_if_fail);
 
void
port_update_identifier (
  Port *                 self,
  const PortIdentifier * prev_id,
  Track *                track,
  bool                   update_automation_track);
 
#ifdef HAVE_RTMIDI
NONNULL void
port_prepare_rtmidi_events (Port * self);
 
NONNULL void
port_sum_data_from_rtmidi (
  Port *          self,
  const nframes_t start_frame,
  const nframes_t nframes);
#endif
 
#ifdef HAVE_RTAUDIO
NONNULL void
port_prepare_rtaudio_data (Port * self);
 
NONNULL void
port_sum_data_from_rtaudio (
  Port *          self,
  const nframes_t start_frame,
  const nframes_t nframes);
#endif
 
NONNULL void
port_disconnect_hw_inputs (Port * self);
 
NONNULL void
port_set_expose_to_backend (Port * self, int expose);
 
NONNULL PURE static inline bool
port_is_exposed_to_backend (const Port * self)
{
  return self->internal_type == INTERNAL_JACK_PORT
         || self->internal_type == INTERNAL_ALSA_SEQ_PORT
         || self->id.owner_type == PORT_OWNER_TYPE_AUDIO_ENGINE
         || self->exposed_to_backend;
}
 
NONNULL void
port_rename_backend (Port * self);
 
#ifdef HAVE_ALSA
 
Port *
port_find_by_alsa_seq_id (const int id);
#endif
 
NONNULL void
port_set_control_value (
  Port *      self,
  const float val,
  const bool  is_normalized,
  const bool  forward_event);
 
NONNULL HOT float
port_get_control_value (Port * self, const bool normalize);
 
#define port_connect(a, b, locked) \
  port_connections_manager_ensure_connect ( \
    PORT_CONNECTIONS_MGR, &((a)->id), &((b)->id), 1.f, \
    locked, true)
 
#define port_disconnect(a, b) \
  port_connections_manager_ensure_disconnect ( \
    PORT_CONNECTIONS_MGR, &((a)->id), &((b)->id))
 
NONNULL int
port_get_num_unlocked_srcs (const Port * self);
 
NONNULL int
port_get_num_unlocked_dests (const Port * self);
 
void
port_update_track_name_hash (
  Port *       self,
  Track *      track,
  unsigned int new_hash);
 
NONNULL static inline void
port_apply_fader (
  Port *          port,
  float           amp,
  nframes_t       start_frame,
  const nframes_t nframes)
{
  nframes_t end = start_frame + nframes;
  while (start_frame < end)
    {
      port->buf[start_frame++] *= amp;
    }
}
 
HOT NONNULL void
port_process (
  Port *                      port,
  const EngineProcessTimeInfo time_nfo,
  const bool                  noroll);
 
#define ports_connected(a, b) \
  (port_connections_manager_find_connection ( \
     PORT_CONNECTIONS_MGR, &(a)->id, &(b)->id) \
   != NULL)
 
NONNULL bool
ports_can_be_connected (const Port * src, const Port * dest);
 
NONNULL void
ports_disconnect (Port ** ports, int num_ports, int deleting);
 
NONNULL void
port_copy_metadata_from_project (
  Port * self,
  Port * project_port);
 
NONNULL void
port_copy_values (Port * self, const Port * other);
 
NONNULL void
port_restore_from_non_project (Port * self, Port * non_project);
 
#define port_clear_buffer(_port) \
  { \
    if (_port->id.type == TYPE_AUDIO || _port->id.type == TYPE_CV) \
      { \
        if (_port->buf) \
          { \
            dsp_fill ( \
              _port->buf, DENORMAL_PREVENTION_VAL, \
              AUDIO_ENGINE->block_length); \
          } \
      } \
    else if (_port->id.type == TYPE_EVENT) \
      { \
        if (_port->midi_events) \
          _port->midi_events->num_events = 0; \
      } \
  }
 
HOT NONNULL OPTIMIZE_O3 void
port_clear_external_buffer (Port * port);
 
NONNULL int
port_disconnect_all (Port * port);
 
NONNULL void
port_apply_pan_stereo (
  Port *       l,
  Port *       r,
  float        pan,
  PanLaw       pan_law,
  PanAlgorithm pan_algo);
 
NONNULL void
port_apply_pan (
  Port *          port,
  float           pan,
  PanLaw          pan_law,
  PanAlgorithm    pan_algo,
  nframes_t       start_frame,
  const nframes_t nframes);
 
NONNULL uint32_t
port_get_hash (const void * ptr);
 
Port *
port_clone (const Port * src);
 
NONNULL void
port_free (Port * port);
 
#endif