clip_renderer.h

// SPDX-FileCopyrightText: © 2025 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#pragma once
 
#include "dsp/tick_types.h"
#include "structure/arrangement/arranger_object_all.h"
#include "structure/arrangement/loop_segment_iterator.h"
#include "utils/audio.h"
#include "utils/units.h"
 
#include <juce_audio_basics/juce_audio_basics.h>
 
namespace zrythm::structure::arrangement
{

class ClipRenderer final
{
public:
  using TimelineRange = std::pair<dsp::TimelineTick, dsp::TimelineTick>;

  static void serialize_to_sequence (
    const MidiClip              &clip,
    juce::MidiMessageSequence   &events,
    std::optional<TimelineRange> timeline_range_ticks = std::nullopt);

  static void serialize_to_sequence (
    const ChordClip             &clip,
    juce::MidiMessageSequence   &events,
    std::optional<TimelineRange> timeline_range_ticks = std::nullopt);

  static void serialize_to_buffer (
    const AudioClip             &clip,
    juce::AudioSampleBuffer     &buffer,
    std::optional<TimelineRange> timeline_range_ticks = std::nullopt);

  struct RenderedAutomationPoint
  {
    dsp::TimelineTick            position;
    float                        value;
    dsp::CurveOptions::Algorithm curve_algo;
    float                        curve_curviness;

    dsp::TimelineTick curve_origin_start;
    dsp::TimelineTick curve_origin_end;
    float             curve_origin_value_a;
    float             curve_origin_value_b;
  };

  static void serialize_to_points (
    const AutomationClip                 &clip,
    std::vector<RenderedAutomationPoint> &points,
    std::optional<TimelineRange>          timeline_range_ticks = std::nullopt)
    [[clang::blocking]];
 
private:
  struct LoopParameters
  {
    dsp::ContentTick loop_start;
    dsp::ContentTick loop_end;
    dsp::ContentTick clip_start;
    dsp::ContentTick loop_length;
    dsp::ContentTick clip_length;
    int              num_loops;
 
    LoopParameters (const Clip &clip);
  };
 
  template <ClipObject ClipT, typename EventsT>
  static void serialize_clip (
    const ClipT &clip,
    EventsT     &events,
    // currently unused
    std::optional<TimelineRange> timeline_range_ticks = std::nullopt)
  {
    const auto clip_length = clip.length ()->asTick ();
 
    for_each_loop_segment (
      clip.clipStartPosition ()->asTick (),
      clip.loopStartPosition ()->asTick (), clip.loopEndPosition ()->asTick (),
      clip_length, [&] (const LoopSegment &segment) {
        if constexpr (std::is_same_v<ClipT, MidiClip>)
          handle_midi_clip_range (clip, events, segment);
        else if constexpr (std::is_same_v<ClipT, ChordClip>)
          handle_chord_clip_range (clip, events, segment);
        else if constexpr (std::is_same_v<ClipT, AutomationClip>)
          handle_automation_clip_range (clip, events, segment);
      });
  }
 
  static void handle_midi_clip_range (
    const MidiClip            &clip,
    juce::MidiMessageSequence &events,
    const LoopSegment         &segment);
 
  static void handle_chord_clip_range (
    const ChordClip           &clip,
    juce::MidiMessageSequence &events,
    const LoopSegment         &segment);
 
  static void handle_automation_clip_range (
    const AutomationClip                 &clip,
    std::vector<RenderedAutomationPoint> &points,
    const LoopSegment                    &segment);

  static utils::audio::AudioBuffer build_native_looped_buffer (
    const AudioClip &clip,
    units::sample_t  out_start,
    units::sample_t  out_end);

  static void
  apply_gain_pass (const AudioClip &clip, juce::AudioSampleBuffer &buffer);

  static void
  apply_clip_fades_pass (const AudioClip &clip, juce::AudioSampleBuffer &buffer);

  static void apply_builtin_fades_pass (
    const AudioClip         &clip,
    juce::AudioSampleBuffer &buffer,
    int                      builtin_fade_frames);
};
 
} // namespace zrythm::structure::arrangement