clip_playback_data_provider.h

// SPDX-FileCopyrightText: © 2025 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#pragma once
 
#include <atomic>
 
#include "structure/tracks/track_fwd.h"
#include "utils/types.h"
 
#include <farbot/RealtimeObject.hpp>
#include <juce_wrapper.h>
 
namespace zrythm::structure::tracks
{

class ClipPlaybackDataProvider final
{
  struct MidiCache
  {
    MidiCache (
      juce::MidiMessageSequence           &&midi_seq,
      structure::tracks::ClipQuantizeOption quantize_opt,
      units::precise_tick_t                 end_position)
        : midi_seq_ (std::move (midi_seq)), quantize_opt_ (quantize_opt),
          end_position_ (end_position)
    {
    }
    juce::MidiMessageSequence             midi_seq_;
    structure::tracks::ClipQuantizeOption quantize_opt_;

    units::precise_tick_t end_position_;
  };
 
  struct AudioCache
  {
    AudioCache (
      juce::AudioSampleBuffer               audio_buffer,
      structure::tracks::ClipQuantizeOption quantize_opt,
      units::precise_tick_t                 end_position)
        : audio_buffer_ (std::move (audio_buffer)),
          quantize_opt_ (quantize_opt), end_position_ (end_position)
    {
    }
 
    juce::AudioSampleBuffer               audio_buffer_;
    structure::tracks::ClipQuantizeOption quantize_opt_;

    units::precise_tick_t end_position_;
  };
 
public:
  ClipPlaybackDataProvider (const dsp::TempoMap &tempo_map);

  void generate_midi_events (
    const arrangement::MidiRegion        &midi_region,
    structure::tracks::ClipQuantizeOption quantize_option);

  void generate_audio_events (
    const arrangement::AudioRegion       &audio_region,
    structure::tracks::ClipQuantizeOption quantize_option);

  void
  queue_stop_playback (structure::tracks::ClipQuantizeOption quantize_option);
 
  // TrackEventProvider interface
  void process_midi_events (
    const EngineProcessTimeInfo &time_nfo,
    dsp::MidiEventVector        &output_buffer) noexcept [[clang::nonblocking]];

  void process_audio_events (
    const EngineProcessTimeInfo &time_nfo,
    std::span<float>             left_buffer,
    std::span<float>             right_buffer) noexcept [[clang::nonblocking]];

  auto playing () const { return playing_.load (); }
 
  auto current_playback_position_in_clip () const
  {
    return internal_clip_buffer_position_.load ();
  }
 
private:
  void update_playback_position (
    const EngineProcessTimeInfo &time_nfo,
    units::sample_t              clip_loop_end_samples);

  std::pair<units::sample_t, units::sample_t> handle_quantization_and_start (
    const EngineProcessTimeInfo          &time_nfo,
    units::sample_t                       clip_loop_end_samples,
    structure::tracks::ClipQuantizeOption quantize_opt);

  template <typename ProcessFunc>
  void process_chunks_with_looping (
    units::sample_t internal_buffer_start_offset,
    units::sample_t samples_to_process,
    units::sample_t clip_loop_end_samples,
    units::sample_t output_buffer_timestamp_offset,
    ProcessFunc     process_chunk);

  void clear_active_buffers ();
 
private:
  farbot::RealtimeObject<
    std::optional<MidiCache>,
    farbot::RealtimeObjectOptions::nonRealtimeMutatable>
    active_midi_playback_sequence_;

  farbot::RealtimeObject<
    std::optional<AudioCache>,
    farbot::RealtimeObjectOptions::nonRealtimeMutatable>
    active_audio_playback_buffer_;
 
  const dsp::TempoMap &tempo_map_;

  std::atomic<bool> playing_{ false };

  bool was_playing_{ false };

  std::atomic<units::sample_t> internal_clip_buffer_position_;

  units::sample_t last_seen_timeline_position_;

  units::sample_t clip_launch_timeline_position_;
 
  static_assert (decltype (internal_clip_buffer_position_)::is_always_lock_free);
};
 
}