region.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: © 2018-2022 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#ifndef __AUDIO_REGION_H__
#define __AUDIO_REGION_H__
 
#include "dsp/automation_point.h"
#include "dsp/chord_object.h"
#include "dsp/midi_note.h"
#include "dsp/position.h"
#include "dsp/region_identifier.h"
#include "gui/backend/arranger_object.h"
#include "utils/yaml.h"
 
#include <glib/gi18n.h>
 
typedef struct Channel         Channel;
typedef struct Track           Track;
typedef struct MidiNote        MidiNote;
typedef struct TrackLane       TrackLane;
typedef struct RegionLinkGroup RegionLinkGroup;
typedef struct Stretcher       Stretcher;
typedef struct AudioClip       AudioClip;
 
#define REGION_SCHEMA_VERSION 1
 
#define REGION_MAGIC 93075327
#define IS_REGION(x) (((ZRegion *) x)->magic == REGION_MAGIC)
#define IS_REGION_AND_NONNULL(x) (x && IS_REGION (x))
 
#define REGION_PRINTF_FILENAME "%s_%s.mid"
 
#define region_is_selected(r) \
  arranger_object_is_selected ((ArrangerObject *) r)
 
typedef enum RegionMusicalMode
{
  REGION_MUSICAL_MODE_INHERIT,
  REGION_MUSICAL_MODE_OFF,
  REGION_MUSICAL_MODE_ON,
} RegionMusicalMode;
 
static const cyaml_strval_t region_musical_mode_strings[] = {
  {N_ ("Inherit"), REGION_MUSICAL_MODE_INHERIT},
  { N_ ("Off"),    REGION_MUSICAL_MODE_OFF    },
  { N_ ("On"),     REGION_MUSICAL_MODE_ON     },
};
 
typedef struct ZRegion
{
  ArrangerObject base;
 
  int schema_version;
 
  RegionIdentifier id;
 
  char * name;
 
  char * escaped_name;
 
  GdkRGBA color;
 
  bool use_color;
 
  /* ==== MIDI REGION ==== */
 
  MidiNote ** midi_notes;
  int         num_midi_notes;
  size_t      midi_notes_size;
 
  MidiNote * unended_notes[12000];
  int        num_unended_notes;
 
  /* ==== MIDI REGION END ==== */
 
  /* ==== AUDIO REGION ==== */
 
  int pool_id;
 
  bool stretching;
 
  double before_length;
 
  double stretch_ratio;
 
  bool read_from_pool;
 
  float gain;
 
  AudioClip * clip;
 
#if 0
  sample_t *        frames;
  size_t            num_frames;
 
  sample_t *        ch_frames[16];
#endif
 
  RegionMusicalMode musical_mode;
 
  Position * split_points;
  int        num_split_points;
  size_t     split_points_size;
 
  /* ==== AUDIO REGION END ==== */
 
  /* ==== AUTOMATION REGION ==== */
 
  AutomationPoint ** aps;
  int                num_aps;
  size_t             aps_size;
 
  AutomationPoint * last_recorded_ap;
 
  /* ==== AUTOMATION REGION END ==== */
 
  /* ==== CHORD REGION ==== */
 
  ChordObject ** chord_objects;
  int            num_chord_objects;
  size_t         chord_objects_size;
 
  /* ==== CHORD REGION END ==== */
 
  int bounce;
 
  /* --- drawing caches --- */
 
  /* New region drawing needs to be cached in the
   * following situations:
   *
   * 1. when hidden part of the region is revealed
   *   (on x axis).
   *   TODO max 140% of the region should be
   *   cached (20% before and 20% after if before/
   *   after is not fully visible)
   * 2. when full rect (x/width) changes
   * 3. when a region marker is moved
   * 4. when the clip actually changes (use
   *   last-change timestamp on the clip or region)
   * 5. when fades change
   * 6. when region height changes (track/lane)
   */
 
  PangoLayout * layout;
 
  PangoLayout * chords_layout;
 
  /* these are used for caching */
  GdkRectangle last_main_full_rect;
 
  GdkRectangle last_main_draw_rect;
 
  /* these are used for caching */
  GdkRectangle last_lane_full_rect;
 
  GdkRectangle last_lane_draw_rect;
 
  gint64 last_clip_change;
 
  gint64 last_cache_time;
 
  ArrangerObject last_positions_obj;
 
  /* --- drawing caches end --- */
 
  int magic;
} ZRegion;
 
static const cyaml_schema_field_t region_fields_schema[] = {
  YAML_FIELD_INT (ZRegion, schema_version),
  YAML_FIELD_MAPPING_EMBEDDED (
    ZRegion,
    base,
    arranger_object_fields_schema),
  YAML_FIELD_MAPPING_EMBEDDED (
    ZRegion,
    id,
    region_identifier_fields_schema),
  YAML_FIELD_STRING_PTR (ZRegion, name),
  YAML_FIELD_INT (ZRegion, pool_id),
  YAML_FIELD_FLOAT (ZRegion, gain),
  YAML_FIELD_MAPPING_EMBEDDED (
    ZRegion,
    color,
    gdk_rgba_fields_schema),
  YAML_FIELD_INT (ZRegion, use_color),
  CYAML_FIELD_SEQUENCE_COUNT (
    "midi_notes",
    CYAML_FLAG_POINTER | CYAML_FLAG_OPTIONAL,
    ZRegion,
    midi_notes,
    num_midi_notes,
    &midi_note_schema,
    0,
    CYAML_UNLIMITED),
  CYAML_FIELD_SEQUENCE_COUNT (
    "aps",
    CYAML_FLAG_POINTER | CYAML_FLAG_OPTIONAL,
    ZRegion,
    aps,
    num_aps,
    &automation_point_schema,
    0,
    CYAML_UNLIMITED),
  CYAML_FIELD_SEQUENCE_COUNT (
    "chord_objects",
    CYAML_FLAG_POINTER | CYAML_FLAG_OPTIONAL,
    ZRegion,
    chord_objects,
    num_chord_objects,
    &chord_object_schema,
    0,
    CYAML_UNLIMITED),
  YAML_FIELD_ENUM (
    ZRegion,
    musical_mode,
    region_musical_mode_strings),
 
  CYAML_FIELD_END
};
 
static const cyaml_schema_value_t region_schema = {
  YAML_VALUE_PTR_NULLABLE (ZRegion, region_fields_schema),
};
 
#define region_type_can_fade(rtype) \
  (rtype == REGION_TYPE_AUDIO)
 
void
region_init (
  ZRegion *        region,
  const Position * start_pos,
  const Position * end_pos,
  unsigned int     track_name_hash,
  int              lane_pos,
  int              idx_inside_lane);
 
HOT NONNULL ZRegion *
region_find (const RegionIdentifier * const id);
 
#if 0
static inline void
region_set_track_name_hash (
  ZRegion *    self,
  unsigned int name_hash)
{
  self->id.track_name_hash = name_hash;
}
#endif
 
NONNULL void
region_print_to_str (
  const ZRegion * self,
  char *          buf,
  const size_t    buf_size);
 
NONNULL void
region_print (const ZRegion * region);
 
TrackLane *
region_get_lane (const ZRegion * region);
 
RegionLinkGroup *
region_get_link_group (ZRegion * self);
 
void
region_set_link_group (
  ZRegion * region,
  int       group_idx,
  bool      update_identifier);
 
NONNULL bool
region_has_link_group (ZRegion * region);
 
MidiNote *
region_find_midi_note (ZRegion * r, MidiNote * _mn);
 
NONNULL HOT signed_frame_t
region_timeline_frames_to_local (
  const ZRegion * const self,
  const signed_frame_t  timeline_frames,
  const bool            normalize);
 
NONNULL void
region_get_frames_till_next_loop_or_end (
  const ZRegion * const self,
  const signed_frame_t  timeline_frames,
  signed_frame_t *      ret_frames,
  bool *                is_loop);
 
NONNULL void
region_set_lane (ZRegion * self, const TrackLane * const lane);
 
void
region_gen_name (
  ZRegion *         region,
  const char *      base_name,
  AutomationTrack * at,
  Track *           track);
 
NONNULL WARN_UNUSED_RESULT bool
region_stretch (ZRegion * self, double ratio, GError ** error);
 
NONNULL void
region_update_identifier (ZRegion * self);
 
NONNULL void
region_update_link_group (ZRegion * self);
 
void
region_move_to_track (
  ZRegion * region,
  Track *   track,
  int       lane_or_at_index,
  int       index);
 
CONST
static inline int
region_type_has_lane (const RegionType type)
{
  return type == REGION_TYPE_MIDI || type == REGION_TYPE_AUDIO;
}
 
void
region_set_automation_track (
  ZRegion *         region,
  AutomationTrack * at);
 
AutomationTrack *
region_get_automation_track (const ZRegion * const region);
 
void
region_copy (ZRegion * src, ZRegion * dest);
 
NONNULL PURE int
region_is_hit (
  const ZRegion *      region,
  const signed_frame_t gframes,
  const bool           inclusive);
 
int
region_is_hit_by_range (
  const ZRegion *      region,
  const signed_frame_t gframes_start,
  const signed_frame_t gframes_end,
  const bool           end_inclusive);
 
NONNULL_ARGS (3)
PURE ZRegion * region_at_position (
  const Track *           track,
  const AutomationTrack * at,
  const Position *        pos);
 
char *
region_generate_filename (ZRegion * region);
 
void
region_get_type_as_string (RegionType type, char * buf);
 
bool
region_is_recording (ZRegion * self);
 
bool
region_get_musical_mode (ZRegion * self);
 
void
region_add_arranger_object (
  ZRegion *        self,
  ArrangerObject * obj,
  bool             fire_events);
 
void
region_create_link_group_if_none (ZRegion * region);
 
void
region_unlink (ZRegion * region);
 
void
region_remove_all_children (ZRegion * region);
 
void
region_copy_children (ZRegion * dest, ZRegion * src);
 
NONNULL bool
region_is_looped (const ZRegion * const self);
 
ArrangerSelections *
region_get_arranger_selections (ZRegion * self);
 
ArrangerWidget *
region_get_arranger_for_children (ZRegion * self);
 
bool
region_validate (
  ZRegion * self,
  bool      is_project,
  double    frames_per_tick);
 
void
region_disconnect (ZRegion * self);
 
#endif // __AUDIO_REGION_H__