track.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: © 2018-2022 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#ifndef __AUDIO_TRACK_H__
#define __AUDIO_TRACK_H__
 
#include "dsp/automation_tracklist.h"
#include "dsp/channel.h"
#include "dsp/chord_object.h"
#include "dsp/marker.h"
#include "dsp/modulator_macro_processor.h"
#include "dsp/region.h"
#include "dsp/scale.h"
#include "dsp/scale_object.h"
#include "dsp/track_lane.h"
#include "dsp/track_processor.h"
#include "plugins/plugin.h"
#include "utils/yaml.h"
 
#include <glib/gi18n.h>
 
typedef struct AutomationTracklist  AutomationTracklist;
typedef struct Region               Region;
typedef struct Position             Position;
typedef struct _TrackWidget         TrackWidget;
typedef struct _FolderChannelWidget FolderChannelWidget;
typedef struct Channel              Channel;
typedef struct MidiEvents           MidiEvents;
typedef struct AutomationTrack      AutomationTrack;
typedef struct Automatable          Automatable;
typedef struct AutomationPoint      AutomationPoint;
typedef struct ChordObject          ChordObject;
typedef struct MusicalScale         MusicalScale;
typedef struct Modulator            Modulator;
typedef struct Marker               Marker;
typedef struct PluginDescriptor     PluginDescriptor;
typedef struct Tracklist            Tracklist;
typedef struct SupportedFile        SupportedFile;
typedef struct TracklistSelections  TracklistSelections;
enum class PassthroughProcessorType;
enum class FaderType;
typedef void                                  MIDI_FILE;
typedef struct _WrappedObjectWithChangeSignal WrappedObjectWithChangeSignal;
 
TYPEDEF_STRUCT_UNDERSCORED (FileImportInfo);
 
#define TRACK_MIN_HEIGHT 24
#define TRACK_DEF_HEIGHT 48
 
#define TRACK_MAGIC 21890135
#define IS_TRACK(x) (((Track *) x)->magic == TRACK_MAGIC)
#define IS_TRACK_AND_NONNULL(x) (x && IS_TRACK (x))
 
#define TRACK_MAX_MODULATOR_MACROS 128
 
#define TRACK_DND_PREFIX Z_DND_STRING_PREFIX "Track::"
 
#define track_is_in_active_project(self) \
  (self->tracklist && tracklist_is_in_active_project (self->tracklist))
 
#define track_is_auditioner(self) \
  (self->tracklist && tracklist_is_auditioner (self->tracklist))
 
enum class TrackType
{
  TRACK_TYPE_INSTRUMENT,
 
  TRACK_TYPE_AUDIO,
 
  TRACK_TYPE_MASTER,
 
  TRACK_TYPE_CHORD,
 
  TRACK_TYPE_MARKER,
 
  TRACK_TYPE_TEMPO,
 
  TRACK_TYPE_MODULATOR,
 
  TRACK_TYPE_AUDIO_BUS,
 
  TRACK_TYPE_AUDIO_GROUP,
 
  TRACK_TYPE_MIDI,
 
  TRACK_TYPE_MIDI_BUS,
 
  TRACK_TYPE_MIDI_GROUP,
 
  TRACK_TYPE_FOLDER,
};
 
static const char * track_type_strings[] = {
  N_ ("Instrument"),  N_ ("Audio"), N_ ("Master"),    N_ ("Chord"),
  N_ ("Marker"),      N_ ("Tempo"), N_ ("Modulator"), N_ ("Audio FX"),
  N_ ("Audio Group"), N_ ("MIDI"),  N_ ("MIDI FX"),   N_ ("MIDI Group"),
  N_ ("Folder"),
};
 
typedef struct Track
{
  int pos;
 
  TrackType type;
 
  char * name;
 
  unsigned int name_hash;
 
  char * icon_name;
 
  TrackWidget * widget;
 
  FolderChannelWidget * folder_ch_widget;
 
  bool automation_visible;
 
  bool lanes_visible;
 
  bool visible;
 
  bool filtered;
 
  double main_height;
 
  Port * recording;
 
  bool record_set_automatically;
 
  bool enabled;
 
  GdkRGBA color;
 
  /* ==== INSTRUMENT/MIDI/AUDIO TRACK ==== */
 
  TrackLane ** lanes;
  int          num_lanes;
  size_t       lanes_size;
 
  TrackLane ** lane_snapshots;
  int          num_lane_snapshots;
 
  uint8_t midi_ch;
 
  bool drum_mode;
 
  int passthrough_midi_input;
 
  Region * recording_region;
 
  bool recording_start_sent;
 
  bool recording_stop_sent;
 
  bool recording_paused;
 
  int last_lane_idx;
 
  /* ==== INSTRUMENT/MIDI/AUDIO TRACK END ==== */
 
  /* ==== AUDIO TRACK ==== */
 
  Stretcher * rt_stretcher;
 
  /* ==== AUDIO TRACK END ==== */
 
  /* ==== CHORD TRACK ==== */
 
  Region ** chord_regions;
  int       num_chord_regions;
  size_t    chord_regions_size;
 
  Region ** chord_region_snapshots;
  int       num_chord_region_snapshots;
 
  ScaleObject ** scales;
  int            num_scales;
  size_t         scales_size;
 
  ScaleObject ** scale_snapshots;
  int            num_scale_snapshots;
 
  /* ==== CHORD TRACK END ==== */
 
  /* ==== MARKER TRACK ==== */
 
  Marker ** markers;
  int       num_markers;
  size_t    markers_size;
 
  Marker ** marker_snapshots;
  int       num_marker_snapshots;
 
  /* ==== MARKER TRACK END ==== */
 
  /* ==== TEMPO TRACK ==== */
 
  Port * bpm_port;
 
  Port * beats_per_bar_port;
 
  Port * beat_unit_port;
 
  /* ==== TEMPO TRACK END ==== */
 
  /* ==== FOLDABLE TRACK ==== */
 
  int size;
 
  bool folded;
 
  /* ==== FOLDABLE TRACK END ==== */
 
  /* ==== MODULATOR TRACK ==== */
 
  Plugin ** modulators;
  int       num_modulators;
  size_t    modulators_size;
 
  ModulatorMacroProcessor * modulator_macros[TRACK_MAX_MODULATOR_MACROS];
  int                       num_modulator_macros;
  int                       num_visible_modulator_macros;
 
  /* ==== MODULATOR TRACK END ==== */
 
  /* ==== CHANNEL TRACK ==== */
 
  Channel * channel;
 
  /* ==== CHANNEL TRACK END ==== */
 
  TrackProcessor * processor;
 
  AutomationTracklist automation_tracklist;
 
  bool trigger_midi_activity;
 
  ZPortType in_signal_type;
 
  ZPortType out_signal_type;
 
  char * comment;
 
  bool bounce;
 
  bool bounce_to_master;
 
  unsigned int * children;
  int            num_children;
  size_t         children_size;
 
  bool frozen;
 
  int pool_id;
 
  int magic;
 
  bool disconnecting;
 
  Tracklist * tracklist;
 
  TracklistSelections * ts;
 
  int last_lane_created;
 
  bool block_auto_creation_and_deletion;
 
  WrappedObjectWithChangeSignal * gobj;
} Track;
 
COLD NONNULL_ARGS (1) void track_init_loaded (
  Track *               self,
  Tracklist *           tracklist,
  TracklistSelections * ts);
 
void
track_init (Track * self, const int add_lane);
 
Track *
track_new (TrackType type, int pos, const char * label, const int with_lane);
 
NONNULL_ARGS (1) Track * track_clone (Track * track, GError ** error);
 
bool
track_type_has_channel (TrackType type);
 
static inline bool
track_type_can_have_direct_out (TrackType type)
{
  return type != TrackType::TRACK_TYPE_MASTER;
}
 
static inline bool
track_type_can_have_region_type (TrackType type, RegionType region_type)
{
  switch (region_type)
    {
    case RegionType::REGION_TYPE_AUDIO:
      return type == TrackType::TRACK_TYPE_AUDIO;
    case RegionType::REGION_TYPE_MIDI:
      return type == TrackType::TRACK_TYPE_MIDI
             || type == TrackType::TRACK_TYPE_INSTRUMENT;
    case RegionType::REGION_TYPE_CHORD:
      return type == TrackType::TRACK_TYPE_CHORD;
    case RegionType::REGION_TYPE_AUTOMATION:
      return true;
    }
 
  g_return_val_if_reached (false);
}
 
static inline bool
track_type_is_foldable (TrackType type)
{
  return type == TrackType::TRACK_TYPE_FOLDER
         || type == TrackType::TRACK_TYPE_MIDI_GROUP
         || type == TrackType::TRACK_TYPE_AUDIO_GROUP;
}
 
static inline bool
track_type_is_copyable (TrackType type)
{
  return type != TrackType::TRACK_TYPE_MASTER && type != TrackType::TRACK_TYPE_TEMPO
         && type != TrackType::TRACK_TYPE_CHORD
         && type != TrackType::TRACK_TYPE_MODULATOR
         && type != TrackType::TRACK_TYPE_MARKER;
}
 
NONNULL void
track_set_magic (Track * self);
 
#define track_get_name_hash(self) g_str_hash (self->name)
 
NONNULL void
track_set_muted (
  Track * track,
  bool    mute,
  bool    trigger_undo,
  bool    auto_select,
  bool    fire_events);
 
NONNULL void
track_set_folded (
  Track * self,
  bool    folded,
  bool    trigger_undo,
  bool    auto_select,
  bool    fire_events);
 
NONNULL TrackType
track_get_type_from_plugin_descriptor (PluginDescriptor * descr);
 
NONNULL bool
track_type_is_deletable (TrackType type);
 
NONNULL Tracklist *
track_get_tracklist (Track * self);
 
NONNULL bool
track_get_should_be_visible (const Track * self);
 
NONNULL double
track_get_full_visible_height (Track * const self);
 
bool
track_multiply_heights (
  Track * self,
  double  multiplier,
  bool    visible_only,
  bool    check_only);
 
HOT NONNULL bool
track_get_soloed (Track * self);
 
NONNULL bool
track_get_implied_soloed (Track * self);
 
NONNULL bool
track_get_muted (Track * self);
 
NONNULL bool
track_get_listened (Track * self);
 
NONNULL bool
track_get_monitor_audio (Track * self);
 
NONNULL void
track_set_monitor_audio (
  Track * self,
  bool    monitor,
  bool    auto_select,
  bool    fire_events);
 
NONNULL void
track_set_listened (
  Track * self,
  bool    listen,
  bool    trigger_undo,
  bool    auto_select,
  bool    fire_events);
 
HOT NONNULL bool
track_get_recording (const Track * const track);
 
NONNULL void
track_set_recording (Track * track, bool recording, bool fire_events);
 
NONNULL void
track_set_soloed (
  Track * self,
  bool    solo,
  bool    trigger_undo,
  bool    auto_select,
  bool    fire_events);
 
NONNULL bool
track_has_soloed_lanes (const Track * const self);
 
NONNULL int
track_is_selected (Track * self);
 
#define track_is_pinned(x) (x->pos < TRACKLIST->pinned_tracks_cutoff)
 
#define track_add_region( \
  self, region, at, lane_pos, gen_name, fire_events, error) \
  track_insert_region ( \
    self, region, at, lane_pos, -1, gen_name, fire_events, error)
 
bool
track_insert_region (
  Track *           track,
  Region *          region,
  AutomationTrack * at,
  int               lane_pos,
  int               idx,
  int               gen_name,
  int               fire_events,
  GError **         error);
 
NONNULL_ARGS (1, 2)
void track_write_to_midi_file (
  const Track *    self,
  MIDI_FILE *      mf,
  MidiEvents *     events,
  const Position * start,
  const Position * end,
  bool             lanes_as_tracks,
  bool             use_track_pos);
 
NONNULL void
track_select (Track * self, bool select, bool exclusive, bool fire_events);
 
NONNULL void
track_unselect_all (Track * self);
 
NONNULL bool
track_contains_uninstantiated_plugin (const Track * const self);
 
NONNULL void
track_clear (Track * self);
 
NONNULL void
track_remove_region (Track * self, Region * region, bool fire_events, bool free);
 
void
track_fill_events (
  const Track *                       self,
  const EngineProcessTimeInfo * const time_nfo,
  MidiEvents *                        midi_events,
  StereoPorts *                       stereo_ports);
 
bool
track_validate (Track * self);
 
void
track_add_folder_parents (const Track * self, GPtrArray * parents, bool prepend);
 
Track *
track_get_direct_folder_parent (Track * track);
 
void
track_remove_from_folder_parents (Track * self);
 
Region *
track_get_region_at_pos (
  const Track *    track,
  const Position * pos,
  bool             include_region_end);
 
Region *
track_get_last_region (Track * track);
 
void
track_set_lanes_visible (Track * track, const int visible);
 
void
track_set_automation_visible (Track * track, const bool visible);
 
int
track_type_can_host_region_type (const TrackType tt, const RegionType rt);
 
static inline bool
track_type_has_mono_compat_switch (const TrackType tt)
{
  return tt == TrackType::TRACK_TYPE_AUDIO_GROUP
         || tt == TrackType::TRACK_TYPE_MASTER;
}
 
#define track_type_is_audio_group track_type_has_mono_compat_switch
 
static inline bool
track_type_is_fx (const TrackType type)
{
  return type == TrackType::TRACK_TYPE_AUDIO_BUS
         || type == TrackType::TRACK_TYPE_MIDI_BUS;
}
 
static inline int
track_type_can_record (const TrackType type)
{
  return type == TrackType::TRACK_TYPE_AUDIO || type == TrackType::TRACK_TYPE_MIDI
         || type == TrackType::TRACK_TYPE_CHORD
         || type == TrackType::TRACK_TYPE_INSTRUMENT;
}
 
void
track_generate_automation_tracks (Track * track);
 
void
track_setup (Track * track);
 
static inline AutomationTracklist *
track_get_automation_tracklist (Track * const track)
{
  g_return_val_if_fail (IS_TRACK (track), NULL);
 
  switch (track->type)
    {
    case TrackType::TRACK_TYPE_MARKER:
    case TrackType::TRACK_TYPE_FOLDER:
      break;
    case TrackType::TRACK_TYPE_CHORD:
    case TrackType::TRACK_TYPE_AUDIO_BUS:
    case TrackType::TRACK_TYPE_AUDIO_GROUP:
    case TrackType::TRACK_TYPE_MIDI_BUS:
    case TrackType::TRACK_TYPE_MIDI_GROUP:
    case TrackType::TRACK_TYPE_INSTRUMENT:
    case TrackType::TRACK_TYPE_AUDIO:
    case TrackType::TRACK_TYPE_MASTER:
    case TrackType::TRACK_TYPE_MIDI:
    case TrackType::TRACK_TYPE_TEMPO:
    case TrackType::TRACK_TYPE_MODULATOR:
      return &track->automation_tracklist;
    default:
      g_warn_if_reached ();
      break;
    }
 
  return NULL;
}
 
NONNULL static inline Channel *
track_get_channel (const Track * const track)
{
  switch (track->type)
    {
    case TrackType::TRACK_TYPE_MASTER:
    case TrackType::TRACK_TYPE_INSTRUMENT:
    case TrackType::TRACK_TYPE_AUDIO:
    case TrackType::TRACK_TYPE_AUDIO_BUS:
    case TrackType::TRACK_TYPE_AUDIO_GROUP:
    case TrackType::TRACK_TYPE_MIDI_BUS:
    case TrackType::TRACK_TYPE_MIDI_GROUP:
    case TrackType::TRACK_TYPE_MIDI:
    case TrackType::TRACK_TYPE_CHORD:
      return track->channel;
    default:
      return NULL;
    }
}
 
void
track_update_children (Track * self);
 
CONST
static inline bool
track_type_has_piano_roll (const TrackType type)
{
  return type == TrackType::TRACK_TYPE_MIDI
         || type == TrackType::TRACK_TYPE_INSTRUMENT;
}
 
static inline int
track_has_inputs (const Track * track)
{
  return track->type == TrackType::TRACK_TYPE_MIDI
         || track->type == TrackType::TRACK_TYPE_INSTRUMENT
         || track->type == TrackType::TRACK_TYPE_AUDIO;
}
 
Track *
track_find_by_name (const char * name);
 
void
track_get_velocities_in_range (
  const Track *    track,
  const Position * start_pos,
  const Position * end_pos,
  Velocity ***     velocities,
  int *            num_velocities,
  size_t *         velocities_size,
  int              inside);
 
const char *
track_get_name (Track * track);
 
NONNULL bool
track_set_name_with_action_full (Track * track, const char * name);
 
void
track_set_name_with_action (Track * track, const char * name);
 
void
track_set_name (Track * self, const char * name, bool pub_events);
 
char *
track_get_unique_name (Track * track_to_skip, const char * name);
 
Track *
track_get_from_name (const char * name);
 
const char *
track_stringize_type (TrackType type);
 
static inline int
track_type_is_compatible_for_moving (const TrackType type1, const TrackType type2)
{
  return type1 == type2
         || (type1 == TrackType::TRACK_TYPE_MIDI && type2 == TrackType::TRACK_TYPE_INSTRUMENT)
         || (type1 == TrackType::TRACK_TYPE_INSTRUMENT && type2 == TrackType::TRACK_TYPE_MIDI);
}
 
void
track_update_positions (Track * self, bool from_ticks, bool bpm_change);
 
Fader *
track_get_fader (Track * track, bool post_fader);
 
FaderType
track_get_fader_type (const Track * track);
 
FaderType
track_type_get_prefader_type (TrackType type);
 
bool
track_create_missing_lanes (Track * self, const int pos);
 
void
track_remove_empty_last_lanes (Track * self);
 
int
track_get_regions_in_range (
  Track *    self,
  Position * p1,
  Position * p2,
  Region **  regions);
 
int
track_get_plugins (const Track * const self, GPtrArray * arr);
 
void
track_activate_all_plugins (Track * track, bool activate);
 
void
track_comment_setter (void * track, const char * comment);
 
void
track_set_comment (Track * self, const char * comment, bool undoable);
 
const char *
track_get_comment (void * track);
 
void
track_set_color (
  Track *         self,
  const GdkRGBA * color,
  bool            undoable,
  bool            fire_events);
 
void
track_set_icon (
  Track *      self,
  const char * icon_name,
  bool         undoable,
  bool         fire_events);
 
Plugin *
track_get_plugin_at_slot (Track * track, ZPluginSlotType slot_type, int slot);
 
void
track_mark_for_bounce (
  Track * self,
  bool    bounce,
  bool    mark_regions,
  bool    mark_children,
  bool    mark_parents);
 
void
track_append_ports (Track * self, GPtrArray * ports, bool include_plugins);
 
bool
track_freeze (Track * self, bool freeze, GError ** error);
 
void
track_insert_plugin (
  Track *         self,
  Plugin *        pl,
  ZPluginSlotType slot_type,
  int             slot,
  bool            instantiate_plugin,
  bool            replacing_plugin,
  bool            moving_plugin,
  bool            confirm,
  bool            gen_automatables,
  bool            recalc_graph,
  bool            fire_events);
 
void
track_remove_plugin (
  Track *         self,
  ZPluginSlotType slot_type,
  int             slot,
  bool            replacing_plugin,
  bool            moving_plugin,
  bool            deleting_plugin,
  bool            deleting_track,
  bool            recalc_graph);
 
void
track_disconnect (Track * self, bool remove_pl, bool recalc_graph);
 
NONNULL bool
track_is_enabled (Track * self);
 
NONNULL void
track_set_enabled (
  Track * self,
  bool    enabled,
  bool    trigger_undo,
  bool    auto_select,
  bool    fire_events);
 
static inline const char *
track_type_to_string (TrackType type)
{
  return track_type_strings[static_cast<int> (type)];
}
 
TrackType
track_type_get_from_string (const char * str);
 
void
track_get_total_bars (Track * self, int * total_bars);
 
void
track_set_caches (Track * self, CacheTypes types);
 
typedef void (*TracksReadyCallback) (const FileImportInfo *, const GError *);
 
bool
track_create_with_action (
  TrackType             type,
  const PluginSetting * pl_setting,
  const SupportedFile * file_descr,
  const Position *      pos,
  int                   index,
  int                   num_tracks,
  int                   disable_track_idx,
  TracksReadyCallback   ready_cb,
  GError **             error);
 
Track *
track_create_empty_at_idx_with_action (TrackType type, int index, GError ** error);
 
Track *
track_create_for_plugin_at_idx_w_action (
  TrackType             type,
  const PluginSetting * pl_setting,
  int                   index,
  GError **             error);
 
#define track_create_empty_with_action(type, error) \
  track_create_empty_at_idx_with_action (type, TRACKLIST->num_tracks, error)
 
GMenu *
track_generate_edit_context_menu (Track * track, int num_selected);
 
GMenu *
track_generate_channel_context_menu (Track * track);
 
void
track_free (Track * track);
 
#endif // __AUDIO_TRACK_H__