position.h

Go to the documentation of this file.

// clang-format off
// SPDX-FileCopyrightText: © 2018-2021, 2023-2024 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
// clang-format on
 
#ifndef __AUDIO_POSITION_H__
#define __AUDIO_POSITION_H__
 
#include "utils/types.h"
#include "utils/yaml.h"
 
#define TICKS_PER_QUARTER_NOTE 960
#define TICKS_PER_SIXTEENTH_NOTE 240
#define TICKS_PER_QUARTER_NOTE_DBL 960.0
#define TICKS_PER_SIXTEENTH_NOTE_DBL 240.0
#define TICKS_PER_NINETYSIXTH_NOTE_DBL 40.0
#define position_add_sixteenths(_pos, _s) \
  position_add_ticks ((_pos), (_s) * TICKS_PER_SIXTEENTH_NOTE)
#define position_add_beats(_pos, _b) \
  g_warn_if_fail (TRANSPORT->ticks_per_beat > 0); \
  position_add_ticks ((_pos), (_b) * TRANSPORT->ticks_per_beat)
#define position_add_bars(_pos, _b) \
  g_warn_if_fail (TRANSPORT->ticks_per_bar > 0); \
  position_add_ticks ((_pos), (_b) * TRANSPORT->ticks_per_bar)
#define position_snap_simple(pos, sg) position_snap (NULL, pos, NULL, NULL, sg)
 
#define POSITION_MAX_BAR 160000
 
#define position_between_frames_excl2(pos, f1, f2) \
  ((pos)->frames >= f1 && (pos)->frames < f2)
 
#define position_compare_frames(p1, p2) ((p1)->frames - (p2)->frames)
 
#define position_is_before(_pos, _cmp) \
  (position_compare_frames (_pos, _cmp) < 0)
 
#define position_is_before_or_equal(_pos, _cmp) \
  (position_compare_frames (_pos, _cmp) <= 0)
 
#define position_is_equal(_pos, _cmp) \
  (position_compare_frames (_pos, _cmp) == 0)
 
#define position_is_after(_pos, _cmp) (position_compare_frames (_pos, _cmp) > 0)
 
#define position_is_after_or_equal(_pos, _cmp) \
  (position_compare_frames (_pos, _cmp) >= 0)
 
#define position_is_positive(pos) ((pos)->frames >= 0 && (pos)->ticks >= 0)
 
#define position_compare_ticks(p1, p2) ((p1)->ticks - (p2)->ticks)
 
#define position_is_equal_ticks(p1, p2) \
  (fabs (position_compare_ticks (p1, p2)) <= DBL_EPSILON)
 
#define position_is_between(_pos, _start, _end) \
  (position_is_after_or_equal (_pos, _start) && position_is_before (_pos, _end))
 
#define position_is_between_excl_start(_pos, _start, _end) \
  (position_is_after (_pos, _start) && position_is_before (_pos, _end))
 
#define position_min(p1, p2) (position_compare_frames (p1, p2) < 0 ? p1 : p2)
 
#define position_max(p1, p2) (position_compare_frames (p1, p2) > 0 ? p1 : p2)
 
#define POSITION_INIT_ON_STACK(name) Position name = POSITION_START;
 
#define position_init(__pos) *(__pos) = POSITION_START
 
typedef struct SnapGrid SnapGrid;
typedef struct Track    Track;
typedef struct Region   Region;
 
typedef struct Position
{
  double ticks;
 
  signed_frame_t frames;
 
  // double precise_frames;
} Position;
 
static const Position POSITION_START = { .ticks = 0.0, .frames = 0 };
 
static inline int
position_cmp_func (const void * _a, const void * _b)
{
  const Position * a = (Position const *) _a;
  const Position * b = (Position const *) _b;
 
  /* prevent conversion overflows */
  signed_frame_t diff = position_compare_frames (a, b);
  if (diff < 0)
    return -1;
  else if (diff > 0)
    return 1;
  else
    return 0;
}
 
void
position_set_to_bar (Position * self, int bar);
 
void
position_sort_array (Position * array, const size_t size);
 
#define position_set_to_pos(_pos, _target) *(_pos) = *(_target)
 
HOT void
position_add_frames (Position * pos, const signed_frame_t frames);
 
#define position_to_frames(x) ((x)->frames)
#define position_to_ticks(x) ((x)->ticks)
 
void
position_from_seconds (Position * position, double secs);
 
HOT NONNULL void
position_from_frames (Position * pos, const signed_frame_t frames);
 
HOT NONNULL void
position_from_ticks (Position * pos, double ticks);
 
NONNULL void
position_from_ms (Position * pos, const signed_ms_t ms);
 
NONNULL void
position_from_bars (Position * pos, int bars);
 
HOT NONNULL void
position_add_ticks (Position * self, double ticks);
 
signed_ms_t
position_to_ms (const Position * pos);
 
signed_frame_t
position_ms_to_frames (const double ms);
 
double
position_ms_to_ticks (const double ms);
 
void
position_add_ms (Position * pos, const double ms);
 
void
position_add_minutes (Position * pos, int mins);
 
void
position_add_seconds (Position * pos, const signed_sec_t seconds);
 
NONNULL_ARGS (2)
void position_snap (
  const Position * start_pos,
  Position *       pos,
  Track *          track,
  Region *         region,
  const SnapGrid * sg);
 
void
position_set_min_size (
  const Position * start_pos,
  Position *       end_pos,
  SnapGrid *       snap);
 
HOT NONNULL void
position_update_ticks_from_frames (Position * position, double ticks_per_frame);
 
signed_frame_t
position_get_frames_from_ticks (double ticks, double frames_per_tick);
 
HOT NONNULL void
position_update_frames_from_ticks (Position * self, double frames_per_tick);
 
static inline void
position_update (Position * self, bool from_ticks, double ratio)
{
  if (from_ticks)
    position_update_frames_from_ticks (self, ratio);
  else
    position_update_ticks_from_frames (self, ratio);
}
 
void
position_get_midway_pos (Position * start_pos, Position * end_pos, Position * pos);
 
double
position_get_ticks_diff (
  const Position * end_pos,
  const Position * start_pos,
  const SnapGrid * sg);
 
NONNULL char *
position_to_string_alloc (const Position * pos);
 
NONNULL void
position_to_string_full (const Position * pos, char * buf, int decimal_places);
 
NONNULL void
position_to_string (const Position * pos, char * buf);
 
NONNULL WARN_UNUSED_RESULT bool
position_parse (Position * pos, const char * str);
 
NONNULL void
position_print (const Position * pos);
 
NONNULL void
position_print_range (const Position * pos, const Position * pos2);
 
NONNULL int
position_get_total_bars (const Position * pos, bool include_current);
 
NONNULL int
position_get_total_beats (const Position * pos, bool include_current);
 
NONNULL int
position_get_total_sixteenths (const Position * pos, bool include_current);
 
NONNULL void
position_change_sign (Position * pos);
 
NONNULL int
position_get_bars (const Position * pos, bool start_at_one);
 
NONNULL int
position_get_beats (const Position * pos, bool start_at_one);
 
NONNULL int
position_get_sixteenths (const Position * pos, bool start_at_one);
 
NONNULL double
position_get_ticks (const Position * pos);
 
NONNULL bool
position_validate (const Position * pos);
 
#endif