position.h

// SPDX-FileCopyrightText: © 2018-2021, 2023-2025 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#pragma once
 
#include <limits>
 
#include "utils/traits.h"
#include "utils/types.h"
 
#include <fmt/format.h>
#include <nlohmann/json.hpp>
#include <type_safe/strong_typedef.hpp>
 
namespace zrythm::dsp
{
 
struct FramesPerTick
    : type_safe::strong_typedef<FramesPerTick, double>,
      type_safe::strong_typedef_op::equality_comparison<FramesPerTick>,
      type_safe::strong_typedef_op::relational_comparison<FramesPerTick>
{
  using FramesPerTickTag = void; // used by the fmt formatter below
  using type_safe::strong_typedef<FramesPerTick, double>::strong_typedef;
 
  explicit FramesPerTick () = default;
 
  static_assert (StrongTypedef<FramesPerTick>);
};
static_assert (std::regular<FramesPerTick>);
 
struct TicksPerFrame
    : type_safe::strong_typedef<TicksPerFrame, double>,
      type_safe::strong_typedef_op::equality_comparison<TicksPerFrame>,
      type_safe::strong_typedef_op::relational_comparison<TicksPerFrame>
{
  using TicksPerFrameTag = void; // used by the fmt formatter below
  using type_safe::strong_typedef<TicksPerFrame, double>::strong_typedef;
 
  explicit TicksPerFrame () = default;
 
  static_assert (StrongTypedef<TicksPerFrame>);
};
static_assert (std::regular<TicksPerFrame>);
 
static constexpr TicksPerFrame
to_ticks_per_frame (const FramesPerTick &frames_per_tick)
{
  return TicksPerFrame (1.0 / type_safe::get (frames_per_tick));
}
static constexpr FramesPerTick
to_frames_per_tick (const TicksPerFrame &ticks_per_frame)
{
  return FramesPerTick (1.0 / type_safe::get (ticks_per_frame));
}

class Position
{
public:
  static constexpr int    TICKS_PER_QUARTER_NOTE = 960;
  static constexpr int    TICKS_PER_SIXTEENTH_NOTE = 240;
  static constexpr double TICKS_PER_QUARTER_NOTE_DBL = 960.0;
  static constexpr double TICKS_PER_SIXTEENTH_NOTE_DBL = 240.0;
  static constexpr double TICKS_PER_NINETYSIXTH_NOTE_DBL = 40.0;
  static constexpr int    POSITION_MAX_BAR = 160000;
 
public:
  // Rule of 0
  Position () = default;

  Position (
    const char *  str,
    int           beats_per_bar,
    int           sixteenths_per_beat,
    FramesPerTick frames_per_tick);

  Position (double ticks, dsp::FramesPerTick frames_per_tick)
  {
    from_ticks (ticks, frames_per_tick);
  }

  Position (signed_frame_t frames, TicksPerFrame ticks_per_frame)
  {
    from_frames (frames, ticks_per_frame);
  }
 
  void zero ()
  {
    ticks_ = 0.0;
    frames_ = 0;
  }

  signed_frame_t get_total_frames () const { return frames_; }

  double get_total_ticks () const { return ticks_; }

  static signed_frame_t compare_frames (const Position &p1, const Position &p2)
  {
    return p1.frames_ - p2.frames_;
  }
 
  bool ticks_equal (const Position &other) const
  {
    return std::abs (ticks_ - other.ticks_)
           <= std::numeric_limits<double>::epsilon ();
  }

  static const Position &get_min (const Position &p1, const Position &p2)
  {
    return compare_frames (p1, p2) < 0 ? p1 : p2;
  }

  static const Position &get_max (const Position &p1, const Position &p2)
  {
    return compare_frames (p1, p2) > 0 ? p1 : p2;
  }
 
  bool is_positive () const { return frames_ >= 0 && ticks_ >= 0; }

  bool
  is_between_frames_excluding_2nd (signed_frame_t f1, signed_frame_t f2) const
  {
    return frames_ >= f1 && frames_ < f2;
  }

  bool is_between_excl_2nd (const Position &start, const Position &end) const
  {
    return is_between_frames_excluding_2nd (start.frames_, end.frames_);
  }

  bool is_between_incl_2nd (const Position &start, const Position &end) const
  {
    return frames_ >= start.frames_ && frames_ <= end.frames_;
  }
 
  bool is_between_excl_both (const Position &start, const Position &end) const
  {
    return frames_ > start.frames_ && frames_ < end.frames_;
  }
 
  bool
  is_between_excl_1st_incl_2nd (const Position &start, const Position &end) const
  {
    return frames_ > start.frames_ && frames_ <= end.frames_;
  }

  void
  set_to_bar (int bar, int ticks_per_bar, dsp::FramesPerTick frames_per_tick);

  void add_frames (signed_frame_t frames, TicksPerFrame ticks_per_frame)
  {
    frames_ += frames;
    update_ticks_from_frames (ticks_per_frame);
  }

  void from_seconds (
    double        secs,
    sample_rate_t sample_rate,
    TicksPerFrame ticks_per_frame);
 
  void from_frames (const signed_frame_t frames, TicksPerFrame ticks_per_frame)
  {
    frames_ = frames;
    update_ticks_from_frames (ticks_per_frame);
  }

  void from_ticks (double ticks, dsp::FramesPerTick frames_per_tick)
  {
    ticks_ = ticks;
    update_frames_from_ticks (frames_per_tick);
  }
 
  void from_ms (
    const double  ms,
    sample_rate_t sample_rate,
    TicksPerFrame ticks_per_frame)
  {
    zero ();
    add_ms (ms, sample_rate, ticks_per_frame);
  }
 
  void
  from_bars (int bars, int ticks_per_bar, dsp::FramesPerTick frames_per_tick)
  {
    zero ();
    add_bars (bars, ticks_per_bar, frames_per_tick);
  }
 
  void
  add_bars (int bars, int ticks_per_bar, dsp::FramesPerTick frames_per_tick);
 
  void
  add_beats (int beats, int ticks_per_beat, dsp::FramesPerTick frames_per_tick);
 
  void add_sixteenths (int sixteenths, dsp::FramesPerTick frames_per_tick)
  {
    add_ticks (sixteenths * TICKS_PER_SIXTEENTH_NOTE_DBL, frames_per_tick);
  }
 
  void add_ticks (double ticks, dsp::FramesPerTick frames_per_tick)
  {
    ticks_ += ticks;
    update_frames_from_ticks (frames_per_tick);
  }

  signed_ms_t to_ms (sample_rate_t sample_rate) const;
 
  static signed_frame_t ms_to_frames (double ms, sample_rate_t sample_rate);
 
  static double
  ms_to_ticks (double ms, sample_rate_t sample_rate, TicksPerFrame ticks_per_frame)
  {
    /* FIXME simplify - this is a roundabout way not suitable for realtime
     * calculations */
    const signed_frame_t frames = ms_to_frames (ms, sample_rate);
    Position             tmp;
    tmp.from_frames (frames, ticks_per_frame);
    return tmp.ticks_;
  }
 
  void
  add_ms (double ms, sample_rate_t sample_rate, TicksPerFrame ticks_per_frame)
  {
    add_frames (ms_to_frames (ms, sample_rate), ticks_per_frame);
  }
 
  void
  add_minutes (int mins, sample_rate_t sample_rate, TicksPerFrame ticks_per_frame)
  {
    add_frames (ms_to_frames (mins * 60 * 1'000, sample_rate), ticks_per_frame);
  }
 
  void add_seconds (
    signed_sec_t  seconds,
    sample_rate_t sample_rate,
    TicksPerFrame ticks_per_frame)
  {
    add_frames (
      ms_to_frames (static_cast<double> (seconds * 1'000), sample_rate),
      ticks_per_frame);
  }

  [[gnu::hot]] void update_ticks_from_frames (TicksPerFrame ticks_per_frame);

  static signed_frame_t
  get_frames_from_ticks (double ticks, dsp::FramesPerTick frames_per_tick);

  [[gnu::hot]] void update_frames_from_ticks (FramesPerTick frames_per_tick);

  void set_to_midway_pos (
    const Position &start_pos,
    const Position &end_pos,
    FramesPerTick   frames_per_tick)
  {
    ticks_ = start_pos.ticks_ + (end_pos.ticks_ - start_pos.ticks_) / 2.0;
    update_frames_from_ticks (frames_per_tick);
  }

  std::string to_string (
    int           beats_per_bar,
    int           sixteenths_per_beat,
    FramesPerTick frames_per_tick,
    int           decimal_places = 4) const;
 
  [[gnu::nonnull]] void to_string (
    int           beats_per_bar,
    int           sixteenths_per_beat,
    FramesPerTick frames_per_tick,
    char *        buf,
    int           decimal_places = 4) const;

  void print (
    int           beats_per_bar,
    int           sixteenths_per_beat,
    FramesPerTick frames_per_tick) const;
 
  static void print_range (
    int             beats_per_bar,
    int             sixteenths_per_beat,
    FramesPerTick   frames_per_tick,
    const Position &p1,
    const Position &p2);

  int get_total_bars (
    bool          include_current,
    int           ticks_per_bar,
    FramesPerTick frames_per_tick) const;

  int get_total_beats (
    bool          include_current,
    int           beats_per_bar,
    int           ticks_per_beat,
    FramesPerTick frames_per_tick) const;

  int
  get_total_sixteenths (bool include_current, dsp::FramesPerTick frames_per_tick)
    const;

  void change_sign ()
  {
    ticks_ = -ticks_;
    frames_ = -frames_;
  }

  int get_bars (bool start_at_one, int ticks_per_bar) const;

  int
  get_beats (bool start_at_one, int beats_per_bar, int ticks_per_beat) const;

  int get_sixteenths (
    bool          start_at_one,
    int           beats_per_bar,
    int           sixteenths_per_beat,
    FramesPerTick frames_per_tick) const;

  double get_ticks_part (FramesPerTick frames_per_tick) const;
 
  void set_to_position (const Position &pos)
  {
    ticks_ = pos.ticks_;
    frames_ = pos.frames_;
  }

  Position &get_closest_position (Position &p1, Position &p2) const
  {
    if (ticks_ - p1.ticks_ <= p2.ticks_ - ticks_)
      {
        return p1;
      }
 
    return p2;
  }

  friend auto operator<=> (const Position &lhs, const Position &rhs)
  {
    return lhs.frames_ <=> rhs.frames_;
  }
 
  friend bool operator== (const Position &lhs, const Position &rhs)
  {
    return (lhs <=> rhs) == 0;
  }
 
private:
  NLOHMANN_DEFINE_TYPE_INTRUSIVE (Position, ticks_, frames_)
 
public:
  double ticks_ = 0.0;

  signed_frame_t frames_ = 0;

  // double precise_frames;
};
 
inline auto
format_as (const Position &p)
{
  return fmt::format ("{:.3f} ticks ({} frames)", p.ticks_, p.frames_);
}
 
}; // namespace zynth::dsp