fix(waveform): per-column min/max envelope fill eliminates gaps in steep segments

src/vst/waveform_view.cpp

@@ -3,7 +3,8 @@
 #include "waveform_view.h"
 
 #include <algorithm>
-#include <cstdlib>  // std::abs (int overload)
+#include <cstdlib>   // std::abs (int overload)
+#include <cstddef>   // std::size_t
 
 namespace reasampler::vst {
 
@@ -65,6 +66,35 @@ std::int64_t resolveDragFrame(const Rect& area, std::int64_t frameCount, std::in
     return clampFrame(start + shift, frameCount);
 }
 
+MinMax columnMinMax(const ChannelEnvelope& bins, int innerW, int col) {
+    const int nbins = static_cast<int>(bins.size());
+    if (innerW <= 0 || nbins == 0) return MinMax{};
+
+    // Clamp col to [0, innerW-1].
+    if (col < 0) col = 0;
+    if (col >= innerW) col = innerW - 1;
+
+    // Half-open bin range for this column: [colBinBegin, colBinEnd).
+    // Mirrors computeEnvelope's exact partition (col * nbins / innerW).
+    const int colBinBegin = (col * nbins) / innerW;
+    const int colBinEnd   = ((col + 1) * nbins) / innerW;
+
+    if (colBinBegin >= nbins) return MinMax{};
+
+    // When the column spans no full bins (colBinEnd == colBinBegin), use the
+    // enclosing bin so every pixel column has a non-empty source.
+    const int scanEnd = (colBinEnd > colBinBegin) ? colBinEnd : colBinBegin + 1;
+    const int clampedEnd = (scanEnd <= nbins) ? scanEnd : nbins;
+
+    MinMax result = bins[static_cast<std::size_t>(colBinBegin)];
+    for (int b = colBinBegin + 1; b < clampedEnd; ++b) {
+        const MinMax& mm = bins[static_cast<std::size_t>(b)];
+        if (mm.min < result.min) result.min = mm.min;
+        if (mm.max > result.max) result.max = mm.max;
+    }
+    return result;
+}
+
 std::int64_t nearestZeroCrossing(const AudioSample* pcm, std::int64_t frames,
                                  std::int64_t target) {
     if (pcm == nullptr || frames < 2) return clampFrame(target, frames > 0 ? frames - 1 : 0);

src/vst/waveform_view.h

@@ -68,6 +68,19 @@ int markerAtPoint(const Rect& area, std::int64_t frameCount, const std::int64_t*
 std::int64_t resolveDragFrame(const Rect& area, std::int64_t frameCount, std::int64_t startFrame,
                               int dxPixels);
 
+// The merged min/max envelope for pixel column `col` (0-based, within `innerW` total columns)
+// given a pre-computed per-bin ChannelEnvelope. For each pixel column the function accumulates
+// all bins whose frames project to that column, returning their true min and max — so no bin is
+// silently skipped when `nbins > innerW` (multiple bins per column) and no column is left empty
+// when `nbins < innerW` (a column may span a fractional bin; the enclosing bin is used).
+//
+// The mapping mirrors computeEnvelope's exact half-open partition:
+//   column col owns bins [col*nbins/innerW, (col+1)*nbins/innerW).
+// When that range is empty (a column maps to a bin boundary), the enclosing bin
+// (col*nbins/innerW) fills the column — ensuring no pixel column is left gap-free.
+// `innerW <= 0` or `bins.empty()` returns {0, 0}. `col` is clamped to [0, innerW-1]. Pure.
+MinMax columnMinMax(const ChannelEnvelope& bins, int innerW, int col);
+
 // The nearest zero-crossing frame to `target` in the mono PCM, for the loop/start snap (the
 // S2 zero-crossing-aware requirement). A zero crossing is a frame index i (1 <= i < frames)
 // where the sign of pcm[i-1] and pcm[i] differ (a sample exactly 0 counts as its own crossing