types.h

// SPDX-FileCopyrightText: © 2019-2022, 2024-2025 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#pragma once
 
#include "zrythm-config.h"
 
#include <chrono>
#include <cinttypes>
#include <cstdint>
#include <filesystem>
 
#include <QtTypes>
 
#include <gsl-lite/gsl-lite.hpp>
 
#if defined(__GNUC__) || defined(__clang__)
#  pragma GCC diagnostic push
#  pragma GCC diagnostic ignored "-Wshadow"
#elifdef _MSC_VER
#  pragma warning(push)
#  pragma warning(disable : 4458) // declaration hides class member
#endif
 
#include <magic_enum_all.hpp>
 
#if defined(__GNUC__) || defined(__clang__)
#  pragma GCC diagnostic pop
#elifdef _MSC_VER
#  pragma warning(pop)
#endif
 
using namespace magic_enum::bitwise_operators;
using namespace std::literals;
namespace gsl = ::gsl_lite;
 
// For compilers without __cpp_size_t_suffix
constexpr size_t
operator""_zu (unsigned long long int x)
{
  return static_cast<size_t> (x);
}

 
// qint64
using RtTimePoint = int64_t;
using RtDuration = int64_t;

using midi_byte_t = uint8_t;

using nframes_t = uint32_t;

using midi_time_t = uint32_t;

using channels_t = uint_fast8_t;

using audio_sample_type_t = float;

using bpm_t = float;
 
using curviness_t = double;

using signed_frame_t = int_fast64_t;

using unsigned_frame_t = uint_fast64_t;

using signed_ms_t = signed_frame_t;

using signed_sec_t = signed_frame_t;

using ProcessId = qint64;

using GenericFloatGetter = std::function<float ()>;

using GenericFloatSetter = std::function<void (float)>;

using GenericStringGetter = std::function<std::string ()>;

using GenericStringSetter = std::function<void (const std::string &)>;

using GenericCallback = std::function<void ()>;
 
using GenericBoolGetter = std::function<bool ()>;
 
enum class AudioValueFormat
{
  Amplitude,

  DBFS,

  Fader,
};

struct EngineProcessTimeInfo
{
public:
  void print () const;
 
public:
  unsigned_frame_t g_start_frame_ = 0;

  unsigned_frame_t g_start_frame_w_offset_ = 0;

  nframes_t local_offset_ = 0;

  nframes_t nframes_ = 0;
};
 
// TODO: check if pausing/resuming can be done with RAII
struct EngineState
{
  bool running_;
  bool playing_;
  bool looping_;
};
 
enum class TimeFormat : std::uint8_t
{
  Musical,
  Absolute,
};

enum class BeatUnit
{
  Two,
  Four,
  Eight,
  Sixteen
};
 
#define ENUM_INT_TO_VALUE_CONST(_enum, _int) \
  (magic_enum::enum_value<_enum, _int> ())
#define ENUM_INT_TO_VALUE(_enum, _int) (magic_enum::enum_value<_enum> (_int))
#define ENUM_VALUE_TO_INT(_val) (magic_enum::enum_integer (_val))
 
#define ENUM_ENABLE_BITSET(_enum) \
  template <> struct magic_enum::customize::enum_range<_enum> \
  { \
    static constexpr bool is_flags = true; \
  }
#define ENUM_BITSET(_enum, _val) (magic_enum::containers::bitset<_enum> (_val))
#define ENUM_BITSET_TEST(_val, _other_val) \
  /* (ENUM_BITSET (_enum, _val).test (_other_val)) */ \
  (static_cast<std::underlying_type_t<decltype (_val)>> (_val) \
   & static_cast<std::underlying_type_t<decltype (_val)>> (_other_val))

#define ENUM_BITSET_TO_STRING(_enum, _val) \
  (ENUM_BITSET (_enum, _val).to_string ().data ())
 
#define ENUM_COUNT(_enum) (magic_enum::enum_count<_enum> ())
#define ENUM_NAME(_val) (magic_enum::enum_name (_val).data ())
#define ENUM_NAME_FROM_INT(_enum, _int) \
  ENUM_NAME (ENUM_INT_TO_VALUE (_enum, _int))
 
enum class CacheType
{
  // TrackNameHashes = 1 << 0,
  // PluginPorts = 1 << 1,
  PlaybackSnapshots = 1 << 2,
  AutomationLaneRecordModes = 1 << 3,
  AutomationLanePorts = 1 << 4,
};
 
ENUM_ENABLE_BITSET (CacheType);
 
constexpr CacheType ALL_CACHE_TYPES =
  CacheType::PlaybackSnapshots | CacheType::AutomationLaneRecordModes
  | CacheType::AutomationLanePorts;
 
/* types for simple timestamps/durations */
using SteadyClock = std::chrono::steady_clock;
using SteadyTimePoint = SteadyClock::time_point;
using SteadyDuration = SteadyClock::duration;
 
namespace fs = std::filesystem;
 
#define ZRYTHM_IS_QT_THREAD (QThread::currentThread () == qApp->thread ())
 
template <typename T>
std::string
typename_to_string ()
{
  return typeid (T).name ();
}
 
#define Z_DISABLE_COPY_MOVE(Class) Q_DISABLE_COPY_MOVE (Class)
#define Z_DISABLE_COPY(Class) Q_DISABLE_COPY (Class)
#define Z_DISABLE_MOVE(Class) \
  Class (Class &&) = delete; \
  Class &operator= (Class &&) = delete;

template <typename T> struct OptionalRef
{
  OptionalRef () = default;
  OptionalRef (std::nullopt_t) { }
  OptionalRef (T &ref) : ref_ (ref) { }
 
  std::optional<std::reference_wrapper<T>> ref_;

  T &operator* ()
  {
    assert (has_value ());
    return ref_->get ();
  }
  const T &operator* () const
  {
    assert (has_value ());
    return ref_->get ();
  }
 
  const T * operator->() const
  {
    assert (has_value ());
    return std::addressof (ref_->get ());
  }
  T * operator->()
  {
    assert (has_value ());
    return std::addressof (ref_->get ());
  }
 
  explicit operator bool () const { return has_value (); }

  bool has_value () const { return ref_.has_value (); }

  T &value ()
  {
    assert (has_value ());
    return ref_->get ();
  }
};
 
template <typename Tuple, typename Callable>
void
iterate_tuple (Callable c, Tuple &&t)
{
  std::apply ([&] (auto &&... args) { (c (args), ...); }, t);
}
 
// We're using the C type here because MOC complains it can't find the type
// otherwise (not even std::uint8_t)
using basic_enum_base_type_t = uint8_t;