channel.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: © 2018-2022 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#ifndef __AUDIO_CHANNEL_H__
#define __AUDIO_CHANNEL_H__
 
#include "zrythm-config.h"
 
#include "dsp/channel_send.h"
#include "dsp/ext_port.h"
#include "dsp/fader.h"
#include "plugins/plugin.h"
#include "utils/audio.h"
#include "utils/yaml.h"
 
#include <gdk/gdk.h>
 
typedef struct AutomationTrack AutomationTrack;
typedef struct _ChannelWidget  ChannelWidget;
typedef struct Track           Track;
typedef struct _TrackWidget    TrackWidget;
typedef struct ExtPort         ExtPort;
 
#define CHANNEL_SCHEMA_VERSION 2
 
#define CHANNEL_MAGIC 8431676
#define IS_CHANNEL(x) (((Channel *) x)->magic == CHANNEL_MAGIC)
#define IS_CHANNEL_AND_NONNULL(x) (x && IS_CHANNEL (x))
 
#define FOREACH_STRIP for (int i = 0; i < STRIP_SIZE; i++)
#define FOREACH_AUTOMATABLE(ch) for (int i = 0; i < ch->num_automatables; i++)
#define MAX_FADER_AMP 1.42f
 
#define channel_is_in_active_project(self) \
  (self->track && track_is_in_active_project (self->track))
 
typedef struct Channel
{
  int schema_version;
  Plugin * midi_fx[STRIP_SIZE];
 
  Plugin * inserts[STRIP_SIZE];
 
  Plugin * instrument;
 
  ChannelSend * sends[STRIP_SIZE];
 
  ExtPort * ext_midi_ins[EXT_PORTS_MAX];
  int       num_ext_midi_ins;
 
  bool all_midi_ins;
 
  ExtPort * ext_stereo_l_ins[EXT_PORTS_MAX];
  int       num_ext_stereo_l_ins;
 
  bool all_stereo_l_ins;
 
  ExtPort * ext_stereo_r_ins[EXT_PORTS_MAX];
  int       num_ext_stereo_r_ins;
 
  bool all_stereo_r_ins;
 
  int midi_channels[16];
 
  bool all_midi_channels;
 
  Fader * fader;
 
  Fader * prefader;
 
  Port * midi_out;
 
  /*
   * Ports for direct (track-to-track) routing with the exception of master,
   * which will route the output to monitor in.
   */
  StereoPorts * stereo_out;
 
  int has_output;
 
  unsigned int output_name_hash;
 
  int track_pos;
 
  int width;
 
  int magic;
 
  ChannelWidget * widget;
 
  Track * track;
} Channel;
 
NONNULL void
channel_init_loaded (Channel * channel, Track * track);
 
NONNULL void
channel_handle_recording (
  Channel *       self,
  const long      g_frames_start,
  const nframes_t nframes);
 
void
channel_append_ports (Channel * self, GPtrArray * ports, bool include_plugins);
 
NONNULL void
channel_set_magic (Channel * self);
 
NONNULL void
channel_expose_ports_to_backend (Channel * ch);
 
void
channel_connect (Channel * ch);
 
NONNULL void
channel_set_phase (void * channel, float phase);
 
NONNULL float
channel_get_phase (void * channel);
 
NONNULL void
channel_set_balance_control (void * _channel, float pan);
 
NONNULL void
channel_add_balance_control (void * _channel, float pan);
 
NONNULL float
channel_get_balance_control (void * _channel);
 
NONNULL void
channel_reset_fader (Channel * self, bool fire_events);
 
void
channel_handle_plugin_import (
  Channel *                self,
  const Plugin *           pl,
  const MixerSelections *  sel,
  const PluginDescriptor * descr,
  int                      slot,
  ZPluginSlotType          slot_type,
  bool                     copy,
  bool                     ask_if_overwrite);
 
NONNULL void
channel_prepare_process (Channel * channel);
 
NONNULL Channel *
channel_new (Track * track);
 
NONNULL void
channel_process (Channel * channel);
 
NONNULL bool
channel_add_plugin (
  Channel *       channel,
  ZPluginSlotType slot_type,
  int             pos,
  Plugin *        plugin,
  bool            confirm,
  bool            moving_plugin,
  bool            gen_automatables,
  bool            recalc_graph,
  bool            pub_events);
 
NONNULL Track *
channel_get_track (Channel * self);
 
NONNULL Track *
channel_get_output_track (Channel * self);
 
NONNULL void
channel_reconnect_ext_input_ports (Channel * ch);
 
NONNULL AutomationTrack *
channel_get_automation_track (
  Channel *             channel,
  PortIdentifier::Flags port_flags);
 
NONNULL void
channel_remove_plugin (
  Channel *       channel,
  ZPluginSlotType slot_type,
  int             slot,
  bool            moving_plugin,
  bool            deleting_plugin,
  bool            deleting_channel,
  bool            recalc_graph);
 
NONNULL void
channel_update_track_name_hash (
  Channel *    self,
  unsigned int old_name_hash,
  unsigned int new_name_hash);
 
NONNULL int
channel_get_plugins (Channel * self, Plugin ** pls);
 
NONNULL bool
channel_get_mono_compat_enabled (Channel * self);
 
NONNULL void
channel_set_mono_compat_enabled (Channel * self, bool enabled, bool fire_events);
 
NONNULL bool
channel_get_swap_phase (Channel * self);
 
NONNULL void
channel_set_swap_phase (Channel * self, bool enabled, bool fire_events);
 
Plugin *
channel_get_plugin_at (const Channel * self, int slot, ZPluginSlotType slot_type);
 
void
channel_select_all (Channel * self, ZPluginSlotType type, bool select);
 
NONNULL void
channel_set_caches (Channel * self);
 
NONNULL_ARGS (1, 2)
Channel * channel_clone (Channel * ch, Track * track, GError ** error);
 
NONNULL void
channel_disconnect (Channel * channel, bool remove_pl);
 
NONNULL void
channel_free (Channel * channel);
 
#endif