waveform_canvas_renderer.h

// SPDX-FileCopyrightText: © 2026 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#pragma once
 
#include <functional>
#include <vector>
 
#include "dsp/tempo_map.h"
#include "dsp/tick_types.h"
 
#include <QColor>
#include <QtCanvasPainter/qcanvaspainter.h>
#include <QtCanvasPainter/qcanvaspainteritemrenderer.h>
 
#include <juce_audio_basics/juce_audio_basics.h>
 
namespace zrythm::gui::qquick
{
 
class WaveformCanvasItem;

struct WaveformPeak
{
  float min;
  float max;
};

std::vector<int64_t>
compute_frame_mapping (
  int                             canvas_width,
  qreal                           reference_width,
  qreal                           reference_x,
  std::function<int64_t (double)> content_fraction_to_frame);

std::vector<int64_t>
compute_linear_frame_mapping (
  int     canvas_width,
  qreal   reference_width,
  qreal   reference_x,
  int64_t total_frames);

std::vector<int64_t>
compute_timeline_frame_mapping (
  int                  canvas_width,
  qreal                reference_width,
  qreal                reference_x,
  const dsp::TempoMap &tempo_map,
  dsp::TimelineTick    clip_start_tick,
  double               timeline_tick_duration);

std::vector<std::vector<WaveformPeak>>
compute_waveform_peaks (
  const juce::AudioSampleBuffer &buffer,
  const std::vector<int64_t>    &pixel_frames,
  int                            canvas_width,
  int64_t                        loop_wrap_start,
  int64_t                        loop_wrap_length,
  bool                           has_loop);

class WaveformCanvasRenderer : public QCanvasPainterItemRenderer
{
public:
  WaveformCanvasRenderer () = default;
  Q_DISABLE_COPY_MOVE (WaveformCanvasRenderer)
 
  void synchronize (QCanvasPainterItem * item) override;
  void paint (QCanvasPainter * painter) override;
 
private:
  void compute_peaks ();
 
  // Cached visual state from the item
  QColor waveform_color_;
  QColor outline_color_;
  float  canvas_width_ = 0.0f;
  float  canvas_height_ = 0.0f;
 
  // Content density decoupling (from ClipCanvasItemBase)
  qreal reference_width_ = 0;
  qreal reference_x_ = 0;
 
  // Loop wrapping (from AudioClipWaveformCanvasItem)
  bool    has_loop_ = false;
  int64_t loop_wrap_start_ = 0;  // where loop region begins in buffer
  int64_t loop_wrap_length_ = 0; // length of one loop iteration in buffer
 
  // Cached pointer to the item's serialized audio buffer (owned by the item)
  const juce::AudioSampleBuffer * audio_buffer_ = nullptr;
 
  // Precomputed per-pixel frame mapping (size = canvas_width + 1)
  std::vector<int64_t> pixel_frames_;
 
  // Cached peak data
  std::vector<std::vector<WaveformPeak>> peaks_;
  int                                    num_channels_ = 0;
 
  // Change detection
  uint64_t prev_generation_ = 0;
  float    prev_width_ = 0.0f;
  float    prev_height_ = 0.0f;
  qreal    prev_reference_width_ = 0;
  qreal    prev_reference_x_ = 0;
};
 
} // namespace zrythm::gui::qquick