tempo_map.h

// SPDX-FileCopyrightText: © 2025-2026 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#pragma once
 
#include <cstdint>
#include <string_view>
#include <vector>
 
#include "utils/units.h"
 
#include <nlohmann/json_fwd.hpp>
 
namespace zrythm::dsp
{

template <units::tick_t::NTTP PPQ> class FixedPpqTempoMap
{
  friend class TempoMapWrapper;
 
public:
  enum class CurveType : std::uint8_t
  {
    Constant, 
    Linear    
  };

  struct TempoEvent
  {
    units::tick_t tick;    
    double        bpm{};   
    CurveType     curve{}; 
 
    friend void to_json (nlohmann::json &j, const TempoEvent &e);
    friend void from_json (const nlohmann::json &j, TempoEvent &e);
  };

  struct TimeSignatureEvent
  {
    units::tick_t tick;          
    int           numerator{};   
    int           denominator{}; 
 
    constexpr auto quarters_per_bar () const
    {
      return (numerator * 4) / denominator;
    }
 
    constexpr auto ticks_per_bar () const
    {
      return units::ticks (quarters_per_bar () * FixedPpqTempoMap::get_ppq ());
    }
 
    constexpr auto ticks_per_beat () const
    {
      return ticks_per_bar () / numerator;
    }
 
    constexpr auto
    is_different_time_signature (const TimeSignatureEvent &other) const
    {
      return numerator != other.numerator || denominator != other.denominator;
    }
 
    friend void to_json (nlohmann::json &j, const TimeSignatureEvent &e);
    friend void from_json (const nlohmann::json &j, TimeSignatureEvent &e);
  };

  struct MusicalPosition
  {
    int bar{ 1 };       
    int beat{ 1 };      
    int sixteenth{ 1 }; 
    int tick{};         
 
    friend bool
    operator== (const MusicalPosition &lhs, const MusicalPosition &rhs) =
      default;
  };

  explicit FixedPpqTempoMap (units::precise_sample_rate_t sampleRate)
      : sample_rate_ (sampleRate)
  {
  }

  void set_sample_rate (units::precise_sample_rate_t sampleRate)
  {
    sample_rate_ = sampleRate;
  }

  void add_tempo_event (units::tick_t tick, double bpm, CurveType curve);

  void remove_tempo_event (units::tick_t tick);

  void
  add_time_signature_event (units::tick_t tick, int numerator, int denominator);

  void remove_time_signature_event (units::tick_t tick);

  auto
  tick_to_seconds (units::precise_tick_t tick) const -> units::precise_second_t;

  units::precise_sample_t tick_to_samples (units::precise_tick_t tick) const
  {
    return tick_to_seconds (tick) * sample_rate_;
  }
 
  units::sample_t tick_to_samples_rounded (units::precise_tick_t tick) const
  {
    return au::round_as<int64_t> (units::samples, tick_to_samples (tick));
  }

  units::precise_tick_t seconds_to_tick (units::precise_second_t seconds) const;

  units::precise_tick_t samples_to_tick (units::precise_sample_t samples) const
  {
    const auto seconds = samples / sample_rate_;
    return seconds_to_tick (seconds);
  }

  TimeSignatureEvent time_signature_at_tick (units::tick_t tick) const;

  double tempo_at_tick (units::tick_t tick) const;

  MusicalPosition tick_to_musical_position (units::tick_t tick) const;
 
  MusicalPosition samples_to_musical_position (units::sample_t samples) const;

  units::tick_t musical_position_to_tick (const MusicalPosition &pos) const;

  static consteval int get_ppq () { return from_nttp (PPQ).in (units::ticks); }

  double get_sample_rate () const
  {
    return sample_rate_.in (units::sample_rate);
  }
 
  void set_default_bpm (double bpm) { default_tempo_.bpm = bpm; }
  void set_default_time_signature (int numerator, int denominator)
  {
    default_time_sig_.numerator = numerator;
    default_time_sig_.denominator = denominator;
  }
 
private:
  const std::vector<TempoEvent> &get_tempo_events () const { return events_; }

  const std::vector<TimeSignatureEvent> &get_time_signature_events () const
  {
    return time_sig_events_;
  }

  void rebuild_cumulative_times ();

  units::precise_second_t compute_segment_time (
    const TempoEvent &start,
    const TempoEvent &end,
    units::tick_t     segmentTicks) const;
 
  auto get_events_or_default () const;
  auto get_time_signature_events_or_default () const;

  void clear_tempo_events ()
  {
    events_.clear ();
    cumulative_seconds_.clear ();
  }

  void clear_time_signature_events () { time_sig_events_.clear (); }
 
  static constexpr std::string_view kTempoChangesKey = "tempoChanges";
  static constexpr std::string_view kTimeSignaturesKey = "timeSignatures";
  friend void to_json (nlohmann::json &j, const FixedPpqTempoMap &tempo_map);
  friend void from_json (const nlohmann::json &j, FixedPpqTempoMap &tempo_map);
 
private:
  units::precise_sample_rate_t sample_rate_; 
  static constexpr auto        ticks_per_sixteenth_ =
    from_nttp (PPQ) / 4; 
 
  static constexpr auto DEFAULT_BPM_EVENT = TempoEvent{
    units::ticks (0), 120.0, CurveType::Constant
  }; 
  static constexpr auto DEFAULT_TIME_SIG_EVENT =
    TimeSignatureEvent{ units::ticks (0), 4, 4 }; 
  static constexpr auto DEFAULT_CUMULATIVE_SECONDS = units::seconds (0.0);
 
  // Default tempo and time signature to be used when no events are present
  TempoEvent         default_tempo_{ DEFAULT_BPM_EVENT };
  TimeSignatureEvent default_time_sig_{ DEFAULT_TIME_SIG_EVENT };
 
  std::vector<TempoEvent>         events_;          
  std::vector<TimeSignatureEvent> time_sig_events_; 
  std::vector<units::precise_second_t>
    cumulative_seconds_; 
};

using TempoMap = FixedPpqTempoMap<units::PPQ>;
 
extern template class FixedPpqTempoMap<units::PPQ>;
}