channel_send.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: © 2020-2021 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#ifndef __AUDIO_CHANNEL_SEND_H__
#define __AUDIO_CHANNEL_SEND_H__
 
#include <stdbool.h>
 
#include "dsp/port.h"
#include "dsp/port_identifier.h"
#include "utils/yaml.h"
 
typedef struct StereoPorts            StereoPorts;
typedef struct Track                  Track;
typedef struct Port                   Port;
typedef struct _ChannelSendWidget     ChannelSendWidget;
typedef struct PortConnectionsManager PortConnectionsManager;
 
#define CHANNEL_SEND_SCHEMA_VERSION 1
 
#define CHANNEL_SEND_POST_FADER_START_SLOT 6
 
#define channel_send_is_prefader(x) \
  (x->slot < CHANNEL_SEND_POST_FADER_START_SLOT)
 
#define channel_send_is_in_active_project(self) \
  (self->track && track_is_in_active_project (self->track))
 
typedef enum ChannelSendTargetType
{
  CHANNEL_SEND_TARGET_TYPE_NONE,
 
  CHANNEL_SEND_TARGET_TYPE_TRACK,
 
  CHANNEL_SEND_TARGET_TYPE_PLUGIN_SIDECHAIN,
} ChannelSendTargetType;
 
typedef struct ChannelSendTarget
{
  ChannelSendTargetType type;
 
  int track_pos;
 
  PluginIdentifier pl_id;
 
  char * port_group;
} ChannelSendTarget;
 
char *
channel_send_target_describe (const ChannelSendTarget * self);
 
char *
channel_send_target_get_icon (const ChannelSendTarget * self);
 
void
channel_send_target_free (ChannelSendTarget * self);
 
typedef struct ChannelSend
{
  int schema_version;
 
  int slot;
 
  StereoPorts * stereo_in;
 
  Port * midi_in;
 
  StereoPorts * stereo_out;
 
  Port * midi_out;
 
  Port * amount;
 
  Port * enabled;
 
  bool is_sidechain;
 
  Track * track;
 
  unsigned int track_name_hash;
 
} ChannelSend;
 
static const cyaml_schema_field_t channel_send_fields_schema[] = {
  YAML_FIELD_INT (ChannelSend, schema_version),
  YAML_FIELD_INT (ChannelSend, slot),
  YAML_FIELD_MAPPING_PTR (ChannelSend, amount, port_fields_schema),
  YAML_FIELD_MAPPING_PTR (ChannelSend, enabled, port_fields_schema),
  YAML_FIELD_INT (ChannelSend, is_sidechain),
  YAML_FIELD_MAPPING_PTR_OPTIONAL (ChannelSend, midi_in, port_fields_schema),
  YAML_FIELD_MAPPING_PTR_OPTIONAL (
    ChannelSend,
    stereo_in,
    stereo_ports_fields_schema),
  YAML_FIELD_MAPPING_PTR_OPTIONAL (ChannelSend, midi_out, port_fields_schema),
  YAML_FIELD_MAPPING_PTR_OPTIONAL (
    ChannelSend,
    stereo_out,
    stereo_ports_fields_schema),
  YAML_FIELD_UINT (ChannelSend, track_name_hash),
 
  CYAML_FIELD_END
};
 
static const cyaml_schema_value_t channel_send_schema = {
  YAML_VALUE_PTR_NULLABLE (ChannelSend, channel_send_fields_schema),
};
 
NONNULL_ARGS (1)
void channel_send_init_loaded (ChannelSend * self, Track * track);
 
ChannelSend *
channel_send_new (unsigned int track_name_hash, int slot, Track * track);
 
NONNULL Track *
channel_send_get_track (const ChannelSend * self);
 
NONNULL bool
channel_send_is_enabled (const ChannelSend * self);
 
#define channel_send_is_empty(x) (!channel_send_is_enabled (x))
 
NONNULL bool
channel_send_is_target_sidechain (ChannelSend * self);
 
Track *
channel_send_get_target_track (ChannelSend * self, Track * owner);
 
NONNULL StereoPorts *
channel_send_get_target_sidechain (ChannelSend * self);
 
NONNULL float
channel_send_get_amount_for_widgets (ChannelSend * self);
 
NONNULL void
channel_send_set_amount_from_widget (ChannelSend * self, float val);
 
bool
channel_send_connect_stereo (
  ChannelSend * self,
  StereoPorts * stereo,
  Port *        l,
  Port *        r,
  bool          sidechain,
  bool          recalc_graph,
  bool          validate,
  GError **     error);
 
NONNULL bool
channel_send_connect_midi (
  ChannelSend * self,
  Port *        port,
  bool          recalc_graph,
  bool          validate,
  GError **     error);
 
NONNULL void
channel_send_disconnect (ChannelSend * self, bool recalc_graph);
 
NONNULL void
channel_send_set_amount (ChannelSend * self, float amount);
 
NONNULL void
channel_send_get_dest_name (ChannelSend * self, char * buf);
 
NONNULL void
channel_send_copy_values (ChannelSend * dest, const ChannelSend * src);
 
NONNULL ChannelSend *
channel_send_clone (const ChannelSend * src);
 
NONNULL ChannelSendWidget *
channel_send_find_widget (ChannelSend * self);
 
void
channel_send_connect_to_owner (ChannelSend * self);
 
void
channel_send_append_ports (ChannelSend * self, GPtrArray * ports);
 
int
channel_send_append_connection (
  const ChannelSend *            self,
  const PortConnectionsManager * mgr,
  GPtrArray *                    arr);
 
void
channel_send_prepare_process (ChannelSend * self);
 
void
channel_send_process (
  ChannelSend *   self,
  const nframes_t local_offset,
  const nframes_t nframes);
 
bool
channel_send_is_connected_to (
  const ChannelSend * self,
  const StereoPorts * stereo,
  const Port *        midi);
 
NONNULL ChannelSend *
channel_send_find (ChannelSend * self);
 
NONNULL bool
channel_send_validate (ChannelSend * self);
 
NONNULL void
channel_send_free (ChannelSend * self);
 
#endif