atomic_position.h

// SPDX-FileCopyrightText: © 2025 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#pragma once
 
#include <atomic>
#include <cstdint>
#include <functional>
#include <limits>
 
#include "dsp/tempo_map.h"
#include "utils/format.h"
#include "utils/types.h"
#include "utils/units.h"
 
#include <fmt/format.h>
#include <nlohmann/json_fwd.hpp>
 
namespace zrythm::dsp
{
 
namespace internal
{
static_assert (
  std::numeric_limits<double>::is_iec559,
  "Requires IEEE-754 doubles");
static_assert (
  std::atomic<uint64_t>::is_always_lock_free,
  "64-bit atomics not lock-free");

class AtomicDoubleWithBool
{
  std::atomic<uint64_t> packed_;
 
  // Mask to clear LSB (where we store the bool)
  static constexpr uint64_t kValueMask = ~1ULL;
 
public:
  AtomicDoubleWithBool () noexcept = default;
  AtomicDoubleWithBool (double d, bool b) noexcept { store (d, b); }
 
  void store (double d, bool b) noexcept
  {
    assert (std::isfinite (d) && "Only finite doubles supported");
    const auto bits = std::bit_cast<uint64_t> (d);
    packed_.store ((bits & kValueMask) | (b ? 1 : 0), std::memory_order_release);
  }
 
  std::pair<double, bool> load () const noexcept
  {
    const uint64_t bits = packed_.load (std::memory_order_acquire);
    return {
      std::bit_cast<double> (bits & kValueMask), // Original value ≈ d
      static_cast<bool> (bits & 1)               // Stored bool
    };
  }
};
} // namespace internal

class AtomicPosition
{
public:
  struct TimeConversionFunctions
  {
    std::function<units::precise_second_t (units::precise_tick_t)>
      tick_to_seconds;
    std::function<units::precise_tick_t (units::precise_second_t)>
      seconds_to_tick;
    std::function<units::precise_sample_t (units::precise_tick_t)>
      tick_to_samples;
    std::function<units::precise_tick_t (units::precise_sample_t)>
      samples_to_tick;
 
    static std::unique_ptr<TimeConversionFunctions>
    from_tempo_map (const dsp::TempoMap &tempo_map)
    {
      return std::make_unique<
        dsp::AtomicPosition::
          TimeConversionFunctions> (dsp::AtomicPosition::TimeConversionFunctions{
        .tick_to_seconds =
          [&] (units::precise_tick_t ticks) {
            return tempo_map.tick_to_seconds (ticks);
          },
        .seconds_to_tick =
          [&] (units::precise_second_t seconds) {
            return tempo_map.seconds_to_tick (seconds);
          },
        .tick_to_samples =
          [&] (units::precise_tick_t ticks) {
            return tempo_map.tick_to_samples (ticks);
          },
        .samples_to_tick =
          [&] (units::precise_sample_t samples) {
            return tempo_map.samples_to_tick (samples);
          },
      });
    }
  };

  AtomicPosition (const TimeConversionFunctions &conversion_funcs) noexcept
      : conversion_funcs_ (conversion_funcs),
        value_ (0, format_to_bool (TimeFormat::Musical))
  {
  }

  auto get_current_mode () const
  {
    return bool_to_format (value_.load ().second);
  }

  void set_mode (TimeFormat format)
  {
    const auto cur_mode = get_current_mode ();
    if (cur_mode == TimeFormat::Absolute && format == TimeFormat::Musical)
      {
        value_.store (
          get_ticks ().in (units::ticks), format_to_bool (TimeFormat::Musical));
      }
    else if (cur_mode == TimeFormat::Musical && format == TimeFormat::Absolute)
      {
        value_.store (
          get_seconds ().in (units::seconds),
          format_to_bool (TimeFormat::Absolute));
      }
  }

  void set_ticks (units::precise_tick_t ticks)
  {
    const auto cur_mode = get_current_mode ();
    if (cur_mode == TimeFormat::Musical)
      {
        value_.store (
          ticks.in (units::ticks), format_to_bool (TimeFormat::Musical));
      }
    else if (cur_mode == TimeFormat::Absolute)
      {
        set_seconds (conversion_funcs_.tick_to_seconds (ticks));
      }
  }

  void set_seconds (units::precise_second_t seconds)
  {
    const auto cur_mode = get_current_mode ();
    if (cur_mode == TimeFormat::Absolute)
      {
        value_.store (
          seconds.in (units::seconds), format_to_bool (TimeFormat::Absolute));
      }
    else if (cur_mode == TimeFormat::Musical)
      {
        set_ticks (conversion_funcs_.seconds_to_tick (seconds));
      }
  }

  units::precise_tick_t get_ticks () const
  {
    const auto &[d, b] = value_.load ();
    if (bool_to_format (b) == TimeFormat::Musical)
      {
        return units::ticks (d);
      }
    return conversion_funcs_.seconds_to_tick (units::seconds (d));
  }

  units::precise_second_t get_seconds () const
  {
    const auto &[d, b] = value_.load ();
    if (bool_to_format (b) == TimeFormat::Absolute)
      {
        return units::seconds (d);
      }
    return conversion_funcs_.tick_to_seconds (units::ticks (d));
  }

  units::sample_t get_samples () const
  {
    const auto &[d, b] = value_.load ();
    auto tick =
      bool_to_format (b) == TimeFormat::Musical
        ? units::ticks (d)
        : conversion_funcs_.seconds_to_tick (units::seconds (d));
    return au::round_as<std::int64_t> (
      units::samples, conversion_funcs_.tick_to_samples (tick));
  }
 
  void set_samples (units::precise_sample_t samples)
  {
    set_ticks (conversion_funcs_.samples_to_tick (samples));
  }
 
  const auto &time_conversion_functions () const { return conversion_funcs_; }
 
private:
  static constexpr bool format_to_bool (TimeFormat format) noexcept
  {
    return format == TimeFormat::Absolute;
  }
  static constexpr TimeFormat bool_to_format (bool b) noexcept
  {
    return b ? TimeFormat::Absolute : TimeFormat::Musical;
  }
 
  static constexpr auto kMode = "mode"sv;
  static constexpr auto kValue = "value"sv;
  friend void           to_json (nlohmann::json &j, const AtomicPosition &pos);
  friend void from_json (const nlohmann::json &j, AtomicPosition &pos);
 
private:
  const TimeConversionFunctions &conversion_funcs_;
  internal::AtomicDoubleWithBool value_;
};
 
} // namespace zrythm::dsp
 
// Formatter for AtomicPosition
template <>
struct fmt::formatter<zrythm::dsp::AtomicPosition>
    : fmt::formatter<std::string_view>
{
  template <typename FormatContext>
  auto format (const zrythm::dsp::AtomicPosition &pos, FormatContext &ctx) const
  {
    return fmt::formatter<std::string_view>{}.format (
      fmt::format (
        "Ticks: {:.2f} | Seconds: {:.3f} | Samples: {} | [Mode: {}]",
        pos.get_ticks (), pos.get_seconds (), pos.get_samples (),
        pos.get_current_mode ()),
      ctx);
  }
};