SkShaderBlurAlgorithm Class Reference

#include <SkBlurEngine.h>

Inheritance diagram for SkShaderBlurAlgorithm:

Public Member Functions
float	maxSigma () const override
bool	supportsOnlyDecalTiling () const override
sk_sp< SkSpecialImage >	blur (SkSize sigma, sk_sp< SkSpecialImage > src, const SkIRect &srcRect, SkTileMode tileMode, const SkIRect &dstRect) const override
Public Member Functions inherited from SkBlurEngine::Algorithm
virtual	~Algorithm ()=default
virtual float	maxSigma () const =0
virtual bool	supportsOnlyDecalTiling () const =0
virtual sk_sp< SkSpecialImage >	blur (SkSize sigma, sk_sp< SkSpecialImage > src, const SkIRect &srcRect, SkTileMode tileMode, const SkIRect &dstRect) const =0

Static Public Member Functions
static constexpr int	KernelWidth (int radius)
static constexpr int	LinearKernelWidth (int radius)
static const SkRuntimeEffect *	GetBlur2DEffect (const SkISize &radii)
static const SkRuntimeEffect *	GetLinearBlur1DEffect (int radius)
static void	Compute2DBlurKernel (SkSize sigma, SkISize radius, SkSpan< float > kernel)
static void	Compute2DBlurKernel (SkSize sigma, SkISize radius, std::array< SkV4, kMaxSamples/4 > &kernel)
static void	Compute1DBlurKernel (float sigma, int radius, SkSpan< float > kernel)
static void	Compute2DBlurOffsets (SkISize radius, std::array< SkV4, kMaxSamples/2 > &offsets)
static void	Compute1DBlurLinearKernel (float sigma, int radius, std::array< SkV4, kMaxSamples/2 > &offsetsAndKernel)

Static Public Attributes
static constexpr int	kMaxSamples = 28
static constexpr float	kMaxLinearSigma = 4.f

Private Member Functions
virtual sk_sp< SkDevice >	makeDevice (const SkImageInfo &) const =0

Detailed Description

The default blur implementation uses internal runtime effects to evaluate either a single 2D kernel within a shader, or performs two 1D blur passes. This algorithm is backend agnostic but must be subclassed per backend to define the SkDevice creation function.

Definition at line 112 of file SkBlurEngine.h.

Member Function Documentation

blur()

sk_sp< SkSpecialImage > SkShaderBlurAlgorithm::blur ( SkSize  sigma, sk_sp< SkSpecialImage >  src, const SkIRect &  srcRect, SkTileMode  tileMode, const SkIRect &  dstRect  ) const

overridevirtual

Implements SkBlurEngine::Algorithm.

Definition at line 383 of file SkBlurEngine.cpp.

                                                                                {
    SkASSERT(sigma.width() <= kMaxLinearSigma &&  sigma.height() <= kMaxLinearSigma);
 
    int radiusX = SkBlurEngine::SigmaToRadius(sigma.width());
    int radiusY = SkBlurEngine::SigmaToRadius(sigma.height());
    const int kernelArea = KernelWidth(radiusX) * KernelWidth(radiusY);
    if (kernelArea <= kMaxSamples && radiusX > 0 && radiusY > 0) {
        // Use a single-pass 2D kernel if it fits and isn't just 1D already
        return this->evalBlur2D(sigma,
                                {radiusX, radiusY},
                                std::move(src),
                                srcRect,
                                tileMode,
                                dstRect);
    } else {
        // Use two passes of a 1D kernel (one per axis).
        SkIRect intermediateSrcRect = srcRect;
        SkIRect intermediateDstRect = dstRect;
        if (radiusX > 0) {
            if (radiusY > 0) {
                // May need to maintain extra rows above and below 'dstRect' for the follow-up pass.
                if (tileMode == SkTileMode::kRepeat || tileMode == SkTileMode::kMirror) {
                    // If the srcRect and dstRect are aligned, then we don't need extra rows since
                    // the periodic tiling on srcRect is the same for the intermediate. If they
                    // are not aligned, then outset by the Y radius.
                    const int period = srcRect.height() * (tileMode == SkTileMode::kMirror ? 2 : 1);
                    if (std::abs(dstRect.fTop - srcRect.fTop) % period != 0 ||
                        dstRect.height() != srcRect.height()) {
                        intermediateDstRect.outset(0, radiusY);
                    }
                } else {
                    // For clamp and decal tiling, we outset by the Y radius up to what's available
                    // from the srcRect. Anything beyond that is identical to tiling the
                    // intermediate dst image directly.
                    intermediateDstRect.outset(0, radiusY);
                    intermediateDstRect.fTop = std::max(intermediateDstRect.fTop, srcRect.fTop);
                    intermediateDstRect.fBottom =
                            std::min(intermediateDstRect.fBottom, srcRect.fBottom);
                    if (intermediateDstRect.fTop >= intermediateDstRect.fBottom) {
                        return nullptr;
                    }
                }
            }
 
            src = this->evalBlur1D(sigma.width(),
                                   radiusX,
                                   /*dir=*/{1.f, 0.f},
                                   std::move(src),
                                   srcRect,
                                   tileMode,
                                   intermediateDstRect);
            if (!src) {
                return nullptr;
            }
            intermediateSrcRect = SkIRect::MakeWH(src->width(), src->height());
            intermediateDstRect = dstRect.makeOffset(-intermediateDstRect.left(),
                                                     -intermediateDstRect.top());
        }
 
        if (radiusY > 0) {
            src = this->evalBlur1D(sigma.height(),
                                   radiusY,
                                   /*dir=*/{0.f, 1.f},
                                   std::move(src),
                                   intermediateSrcRect,
                                   tileMode,
                                   intermediateDstRect);
        }
 
        return src;
    }
}

Compute1DBlurKernel()

static void SkShaderBlurAlgorithm::Compute1DBlurKernel ( float  sigma, int  radius, SkSpan< float >  kernel  )

inlinestatic

Definition at line 235 of file SkBlurEngine.h.

                                                                                    {
        Compute2DBlurKernel(SkSize{sigma, 0.f}, SkISize{radius, 0}, kernel);
    }

Compute1DBlurLinearKernel()

void SkShaderBlurAlgorithm::Compute1DBlurLinearKernel ( float  sigma, int  radius, std::array< SkV4, kMaxSamples/2 > &  offsetsAndKernel  )

static

Definition at line 118 of file SkBlurEngine.cpp.

                                                         {
    SkASSERT(sigma <= kMaxLinearSigma);
    SkASSERT(radius == SkBlurEngine::SigmaToRadius(sigma));
    SkASSERT(LinearKernelWidth(radius) <= kMaxSamples);
 
    // Given 2 adjacent gaussian points, they are blended as: Wi * Ci + Wj * Cj.
    // The GPU will mix Ci and Cj as Ci * (1 - x) + Cj * x during sampling.
    // Compute W', x such that W' * (Ci * (1 - x) + Cj * x) = Wi * Ci + Wj * Cj.
    // Solving W' * x = Wj, W' * (1 - x) = Wi:
    // W' = Wi + Wj
    // x = Wj / (Wi + Wj)
    auto get_new_weight = [](float* new_w, float* offset, float wi, float wj) {
        *new_w = wi + wj;
        *offset = wj / (wi + wj);
    };
 
    // Create a temporary standard kernel. The maximum blur radius that can be passed to this
    // function is (kMaxBlurSamples-1), so make an array large enough to hold the full kernel width.
    static constexpr int kMaxKernelWidth = KernelWidth(kMaxSamples - 1);
    SkASSERT(KernelWidth(radius) <= kMaxKernelWidth);
    std::array<float, kMaxKernelWidth> fullKernel;
    Compute1DBlurKernel(sigma, radius, SkSpan<float>{fullKernel.data(), KernelWidth(radius)});
 
    std::array<float, kMaxSamples> kernel;
    std::array<float, kMaxSamples> offsets;
    // Note that halfsize isn't just size / 2, but radius + 1. This is the size of the output array.
    int halfSize = LinearKernelWidth(radius);
    int halfRadius = halfSize / 2;
    int lowIndex = halfRadius - 1;
 
    // Compute1DGaussianKernel produces a full 2N + 1 kernel. Since the kernel can be mirrored,
    // compute only the upper half and mirror to the lower half.
 
    int index = radius;
    if (radius & 1) {
        // If N is odd, then use two samples.
        // The centre texel gets sampled twice, so halve its influence for each sample.
        // We essentially sample like this:
        // Texel edges
        // v    v    v    v
        // |    |    |    |
        // \-----^---/ Lower sample
        //      \---^-----/ Upper sample
        get_new_weight(&kernel[halfRadius],
                       &offsets[halfRadius],
                       fullKernel[index] * 0.5f,
                       fullKernel[index + 1]);
        kernel[lowIndex] = kernel[halfRadius];
        offsets[lowIndex] = -offsets[halfRadius];
        index++;
        lowIndex--;
    } else {
        // If N is even, then there are an even number of texels on either side of the centre texel.
        // Sample the centre texel directly.
        kernel[halfRadius] = fullKernel[index];
        offsets[halfRadius] = 0.0f;
    }
    index++;
 
    // Every other pair gets one sample.
    for (int i = halfRadius + 1; i < halfSize; index += 2, i++, lowIndex--) {
        get_new_weight(&kernel[i], &offsets[i], fullKernel[index], fullKernel[index + 1]);
        offsets[i] += static_cast<float>(index - radius);
 
        // Mirror to lower half.
        kernel[lowIndex] = kernel[i];
        offsets[lowIndex] = -offsets[i];
    }
 
    // Zero out remaining values in the kernel
    memset(kernel.data() + halfSize, 0, sizeof(float)*(kMaxSamples - halfSize));
    // But copy the last valid offset into the remaining offsets, to increase the chance that
    // over-iteration in a fragment shader will have a cache hit.
    for (int i = halfSize; i < kMaxSamples; ++i) {
        offsets[i] = offsets[halfSize - 1];
    }
 
    // Interleave into the output array to match the 1D SkSL effect
    for (int i = 0; i < kMaxSamples / 2; ++i) {
        offsetsAndKernel[i] = SkV4{offsets[2*i], kernel[2*i], offsets[2*i+1], kernel[2*i+1]};
    }
}

Compute2DBlurKernel() [1/2]

void SkShaderBlurAlgorithm::Compute2DBlurKernel ( SkSize  sigma, SkISize  radius, SkSpan< float >  kernel  )

static

Definition at line 37 of file SkBlurEngine.cpp.

                                                                      {
    // Callers likely had to calculate the radius prior to filling out the kernel value, which is
    // why it's provided; but make sure it's consistent with expectations.
    SkASSERT(SkBlurEngine::SigmaToRadius(sigma.width()) == radius.width() &&
             SkBlurEngine::SigmaToRadius(sigma.height()) == radius.height());
 
    // Callers are responsible for downscaling large sigmas to values that can be processed by the
    // effects, so ensure the radius won't overflow 'kernel'
    const int width = KernelWidth(radius.width());
    const int height = KernelWidth(radius.height());
    const size_t kernelSize = SkTo<size_t>(sk_64_mul(width, height));
    SkASSERT(kernelSize <= kernel.size());
 
    // And the definition of an identity blur should be sufficient that 2sigma^2 isn't near zero
    // when there's a non-trivial radius.
    const float twoSigmaSqrdX = 2.0f * sigma.width() * sigma.width();
    const float twoSigmaSqrdY = 2.0f * sigma.height() * sigma.height();
    SkASSERT((radius.width() == 0 || !SkScalarNearlyZero(twoSigmaSqrdX)) &&
             (radius.height() == 0 || !SkScalarNearlyZero(twoSigmaSqrdY)));
 
    // Setting the denominator to 1 when the radius is 0 automatically converts the remaining math
    // to the 1D Gaussian distribution. When both radii are 0, it correctly computes a weight of 1.0
    const float sigmaXDenom = radius.width() > 0 ? 1.0f / twoSigmaSqrdX : 1.f;
    const float sigmaYDenom = radius.height() > 0 ? 1.0f / twoSigmaSqrdY : 1.f;
 
    float sum = 0.0f;
    for (int x = 0; x < width; x++) {
        float xTerm = static_cast<float>(x - radius.width());
        xTerm = xTerm * xTerm * sigmaXDenom;
        for (int y = 0; y < height; y++) {
            float yTerm = static_cast<float>(y - radius.height());
            float xyTerm = std::exp(-(xTerm + yTerm * yTerm * sigmaYDenom));
            // Note that the constant term (1/(sqrt(2*pi*sigma^2)) of the Gaussian
            // is dropped here, since we renormalize the kernel below.
            kernel[y * width + x] = xyTerm;
            sum += xyTerm;
        }
    }
    // Normalize the kernel
    float scale = 1.0f / sum;
    for (size_t i = 0; i < kernelSize; ++i) {
        kernel[i] *= scale;
    }
    // Zero remainder of the array
    memset(kernel.data() + kernelSize, 0, sizeof(float)*(kernel.size() - kernelSize));
}

Compute2DBlurKernel() [2/2]

void SkShaderBlurAlgorithm::Compute2DBlurKernel ( SkSize  sigma, SkISize  radius, std::array< SkV4, kMaxSamples/4 > &  kernel  )

static

Definition at line 86 of file SkBlurEngine.cpp.

                                                                                       {
    static_assert(sizeof(kernel) == sizeof(std::array<float, kMaxSamples>));
    static_assert(alignof(float) == alignof(SkV4));
    float* data = kernel[0].ptr();
    Compute2DBlurKernel(sigma, radii, SkSpan<float>(data, kMaxSamples));
}

Compute2DBlurOffsets()

void SkShaderBlurAlgorithm::Compute2DBlurOffsets ( SkISize  radius, std::array< SkV4, kMaxSamples/2 > &  offsets  )

static

Definition at line 95 of file SkBlurEngine.cpp.

                                                                                         {
    const int kernelArea = KernelWidth(radius.width()) * KernelWidth(radius.height());
    SkASSERT(kernelArea <= kMaxSamples);
 
    SkSpan<float> offsetView{offsets[0].ptr(), kMaxSamples*2};
 
    int i = 0;
    for (int y = -radius.height(); y <= radius.height(); ++y) {
        for (int x = -radius.width(); x <= radius.width(); ++x) {
            offsetView[2*i]   = x;
            offsetView[2*i+1] = y;
            ++i;
        }
    }
    SkASSERT(i == kernelArea);
    const int lastValidOffset = 2*(kernelArea - 1);
    for (; i < kMaxSamples; ++i) {
        offsetView[2*i]   = offsetView[lastValidOffset];
        offsetView[2*i+1] = offsetView[lastValidOffset+1];
    }
}

GetBlur2DEffect()

const SkRuntimeEffect * SkShaderBlurAlgorithm::GetBlur2DEffect ( const SkISize &  radii )

static

Definition at line 247 of file SkBlurEngine.cpp.

                                                                                  {
    int kernelArea = KernelWidth(radii.width()) * KernelWidth(radii.height());
    return GetKnownRuntimeEffect(
            to_stablekey(kernelArea,
                         static_cast<uint32_t>(SkKnownRuntimeEffects::StableKey::k2DBlurBase)));
}

GetLinearBlur1DEffect()

const SkRuntimeEffect * SkShaderBlurAlgorithm::GetLinearBlur1DEffect ( int  radius )

static

Definition at line 241 of file SkBlurEngine.cpp.

                                                                              {
    return GetKnownRuntimeEffect(
            to_stablekey(LinearKernelWidth(radius),
                         static_cast<uint32_t>(SkKnownRuntimeEffects::StableKey::k1DBlurBase)));
}

KernelWidth()

static constexpr int SkShaderBlurAlgorithm::KernelWidth ( int  radius )

inlinestaticconstexpr

Definition at line 154 of file SkBlurEngine.h.

{ return 2 * radius + 1; }

LinearKernelWidth()

static constexpr int SkShaderBlurAlgorithm::LinearKernelWidth ( int  radius )

inlinestaticconstexpr

Definition at line 158 of file SkBlurEngine.h.

{ return radius + 1; }

makeDevice()

virtual sk_sp< SkDevice > SkShaderBlurAlgorithm::makeDevice ( const SkImageInfo &  ) const

privatepure virtual

maxSigma()

float SkShaderBlurAlgorithm::maxSigma ( ) const

inlineoverridevirtual

Implements SkBlurEngine::Algorithm.

Definition at line 114 of file SkBlurEngine.h.

{ return kMaxLinearSigma; }

supportsOnlyDecalTiling()

bool SkShaderBlurAlgorithm::supportsOnlyDecalTiling ( ) const

inlineoverridevirtual

Implements SkBlurEngine::Algorithm.

Definition at line 115 of file SkBlurEngine.h.

{ return false; }

Member Data Documentation

kMaxLinearSigma

constexpr float SkShaderBlurAlgorithm::kMaxLinearSigma = 4.f

staticconstexpr

Definition at line 172 of file SkBlurEngine.h.

kMaxSamples

constexpr int SkShaderBlurAlgorithm::kMaxSamples = 28

staticconstexpr

Definition at line 166 of file SkBlurEngine.h.

---

The documentation for this class was generated from the following files:

• third_party/skia/src/core/SkBlurEngine.h
• third_party/skia/src/core/SkBlurEngine.cpp