vpass_rowmajor_impl()

template<int R, typename RGB_T, typename acc_t, bool ApplyAlpha, typename AlphaT>

static FL_OPTIMIZE_FUNCTION void fl::gfx::blur_detail::vpass_rowmajor_impl ( RGB_T * pixels, int w, int h, RGB_T * scratch, AlphaT alpha )

static

Definition at line 968 of file blur.cpp.hpp.

             {
    constexpr int shift = 2 * R;
    using P = pixel_ops<RGB_T>;
 
    // Ring buffer: bufs[0..R-1] = saved previous rows, bufs[R] = save slot.
    // Extra zero_row for bottom-boundary padding.
    RGB_T *bufs[5] = {nullptr, nullptr, nullptr, nullptr, nullptr};
    for (int i = 0; i <= R; ++i)
        bufs[i] = scratch + i * w;
    RGB_T *zero_row = scratch + (R + 1) * w;
 
    // Zero all: first R buffers (top-boundary padding) + zero_row.
    FL_BUILTIN_MEMSET(scratch, 0, (R + 2) * w * sizeof(RGB_T));
 
    for (int y = 0; y < h; ++y) {
        RGB_T *out_row = pixels + y * w;
 
        // Save current row before we overwrite it.
        FL_BUILTIN_MEMCPY(bufs[R], out_row, w * sizeof(RGB_T));
 
        // Forward row pointers (rows y+1 .. y+R, or zero_row if OOB).
        const RGB_T *fwd[4] = {zero_row, zero_row, zero_row, zero_row};
        for (int k = 0; k < R; ++k)
            fwd[k] = (y + 1 + k < h) ? (pixels + (y + 1 + k) * w) : zero_row;
 
        // Prefetch the furthest-ahead row needed by the NEXT iteration.
        // At row y, next iteration needs fwd[R-1] = row y+1+R.
        // Prefetching 2 rows ahead gives the memory subsystem time to fetch.
        {
            const int prefetch_y = y + R + 2;
            if (prefetch_y < h) {
                const char *pf = (const char *)(pixels + prefetch_y * w);
                const int row_bytes = w * (int)sizeof(RGB_T);
                for (int off = 0; off < row_bytes; off += 64)
                    __builtin_prefetch(pf + off, 0, 3);
            }
        }
 
        // Process all pixels in this output row.
        // For u8-channel types (CRGB), process as raw byte stream — all
        // channels use the same kernel weights, so we treat the row as a
        // flat u8 array of w*sizeof(RGB_T) bytes. This produces a simpler
        // loop that the compiler can optimize better at low -O levels.
        if (sizeof(typename RGB_T::fp) == 1 && !ApplyAlpha) {
            // Raw byte fast path (CRGB without alpha).
            const int nbytes = w * (int)sizeof(RGB_T);
            u8 *ob = (u8 *)out_row;
 
            simd_vconv_dispatch<R>::apply(bufs, fwd, ob, nbytes);
        } else {
            // Generic path: per-pixel struct access (CRGB16 or alpha case).
            for (int x = 0; x < w; ++x) {
                acc_t r, g, b;
 
                vpass_pixel_kernel<R, RGB_T, acc_t>::apply(bufs, fwd, x, r, g, b);
 
                if (ApplyAlpha) {
                    out_row[x] = P::make(static_cast<acc_t>(r >> shift),
                                         static_cast<acc_t>(g >> shift),
                                         static_cast<acc_t>(b >> shift), alpha);
                } else {
                    out_row[x] = P::make(static_cast<acc_t>(r >> shift),
                                         static_cast<acc_t>(g >> shift),
                                         static_cast<acc_t>(b >> shift));
                }
            }
        }
 
        // Rotate ring buffer: discard oldest, current becomes newest saved.
        RGB_T *recycled = bufs[0];
        for (int i = 0; i < R; ++i) bufs[i] = bufs[i + 1];
        bufs[R] = recycled;
    }
}

References FL_BUILTIN_MEMCPY, FL_BUILTIN_MEMSET, fl::FL_NO_EXCEPT, fl::g, fl::P(), fl::x, and fl::y.

Referenced by vpass_full().

Here is the call graph for this function:

Here is the caller graph for this function: