transport.h

// SPDX-FileCopyrightText: © 2018-2025 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#pragma once
 
#include "dsp/atomic_position_qml_adapter.h"
#include "dsp/itransport.h"
#include "dsp/playhead_qml_adapter.h"
#include "utils/icloneable.h"
 
namespace zrythm::dsp
{
enum class PrerollCountBars
{
  PrerollNone,
  PrerollOne,
  PrerollTwo,
  PrerollFour,
};
 
inline int
preroll_count_bars_enum_to_int (PrerollCountBars bars)
{
  switch (bars)
    {
    case PrerollCountBars::PrerollNone:
      return 0;
    case PrerollCountBars::PrerollOne:
      return 1;
    case PrerollCountBars::PrerollTwo:
      return 2;
    case PrerollCountBars::PrerollFour:
      return 4;
    }
  return -1;
}

class Transport : public QObject, public dsp::ITransport
{
  Q_OBJECT
  QML_ELEMENT
  Q_PROPERTY (
    bool loopEnabled READ loopEnabled WRITE setLoopEnabled NOTIFY
      loopEnabledChanged)
  Q_PROPERTY (
    bool recordEnabled READ recordEnabled WRITE setRecordEnabled NOTIFY
      recordEnabledChanged)
  Q_PROPERTY (
    bool punchEnabled READ punchEnabled WRITE setPunchEnabled NOTIFY
      punchEnabledChanged)
  Q_PROPERTY (
    PlayState playState READ getPlayState WRITE setPlayState NOTIFY
      playStateChanged)
  Q_PROPERTY (zrythm::dsp::PlayheadQmlWrapper * playhead READ playhead CONSTANT)
  Q_PROPERTY (
    zrythm::dsp::AtomicPositionQmlAdapter * cuePosition READ cuePosition CONSTANT)
  Q_PROPERTY (
    zrythm::dsp::AtomicPositionQmlAdapter * loopStartPosition READ
      loopStartPosition CONSTANT)
  Q_PROPERTY (
    zrythm::dsp::AtomicPositionQmlAdapter * loopEndPosition READ loopEndPosition
      CONSTANT)
  Q_PROPERTY (
    zrythm::dsp::AtomicPositionQmlAdapter * punchInPosition READ punchInPosition
      CONSTANT)
  Q_PROPERTY (
    zrythm::dsp::AtomicPositionQmlAdapter * punchOutPosition READ
      punchOutPosition CONSTANT)
  QML_UNCREATABLE ("")
 
  

  static constexpr auto REPEATED_BACKWARD_MS = au::milli (units::seconds) (240);
 
public:
  Q_ENUM (PlayState)

   * gsettings.
   */
  enum class Display
  {
    BBT,
    Time,
  };
  Q_ENUM (Display)
 
  
  enum class RecordingMode
  {
    OverwriteEvents,


    MergeEvents,

    /**
     * Events get put in new lanes each time recording starts/resumes (eg,
     * when looping or entering/leaving the punch range).
     */
    Takes,

    TakesMuted,
  };
  Q_ENUM (RecordingMode)
 
public:
  struct ConfigProvider
  {
    std::function<bool ()> return_to_cue_on_pause_;

    std::function<int ()> metronome_countin_bars_;

    std::function<int ()> recording_preroll_bars_;
  };
 
  class TransportSnapshot : public dsp::ITransport
  {
  public:
    TransportSnapshot (
      std::pair<units::sample_t, units::sample_t> loop_range,
      std::pair<units::sample_t, units::sample_t> punch_range,
      units::sample_t                             playhead_position,
      units::sample_t recording_preroll_frames_remaining,
      units::sample_t metronome_countin_frames_remaining,
      PlayState       play_state,
      bool            loop_enabled,
      bool            punch_enabled,
      bool            recording_enabled)
        : loop_range_ (loop_range), punch_range_ (punch_range),
          playhead_position_ (playhead_position),
          recording_preroll_frames_remaining_ (recording_preroll_frames_remaining),
          metronome_countin_frames_remaining_ (metronome_countin_frames_remaining),
          play_state_ (play_state), loop_enabled_ (loop_enabled),
          punch_enabled_ (punch_enabled), recording_enabled_ (recording_enabled)
    {
    }
 
    std::pair<units::sample_t, units::sample_t>
    get_loop_range_positions () const noexcept override
    {
      return loop_range_;
    }
    std::pair<units::sample_t, units::sample_t>
    get_punch_range_positions () const noexcept override
    {
      return punch_range_;
    }
    PlayState get_play_state () const noexcept override { return play_state_; }
    units::sample_t
    get_playhead_position_in_audio_thread () const noexcept override
    {
      return playhead_position_;
    }
    bool loop_enabled () const noexcept override { return loop_enabled_; }
 
    bool punch_enabled () const noexcept override { return punch_enabled_; }
    bool recording_enabled () const noexcept override
    {
      return recording_enabled_;
    }
    units::sample_t
    recording_preroll_frames_remaining () const noexcept override
    {
      return recording_preroll_frames_remaining_;
    }
    units::sample_t
    metronome_countin_frames_remaining () const noexcept override
    {
      return metronome_countin_frames_remaining_;
    }
 
    void set_play_state (dsp::ITransport::PlayState play_state)
    {
      play_state_ = play_state;
    }
    void set_position (units::sample_t position)
    {
      playhead_position_ = position;
    }
    void consume_metronome_countin_samples (units::sample_t samples)
    {
      metronome_countin_frames_remaining_ -= samples;
    }
    void consume_recording_preroll_samples (units::sample_t samples)
    {
      recording_preroll_frames_remaining_ -= samples;
    }
 
  private:
    std::pair<units::sample_t, units::sample_t> loop_range_;
    std::pair<units::sample_t, units::sample_t> punch_range_;
    units::sample_t                             playhead_position_;
    units::sample_t recording_preroll_frames_remaining_;
    units::sample_t metronome_countin_frames_remaining_;
    PlayState       play_state_;
    bool            loop_enabled_;
    bool            punch_enabled_;
    bool            recording_enabled_;
  };
 
  Transport (
    const dsp::TempoMap &tempo_map,
    ConfigProvider       config_provider,
    QObject *            parent = nullptr);
 
  // ==================================================================
  // QML Interface
  // ==================================================================
 
  bool          loopEnabled () const { return loop_enabled (); }
  void          setLoopEnabled (bool enabled);
  Q_SIGNAL void loopEnabledChanged (bool enabled);
 
  bool          recordEnabled () const { return recording_enabled (); }
  void          setRecordEnabled (bool enabled);
  Q_SIGNAL void recordEnabledChanged (bool enabled);
 
  bool          punchEnabled () const { return punch_enabled (); }
  void          setPunchEnabled (bool enabled);
  Q_SIGNAL void punchEnabledChanged (bool enabled);
 
  PlayState     getPlayState () const;
  void          setPlayState (PlayState state);
  Q_SIGNAL void playStateChanged (PlayState state);
 
  dsp::PlayheadQmlWrapper * playhead () const
  {
    return playhead_adapter_.get ();
  }
  dsp::AtomicPositionQmlAdapter * cuePosition () const
  {
    return cue_position_adapter_.get ();
  }
  dsp::AtomicPositionQmlAdapter * loopStartPosition () const
  {
    return loop_start_position_adapter_.get ();
  }
  dsp::AtomicPositionQmlAdapter * loopEndPosition () const
  {
    return loop_end_position_adapter_.get ();
  }
  dsp::AtomicPositionQmlAdapter * punchInPosition () const
  {
    return punch_in_position_adapter_.get ();
  }
  dsp::AtomicPositionQmlAdapter * punchOutPosition () const
  {
    return punch_out_position_adapter_.get ();
  }

   */
  Q_INVOKABLE void requestPause () [[clang::blocking]];


  Q_INVOKABLE void requestRoll () [[clang::blocking]];
 
  // ==================================================================
 
  // ==================================================================
  // ITransport Interface
  // ==================================================================
 
  units::sample_t
  get_playhead_position_in_audio_thread () const noexcept override
  {
    return playhead_.position_during_processing_rounded ();
  }
 
  std::pair<units::sample_t, units::sample_t>
  get_loop_range_positions () const noexcept override
  {
    return std::make_pair (
      loop_start_position_.get_samples (), loop_end_position_.get_samples ());
  }
 
  std::pair<units::sample_t, units::sample_t>
  get_punch_range_positions () const noexcept override
  {
    return std::make_pair (
      punch_in_position_.get_samples (), punch_out_position_.get_samples ());
  }
 
  PlayState get_play_state () const noexcept override { return play_state_; }
 
  bool loop_enabled () const noexcept override { return loop_; }
  bool punch_enabled () const noexcept override { return punch_mode_; }
  bool recording_enabled () const noexcept override { return recording_; }
  units::sample_t recording_preroll_frames_remaining () const noexcept override
  {
    return recording_preroll_frames_remaining_;
  }
  units::sample_t metronome_countin_frames_remaining () const noexcept override
  {
    return countin_frames_remaining_;
  }
 
  // ==================================================================
 
  Q_INVOKABLE bool isRolling () const
  {
    return play_state_ == PlayState::Rolling;
  }
 
  Q_INVOKABLE bool isPaused () const
  {
    return play_state_ == PlayState::Paused;
  }

  void add_to_playhead_in_audio_thread (units::sample_t nframes);
 
  void set_play_state_rt_safe (PlayState state);

   * This is only for moves other than while playing and for looping while
   * playing.
   *
   * Should not be used during exporting.
   *
   * @param target_ticks Position to set to.
   * @param set_cue_point Also set the cue point at this position.
   */
  void move_playhead (units::precise_tick_t target_ticks, bool set_cue_point);

  void goto_prev_or_next_marker (
    bool                                  prev,
    RangeOf<units::precise_tick_t> auto &&extra_markers)
  {
    /* gather all markers */
    std::vector<units::precise_tick_t> marker_ticks;
    static_assert (__cpp_lib_containers_ranges >= 202202L);
    marker_ticks.append_range (extra_markers);
    marker_ticks.emplace_back (cue_position_.get_ticks ());
    marker_ticks.emplace_back (loop_start_position_.get_ticks ());
    marker_ticks.emplace_back (loop_end_position_.get_ticks ());
    marker_ticks.emplace_back ();
    std::ranges::sort (marker_ticks);
 
    if (prev)
      {
        // Iterate backwards through marker_ticks with manual index.
        // Equivalent to (but can't use enumerate yet on AppleClang):
        // marker_ticks | std::views::enumerate | std::views::reverse
        for (size_t i = 0; i < marker_ticks.size (); ++i)
          {
            const auto  index = marker_ticks.size () - 1 - i;
            const auto &marker_tick = marker_ticks[index];
 
            if (marker_tick >= playhead_.position_ticks ())
              continue;
 
            if (
              isRolling () && index > 0
              && (playhead_.get_tempo_map ().tick_to_seconds (
                    playhead_.position_ticks ())
                  - playhead_.get_tempo_map ().tick_to_seconds (marker_tick))
                   < REPEATED_BACKWARD_MS)
              {
                continue;
              }
 
            move_playhead (marker_tick, true);
            break;
          }
      }
    else
      {
        for (auto &marker : marker_ticks)
          {
            if (marker > playhead_.position_ticks ())
              {
                move_playhead (marker, true);
                break;
              }
          }
      }
  }
 
  bool position_is_inside_punch_range (units::sample_t pos);
 
  auto playhead_ticks_before_pause () const [[clang::blocking]]
  {
    return playhead_before_pause_;
  }

   * @brief For engine use only.
   *
   * @param samples Samples to consume.
   */
  void consume_metronome_countin_samples (units::sample_t samples)
  {
    assert (countin_frames_remaining_ >= samples);
    countin_frames_remaining_ -= samples;
  }

  void consume_recording_preroll_samples (units::sample_t samples)
  {
    assert (recording_preroll_frames_remaining_ >= samples);
    recording_preroll_frames_remaining_ -= samples;
  }
 
  auto get_snapshot () const
  {
    return TransportSnapshot{
      get_loop_range_positions (),
      get_punch_range_positions (),
      get_playhead_position_in_audio_thread (),
      recording_preroll_frames_remaining (),
      metronome_countin_frames_remaining (),
      get_play_state (),
      loop_enabled (),
      punch_enabled (),
      recording_enabled ()
    };
  }
 
  friend void init_from (
    Transport             &obj,
    const Transport       &other,
    utils::ObjectCloneType clone_type);
 
private:
  static constexpr auto kPlayheadKey = "playheadPosition"sv;
  static constexpr auto kCuePosKey = "cuePosition"sv;
  static constexpr auto kLoopStartPosKey = "loopStartPosition"sv;
  static constexpr auto kLoopEndPosKey = "loopEndPosition"sv;
  static constexpr auto kPunchInPosKey = "punchInPosition"sv;
  static constexpr auto kPunchOutPosKey = "punchOutPosition"sv;
  friend void           to_json (nlohmann::json &j, const Transport &transport);
  friend void from_json (const nlohmann::json &j, Transport &transport);

  bool can_user_move_playhead () const;
 
private:
  dsp::Playhead                                    playhead_;
  utils::QObjectUniquePtr<dsp::PlayheadQmlWrapper> playhead_adapter_;
 
  std::unique_ptr<dsp::AtomicPosition::TimeConversionFunctions>
    time_conversion_funcs_;

  dsp::AtomicPosition                                    cue_position_;
  utils::QObjectUniquePtr<dsp::AtomicPositionQmlAdapter> cue_position_adapter_;

  dsp::AtomicPosition loop_start_position_;
  utils::QObjectUniquePtr<dsp::AtomicPositionQmlAdapter>
    loop_start_position_adapter_;

  dsp::AtomicPosition loop_end_position_;
  utils::QObjectUniquePtr<dsp::AtomicPositionQmlAdapter>
    loop_end_position_adapter_;

  dsp::AtomicPosition punch_in_position_;
  utils::QObjectUniquePtr<dsp::AtomicPositionQmlAdapter>
    punch_in_position_adapter_;

  dsp::AtomicPosition punch_out_position_;
  utils::QObjectUniquePtr<dsp::AtomicPositionQmlAdapter>
    punch_out_position_adapter_;

  bool loop_{ true };

  bool punch_mode_{ false };

  bool recording_{ false };

  units::sample_t recording_preroll_frames_remaining_;

  units::sample_t countin_frames_remaining_;

  units::precise_tick_t playhead_before_pause_;

  PlayState play_state_{ PlayState::Paused };

  QTimer *          property_notification_timer_ = nullptr;
  std::atomic<bool> needs_property_notification_{ false };
 
  ConfigProvider config_provider_;
};
}