automation_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_AUTOMATION_TRACK_H__
#define __AUDIO_AUTOMATION_TRACK_H__
 
#include "zrythm-config.h"
 
#include <stdbool.h>
 
#include "dsp/automation_point.h"
#include "dsp/port.h"
#include "dsp/position.h"
#include "dsp/region.h"
 
typedef struct Port                   Port;
typedef struct _AutomationTrackWidget AutomationTrackWidget;
typedef struct Track                  Track;
typedef struct AutomationTracklist    AutomationTracklist;
typedef struct CustomButtonWidget     CustomButtonWidget;
typedef struct AutomationModeWidget   AutomationModeWidget;
 
#define AUTOMATION_TRACK_SCHEMA_VERSION 2
 
#define MAX_AUTOMATION_POINTS 1200
 
#define AUTOMATION_RECORDING_TOUCH_REL_MS 800
 
typedef enum AutomationMode
{
  AUTOMATION_MODE_READ,
  AUTOMATION_MODE_RECORD,
  AUTOMATION_MODE_OFF,
  NUM_AUTOMATION_MODES,
} AutomationMode;
 
static const cyaml_strval_t automation_mode_strings[] = {
  {"Read",       AUTOMATION_MODE_READ  },
  { "Rec",       AUTOMATION_MODE_RECORD},
  { "Off",       AUTOMATION_MODE_OFF   },
  { "<invalid>", NUM_AUTOMATION_MODES  },
};
 
typedef enum AutomationRecordMode
{
  AUTOMATION_RECORD_MODE_TOUCH,
  AUTOMATION_RECORD_MODE_LATCH,
  NUM_AUTOMATION_RECORD_MODES,
} AutomationRecordMode;
 
static const cyaml_strval_t automation_record_mode_strings[] = {
  {"Touch",      AUTOMATION_RECORD_MODE_TOUCH},
  { "Latch",     AUTOMATION_RECORD_MODE_LATCH},
  { "<invalid>", NUM_AUTOMATION_RECORD_MODES },
};
 
typedef struct AutomationTrack
{
  int schema_version;
 
  int index;
 
  PortIdentifier port_id;
 
  bool created;
 
  ZRegion ** regions;
  int        num_regions;
  size_t     regions_size;
 
  ZRegion ** region_snapshots;
  int        num_region_snapshots;
 
  bool visible;
 
  int y;
 
  double height;
 
  float last_recorded_value;
 
  AutomationMode automation_mode;
 
  AutomationRecordMode record_mode;
 
  bool recording_started;
 
  ZRegion * recording_region;
 
  bool recording_start_sent;
 
  bool recording_paused;
 
  CustomButtonWidget * top_right_buttons[8];
  int                  num_top_right_buttons;
  CustomButtonWidget * top_left_buttons[8];
  int                  num_top_left_buttons;
  CustomButtonWidget * bot_right_buttons[8];
  int                  num_bot_right_buttons;
 
  AutomationModeWidget * am_widget;
 
  CustomButtonWidget * bot_left_buttons[8];
  int                  num_bot_left_buttons;
 
  AutomationTracklist * atl;
 
  Port * port;
} AutomationTrack;
 
static const cyaml_schema_field_t automation_track_fields_schema[] = {
  YAML_FIELD_INT (AutomationTrack, schema_version),
  YAML_FIELD_INT (AutomationTrack, index),
  YAML_FIELD_MAPPING_EMBEDDED (
    AutomationTrack,
    port_id,
    port_identifier_fields_schema),
  YAML_FIELD_DYN_PTR_ARRAY_VAR_COUNT_OPT (AutomationTrack, regions, region_schema),
  YAML_FIELD_INT (AutomationTrack, created),
  YAML_FIELD_ENUM (AutomationTrack, automation_mode, automation_mode_strings),
  YAML_FIELD_ENUM (AutomationTrack, record_mode, automation_record_mode_strings),
  YAML_FIELD_INT (AutomationTrack, visible),
  YAML_FIELD_FLOAT (AutomationTrack, height),
 
  CYAML_FIELD_END
};
 
static const cyaml_schema_value_t automation_track_schema = {
  YAML_VALUE_PTR (AutomationTrack, automation_track_fields_schema),
};
 
COLD NONNULL_ARGS (1) void automation_track_init_loaded (
  AutomationTrack *     self,
  AutomationTracklist * atl);
 
NONNULL AutomationTrack *
automation_track_new (Port * port);
 
NONNULL bool
automation_track_validate (AutomationTrack * self);
 
void
automation_mode_get_localized (AutomationMode mode, char * buf);
 
void
automation_record_mode_get_localized (AutomationRecordMode mode, char * buf);
 
NONNULL AutomationTrack *
automation_track_find_from_port_id (PortIdentifier * id, bool basic_search);
 
HOT AutomationTrack *
automation_track_find_from_port (Port * port, Track * track, bool basic_search);
 
void
automation_track_set_automation_mode (
  AutomationTrack * self,
  AutomationMode    mode,
  bool              fire_events);
 
NONNULL static inline void
automation_track_swap_record_mode (AutomationTrack * self)
{
  self->record_mode = (self->record_mode + 1) % NUM_AUTOMATION_RECORD_MODES;
}
 
NONNULL AutomationTracklist *
automation_track_get_automation_tracklist (AutomationTrack * self);
 
HOT NONNULL bool
automation_track_should_read_automation (AutomationTrack * at, gint64 cur_time);
 
HOT NONNULL bool
automation_track_should_be_recording (
  const AutomationTrack * const at,
  const gint64                  cur_time,
  const bool                    record_aps);
 
NONNULL void
automation_track_add_region (AutomationTrack * self, ZRegion * region);
 
NONNULL void
automation_track_insert_region (AutomationTrack * self, ZRegion * region, int idx);
 
//int
//automation_track_get_visible_y_offset (
//AutomationTrack * self);
 
NONNULL void
automation_track_update_positions (
  AutomationTrack * self,
  bool              from_ticks,
  bool              bpm_change);
 
NONNULL void
automation_track_set_index (AutomationTrack * self, int index);
 
NONNULL AutomationTrack *
automation_track_clone (AutomationTrack * src);
 
NONNULL Track *
automation_track_get_track (AutomationTrack * self);
 
NONNULL AutomationPoint *
automation_track_get_ap_before_pos (
  const AutomationTrack * self,
  const Position *        pos,
  bool                    ends_after,
  bool                    use_snapshots);
 
ZRegion *
automation_track_get_region_before_pos (
  const AutomationTrack * self,
  const Position *        pos,
  bool                    ends_after,
  bool                    use_snapshots);
 
NONNULL void
automation_track_unselect_all (AutomationTrack * self);
 
NONNULL void
automation_track_remove_region (AutomationTrack * self, ZRegion * region);
 
NONNULL void
automation_track_clear (AutomationTrack * self);
 
NONNULL float
automation_track_get_val_at_pos (
  AutomationTrack * self,
  Position *        pos,
  bool              normalized,
  bool              ends_after,
  bool              use_snapshots);
 
NONNULL int
automation_track_get_y_px_from_normalized_val (
  AutomationTrack * self,
  float             normalized_val);
 
#if 0
NONNULL
Port *
automation_track_get_port (
  const AutomationTrack * const self);
#endif
 
NONNULL ZRegion *
automation_track_get_last_region (AutomationTrack * self);
 
NONNULL void
automation_track_set_caches (AutomationTrack * self, CacheTypes types);
 
NONNULL bool
automation_track_contains_automation (const AutomationTrack * self);
 
NONNULL bool
automation_track_verify (AutomationTrack * self);
 
NONNULL void
automation_track_free (AutomationTrack * at);
 
#endif // __AUDIO_AUTOMATION_TRACK_H__