loop_segment_iterator.h

// SPDX-FileCopyrightText: © 2026 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#pragma once
 
#include <concepts>
#include <vector>
 
#include "dsp/tick_types.h"
 
namespace zrythm::structure::arrangement
{

struct LoopSegment
{
  dsp::ContentTick virt_start;
  dsp::ContentTick virt_end;
  dsp::ContentTick abs_start;
  dsp::ContentTick abs_end;
};

template <std::invocable<const LoopSegment &> Func>
void
for_each_loop_segment (
  dsp::ContentTick clip_start,
  dsp::ContentTick loop_start,
  dsp::ContentTick loop_end,
  dsp::ContentTick end_tick,
  Func           &&callback)
{
  const auto loop_length =
    max (dsp::ContentTick{ units::ticks (0.0) }, loop_end - loop_start);
 
  auto virt_start = clip_start;
  auto virt_end = loop_end;
  auto abs_start = dsp::ContentTick{ units::ticks (0.0) };
  auto abs_end = loop_end - clip_start;
 
  // Clamp first leg to end_tick.
  if (abs_end > end_tick)
    {
      const auto diff = abs_end - end_tick;
      virt_end = virt_end - diff;
      abs_end = abs_end - diff;
    }
 
  while (abs_start < end_tick)
    {
      if (abs_end <= abs_start)
        break;
 
      callback (LoopSegment{ virt_start, virt_end, abs_start, abs_end });
 
      const auto current_len = abs_end - abs_start;
      if (current_len <= dsp::ContentTick{})
        break;
 
      // Subsequent legs use the loop region.
      virt_start = loop_start;
      virt_end = loop_end;
      abs_start = abs_start + current_len;
      abs_end = abs_end + loop_length;
 
      if (abs_end > end_tick)
        {
          const auto diff = abs_end - end_tick;
          virt_end = virt_end - diff;
          abs_end = abs_end - diff;
        }
    }
}

template <typename WarpLookup>
std::vector<dsp::TimelineTick>
compute_loop_boundary_deltas (
  WarpLookup      &&warp_lookup,
  dsp::ContentTick  clip_start_ct,
  dsp::ContentTick  loop_start_ct,
  dsp::ContentTick  loop_end_ct,
  dsp::TimelineTick max_delta_ticks,
  int               max_iterations = 1000)
{
  std::vector<dsp::TimelineTick> result;
 
  const auto loop_length =
    max (dsp::ContentTick{ units::ticks (0.0) }, loop_end_ct - loop_start_ct);
  if (loop_length <= dsp::ContentTick{})
    return result;
 
  auto cumulative = loop_end_ct - clip_start_ct;
 
  for (int i = 0; i < max_iterations; ++i)
    {
      const auto delta = warp_lookup (cumulative);
      if (delta >= max_delta_ticks)
        break;
      result.push_back (delta);
      cumulative = cumulative + loop_length;
    }
 
  return result;
}
 
} // namespace zrythm::structure::arrangement