SkMatrixConvolutionImageFilter.cpp File Reference

#include "include/effects/SkImageFilters.h"
#include "include/core/SkAlphaType.h"
#include "include/core/SkBitmap.h"
#include "include/core/SkColorType.h"
#include "include/core/SkFlattenable.h"
#include "include/core/SkImage.h"
#include "include/core/SkImageFilter.h"
#include "include/core/SkImageInfo.h"
#include "include/core/SkM44.h"
#include "include/core/SkPoint.h"
#include "include/core/SkRect.h"
#include "include/core/SkRefCnt.h"
#include "include/core/SkSamplingOptions.h"
#include "include/core/SkScalar.h"
#include "include/core/SkShader.h"
#include "include/core/SkSize.h"
#include "include/core/SkString.h"
#include "include/core/SkTileMode.h"
#include "include/core/SkTypes.h"
#include "include/effects/SkRuntimeEffect.h"
#include "include/private/base/SkMath.h"
#include "include/private/base/SkMutex.h"
#include "include/private/base/SkSpan_impl.h"
#include "include/private/base/SkTArray.h"
#include "include/private/base/SkTemplates.h"
#include "include/private/base/SkThreadAnnotations.h"
#include "src/base/SkMathPriv.h"
#include "src/base/SkSafeMath.h"
#include "src/core/SkImageFilterTypes.h"
#include "src/core/SkImageFilter_Base.h"
#include "src/core/SkLRUCache.h"
#include "src/core/SkPicturePriv.h"
#include "src/core/SkReadBuffer.h"
#include "src/core/SkRectPriv.h"
#include "src/core/SkRuntimeEffectPriv.h"
#include "src/core/SkWriteBuffer.h"
#include <cstdint>
#include <cstring>
#include <optional>
#include <utility>

Go to the source code of this file.

Functions
void	SkRegisterMatrixConvolutionImageFilterFlattenable ()
static sk_sp< SkRuntimeEffect >	get_runtime_effect (int texWidth, int texHeight)

Function Documentation

get_runtime_effect()

static sk_sp< SkRuntimeEffect > get_runtime_effect ( int  texWidth, int  texHeight  )

static

Definition at line 355 of file SkMatrixConvolutionImageFilter.cpp.

                                                                              {
    // While the loop structure and uniforms are different, pieces of the algorithm are common and
    // defined statically for re-use in the two shaders:
    static const char* kHeaderSkSL =
        "uniform int2 size;"
        "uniform int2 offset;"
        "uniform half2 gainAndBias;"
        "uniform int convolveAlpha;" // FIXME not a full  int?
 
        "uniform shader child;"
 
        "half4 main(float2 coord) {"
            "half4 sum = half4(0);"
            "half origAlpha = 0;";
 
    // Used in the inner loop to accumulate convolution sum
    static const char* kAccumulateSkSL =
                "half4 c = child.eval(coord + half2(kernelPos) - half2(offset));"
                "if (convolveAlpha == 0) {"
                    // When not convolving alpha, remember the original alpha for actual sample
                    // coord, and perform accumulation on unpremul colors.
                    "if (kernelPos == offset) {"
                        "origAlpha = c.a;"
                    "}"
                    "c = unpremul(c);"
                "}"
                "sum += c*k;";
 
    // Used after the loop to calculate final color
    static const char* kFooterSkSL =
            "half4 color = sum*gainAndBias.x + gainAndBias.y;"
            "if (convolveAlpha == 0) {"
                // Reset the alpha to the original and convert to premul RGB
                "color = half4(color.rgb*origAlpha, origAlpha);"
            "} else {"
                // Ensure convolved alpha is within [0, 1]
                "color.a = saturate(color.a);"
            "}"
            // Make RGB valid premul w/ respect to the alpha (either original or convolved)
            "color.rgb = clamp(color.rgb, 0, color.a);"
            "return color;"
        "}";
 
    // The uniform array storing the kernel is packed into half4's so that we don't waste space
    // forcing array elements out to 16-byte alignment when using std140.
    static_assert(kMaxUniformKernelSize % 4 == 0, "Must be a multiple of 4");
    static SkRuntimeEffect* uniformEffect = SkMakeRuntimeEffect(SkRuntimeEffect::MakeForShader,
        SkStringPrintf("const int kMaxUniformKernelSize = %d / 4;"
                       "uniform half4 kernel[kMaxUniformKernelSize];"
                       "%s" // kHeaderSkSL
                            "int2 kernelPos = int2(0);"
                            "for (int i = 0; i < kMaxUniformKernelSize; ++i) {"
                                "if (kernelPos.y >= size.y) { break; }"
 
                                "half4 k4 = kernel[i];"
                                "for (int j = 0; j < 4; ++j) {"
                                    "if (kernelPos.y >= size.y) { break; }"
                                    "half k = k4[j];"
                                    "%s" // kAccumulateSkSL
 
                                    // The 1D index has to be "constant", so reconstruct 2D coords
                                    // instead of a more conventional double for-loop and i=y*w+x
                                    "kernelPos.x += 1;"
                                    "if (kernelPos.x >= size.x) {"
                                        "kernelPos.x = 0;"
                                        "kernelPos.y += 1;"
                                    "}"
                                "}"
                            "}"
                        "%s", // kFooterSkSL
                        kMaxUniformKernelSize, kHeaderSkSL, kAccumulateSkSL, kFooterSkSL).c_str());
 
    // The texture-backed kernel creates shaders with quantized upper bounds on the kernel size and
    // then stored in a thread-safe LRU cache.
    static SkMutex cacheLock;
    static SkLRUCache<SkISize, sk_sp<SkRuntimeEffect>>
            textureShaderCache SK_GUARDED_BY(cacheLock) {/*maxCount=*/5};
    static const auto makeTextureEffect = [](SkISize maxKernelSize) {
        return SkMakeRuntimeEffect(SkRuntimeEffect::MakeForShader,
            SkStringPrintf("const int kMaxKernelWidth = %d;"
                           "const int kMaxKernelHeight = %d;"
                           "uniform shader kernel;"
                           "uniform half2 innerGainAndBias;"
                           "%s" // kHeaderSkSL
                                   "for (int y = 0; y < kMaxKernelHeight; ++y) {"
                                       "if (y >= size.y) { break; }"
                                       "for (int x = 0; x < kMaxKernelWidth; ++x) {"
                                           "if (x >= size.x) { break; }"
 
                                           "int2 kernelPos = int2(x,y);"
                                           "half k = kernel.eval(half2(kernelPos) + 0.5).a;"
                                           "k = k * innerGainAndBias.x + innerGainAndBias.y;"
                                           "%s" // kAccumulateSkSL
                                       "}"
                                   "}"
                               "%s", // kFooterSkSL
                               maxKernelSize.fWidth, maxKernelSize.fHeight,
                               kHeaderSkSL, kAccumulateSkSL, kFooterSkSL).c_str());
    };
 
 
    if (texWidth == 0 && texHeight == 0) {
        return sk_ref_sp(uniformEffect);
    } else {
        static_assert(kMaxKernelSize % 4 == 0, "Must be a multiple of 4");
        SkASSERT(SkSafeMath::Mul(texWidth, texHeight) <= kMaxKernelSize);
        const SkISize key = {SkNextPow2(texWidth), SkNextPow2(texHeight)};
 
        SkAutoMutexExclusive acquire{cacheLock};
        sk_sp<SkRuntimeEffect>* effect = textureShaderCache.find(key);
        if (!effect) {
            // Adopt the raw pointer returned by makeTextureEffect so that it will be deleted if
            // it's removed from the LRU cache.
            sk_sp<SkRuntimeEffect> newEffect{makeTextureEffect(key)};
            effect = textureShaderCache.insert(key, std::move(newEffect));
        }
 
        return *effect;
    }
}

SkRegisterMatrixConvolutionImageFilterFlattenable()

void SkRegisterMatrixConvolutionImageFilterFlattenable

(

)

Definition at line 268 of file SkMatrixConvolutionImageFilter.cpp.

                                                         {
    SK_REGISTER_FLATTENABLE(SkMatrixConvolutionImageFilter);
    // TODO (michaelludwig) - Remove after grace period for SKPs to stop using old name
    SkFlattenable::Register("SkMatrixConvolutionImageFilterImpl",
                            SkMatrixConvolutionImageFilter::CreateProc);
}