Add special case circle blur for Ganesh

src/effects/SkBlurMaskFilter.cpp

 
 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBlurMaskFilter.h"
 #include "SkBlurMask.h"
 #include "SkGpuBlurUtils.h"
 #include "SkReadBuffer.h"
 #include "SkWriteBuffer.h"
 #include "SkMaskFilter.h"
 #include "SkRRect.h"
 #include "SkRTConf.h"
 #include "SkStringUtils.h"
 #include "SkStrokeRec.h"
 
 #if SK_SUPPORT_GPU
+#include "GrCircleBlurFragmentProcessor.h"
 #include "GrContext.h"
 #include "GrDrawContext.h"
 #include "GrTexture.h"
 #include "GrFragmentProcessor.h"
 #include "GrInvariantOutput.h"
 #include "SkGrPixelRef.h"
 #include "SkDraw.h"
 #include "effects/GrSimpleTextureEffect.h"
 #include "gl/GrGLFragmentProcessor.h"
 #include "gl/builders/GrGLProgramBuilder.h"
 #endif
 
 SkScalar SkBlurMaskFilter::ConvertRadiusToSigma(SkScalar radius) {
     return SkBlurMask::ConvertRadiusToSigma(radius);
 }
 
 class SkBlurMaskFilterImpl : public SkMaskFilter {
 public:
     SkBlurMaskFilterImpl(SkScalar sigma, SkBlurStyle, uint32_t flags);
 
     // overrides from SkMaskFilter
     SkMask::Format getFormat() const override;
     bool filterMask(SkMask* dst, const SkMask& src, const SkMatrix&,
                     SkIPoint* margin) const override;
 
 #if SK_SUPPORT_GPU
-    bool canFilterMaskGPU(const SkRect& devBounds,
+    bool canFilterMaskGPU(const SkRRect& devRRect,
                           const SkIRect& clipBounds,
                           const SkMatrix& ctm,
                           SkRect* maskRect) const override;
     bool directFilterMaskGPU(GrTextureProvider* texProvider,
                              GrDrawContext* drawContext,
                              GrRenderTarget* rt,
                              GrPaint* grp,
                              const GrClip&,
                              const SkMatrix& viewMatrix,
                              const SkStrokeRec& strokeRec,
@@ skipping 101 matching lines @@
     if (rec) {
         rec->fSigma = fSigma;
         rec->fStyle = fBlurStyle;
         rec->fQuality = this->getQuality();
     }
     return true;
 }
 
 bool SkBlurMaskFilterImpl::filterMask(SkMask* dst, const SkMask& src,
                                       const SkMatrix& matrix,
-                                      SkIPoint* margin) const{
+                                      SkIPoint* margin) const {
     SkScalar sigma = this->computeXformedSigma(matrix);
     return SkBlurMask::BoxBlur(dst, src, sigma, fBlurStyle, this->getQuality(), margin);
 }
 
 bool SkBlurMaskFilterImpl::filterRectMask(SkMask* dst, const SkRect& r,
                                           const SkMatrix& matrix,
-                                          SkIPoint* margin, SkMask::CreateMode createMode) const{
+                                          SkIPoint* margin, SkMask::CreateMode createMode) const {
     SkScalar sigma = computeXformedSigma(matrix);
 
-    return SkBlurMask::BlurRect(sigma, dst, r, fBlurStyle,
-                                margin, createMode);
+    return SkBlurMask::BlurRect(sigma, dst, r, fBlurStyle, margin, createMode);
 }
 
 bool SkBlurMaskFilterImpl::filterRRectMask(SkMask* dst, const SkRRect& r,
                                           const SkMatrix& matrix,
-                                          SkIPoint* margin, SkMask::CreateMode createMode) const{
+                                          SkIPoint* margin, SkMask::CreateMode createMode) const {
     SkScalar sigma = computeXformedSigma(matrix);
 
-    return SkBlurMask::BlurRRect(sigma, dst, r, fBlurStyle,
-                                margin, createMode);
+    return SkBlurMask::BlurRRect(sigma, dst, r, fBlurStyle, margin, createMode);
 }
 
 #include "SkCanvas.h"
 
 static bool prepare_to_draw_into_mask(const SkRect& bounds, SkMask* mask) {
     SkASSERT(mask != nullptr);
 
     mask->fBounds = bounds.roundOut();
     mask->fRowBytes = SkAlign4(mask->fBounds.width());
     mask->fFormat = SkMask::kA8_Format;
@@ skipping 400 matching lines @@
     buffer.writeUInt(fBlurStyle);
     buffer.writeUInt(fBlurFlags);
 }
 
 #if SK_SUPPORT_GPU
 
 class GrGLRectBlurEffect;
 
 class GrRectBlurEffect : public GrFragmentProcessor {
 public:
-    virtual ~GrRectBlurEffect();
+    ~GrRectBlurEffect() override { }
 
     const char* name() const override { return "RectBlur"; }
 
-    /**
-     * Create a simple filter effect with custom bicubic coefficients.
-     */
-    static GrFragmentProcessor* Create(GrTextureProvider *textureProvider, const SkRect& rect,
-                                       float sigma) {
-        GrTexture *blurProfileTexture = nullptr;
+    static GrFragmentProcessor* Create(GrTextureProvider *textureProvider,
+                                       const SkRect& rect, float sigma) {
         int doubleProfileSize = SkScalarCeilToInt(12*sigma);
 
         if (doubleProfileSize >= rect.width() || doubleProfileSize >= rect.height()) {
             // if the blur sigma is too large so the gaussian overlaps the whole
             // rect in either direction, fall back to CPU path for now.
-
             return nullptr;
         }
 
-        bool createdBlurProfileTexture = CreateBlurProfileTexture(
-            textureProvider, sigma, &blurProfileTexture);
-        SkAutoTUnref<GrTexture> hunref(blurProfileTexture);
-        if (!createdBlurProfileTexture) {
+        SkAutoTUnref<GrTexture> blurProfile(CreateBlurProfileTexture(textureProvider, sigma));
+        if (!blurProfile) {
            return nullptr;
         }
-        return new GrRectBlurEffect(rect, sigma, blurProfileTexture);
+        return new GrRectBlurEffect(rect, sigma, blurProfile);
     }
 
     const SkRect& getRect() const { return fRect; }
     float getSigma() const { return fSigma; }
 
 private:
+    GrRectBlurEffect(const SkRect& rect, float sigma, GrTexture *blurProfile);
+
     GrGLFragmentProcessor* onCreateGLInstance() const override;
 
-    GrRectBlurEffect(const SkRect& rect, float sigma, GrTexture *blur_profile);
-
-    virtual void onGetGLProcessorKey(const GrGLSLCaps& caps,
-                                     GrProcessorKeyBuilder* b) const override;
+    void onGetGLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const override;
 
     bool onIsEqual(const GrFragmentProcessor&) const override;
 
     void onComputeInvariantOutput(GrInvariantOutput* inout) const override;
 
-    static bool CreateBlurProfileTexture(GrTextureProvider*, float sigma,
-                                         GrTexture **blurProfileTexture);
+    static GrTexture* CreateBlurProfileTexture(GrTextureProvider*, float sigma);
 
     SkRect          fRect;
     float           fSigma;
     GrTextureAccess fBlurProfileAccess;
 
     GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
 
     typedef GrFragmentProcessor INHERITED;
 };
 
 class GrGLRectBlurEffect : public GrGLFragmentProcessor {
 public:
     GrGLRectBlurEffect(const GrProcessor&) {}
-    virtual void emitCode(EmitArgs&) override;
+    void emitCode(EmitArgs&) override;
 
 protected:
     void onSetData(const GrGLProgramDataManager&, const GrProcessor&) override;
 
 private:
     typedef GrGLProgramDataManager::UniformHandle UniformHandle;
 
     UniformHandle       fProxyRectUniform;
     UniformHandle       fProfileSizeUniform;
 
@@ skipping 52 matching lines @@
     OutputRectBlurProfileLookup(fsBuilder, args.fSamplers[0], "horiz_lookup", profileSizeName,
                                 "translatedPos.x", "width", "wh.x");
     OutputRectBlurProfileLookup(fsBuilder, args.fSamplers[0], "vert_lookup", profileSizeName,
                                 "translatedPos.y", "height", "wh.y");
 
     fsBuilder->codeAppendf("\tfloat final = horiz_lookup * vert_lookup;\n");
     fsBuilder->codeAppendf("\t%s = src * final;\n", args.fOutputColor );
 }
 
 void GrGLRectBlurEffect::onSetData(const GrGLProgramDataManager& pdman,
-                                 const GrProcessor& proc) {
+                                   const GrProcessor& proc) {
     const GrRectBlurEffect& rbe = proc.cast<GrRectBlurEffect>();
     SkRect rect = rbe.getRect();
 
     pdman.set4f(fProxyRectUniform, rect.fLeft, rect.fTop, rect.fRight, rect.fBottom);
     pdman.set1f(fProfileSizeUniform, SkScalarCeilToScalar(6*rbe.getSigma()));
 }
 
-bool GrRectBlurEffect::CreateBlurProfileTexture(GrTextureProvider* textureProvider, float sigma,
-                                                GrTexture **blurProfileTexture) {
+GrTexture* GrRectBlurEffect::CreateBlurProfileTexture(GrTextureProvider* textureProvider,
+                                                      float sigma) {
     GrSurfaceDesc texDesc;
 
     unsigned int profileSize = SkScalarCeilToInt(6*sigma);
 
     texDesc.fWidth = profileSize;
     texDesc.fHeight = 1;
     texDesc.fConfig = kAlpha_8_GrPixelConfig;
 
     static const GrUniqueKey::Domain kDomain = GrUniqueKey::GenerateDomain();
     GrUniqueKey key;
     GrUniqueKey::Builder builder(&key, kDomain, 1);
     builder[0] = profileSize;
     builder.finish();
 
-    uint8_t *profile = nullptr;
-    SkAutoTDeleteArray<uint8_t> ada(nullptr);
+    GrTexture *blurProfile = textureProvider->findAndRefTextureByUniqueKey(key);
 
-    *blurProfileTexture = textureProvider->findAndRefTextureByUniqueKey(key);
+    if (!blurProfile) {
+        SkAutoTDeleteArray<uint8_t> profile(SkBlurMask::ComputeBlurProfile(sigma));
 
-    if (nullptr == *blurProfileTexture) {
-
-        SkBlurMask::ComputeBlurProfile(sigma, &profile);
-        ada.reset(profile);
-
-        *blurProfileTexture = textureProvider->createTexture(texDesc, true, profile, 0);
-
-        if (nullptr == *blurProfileTexture) {
-            return false;
+        blurProfile = textureProvider->createTexture(texDesc, true, profile.get(), 0);
+        if (blurProfile) {
+            textureProvider->assignUniqueKeyToTexture(key, blurProfile);
         }
-        textureProvider->assignUniqueKeyToTexture(key, *blurProfileTexture);
     }
 
-    return true;
+    return blurProfile;
 }
 
-GrRectBlurEffect::GrRectBlurEffect(const SkRect& rect, float sigma,
-                                   GrTexture *blur_profile)
-  : fRect(rect),
-    fSigma(sigma),
-    fBlurProfileAccess(blur_profile) {
+GrRectBlurEffect::GrRectBlurEffect(const SkRect& rect, float sigma, GrTexture *blurProfile)
+    : fRect(rect)
+    , fSigma(sigma)
+    , fBlurProfileAccess(blurProfile) {
     this->initClassID<GrRectBlurEffect>();
     this->addTextureAccess(&fBlurProfileAccess);
     this->setWillReadFragmentPosition();
 }
 
-GrRectBlurEffect::~GrRectBlurEffect() {
-}
-
 void GrRectBlurEffect::onGetGLProcessorKey(const GrGLSLCaps& caps,
                                          GrProcessorKeyBuilder* b) const {
     GrGLRectBlurEffect::GenKey(*this, caps, b);
 }
 
 GrGLFragmentProcessor* GrRectBlurEffect::onCreateGLInstance() const {
     return new GrGLRectBlurEffect(*this);
 }
 
 bool GrRectBlurEffect::onIsEqual(const GrFragmentProcessor& sBase) const {
@@ skipping 23 matching lines @@
                                                const GrClip& clip,
                                                const SkMatrix& viewMatrix,
                                                const SkStrokeRec& strokeRec,
                                                const SkPath& path) const {
     SkASSERT(drawContext);
 
     if (fBlurStyle != kNormal_SkBlurStyle) {
         return false;
     }
 
-    SkRect rect;
-    if (!path.isRect(&rect)) {
-        return false;
-    }
-
+    // TODO: we could handle blurred stroked circles
     if (!strokeRec.isFillStyle()) {
         return false;
     }
 
     SkScalar xformedSigma = this->computeXformedSigma(viewMatrix);
 
-    int pad = SkScalarCeilToInt(6*xformedSigma)/2;
-    rect.outset(SkIntToScalar(pad), SkIntToScalar(pad));
+    SkAutoTUnref<const GrFragmentProcessor> fp;
 
-    SkAutoTUnref<GrFragmentProcessor> fp(GrRectBlurEffect::Create(
-                                                                texProvider, rect, xformedSigma));
+    SkRect rect;
+    if (path.isRect(&rect)) {
+        int pad = SkScalarCeilToInt(6*xformedSigma)/2;
+        rect.outset(SkIntToScalar(pad), SkIntToScalar(pad));
+
+        fp.reset(GrRectBlurEffect::Create(texProvider, rect, xformedSigma));
+    } else if (path.isOval(&rect) && SkScalarNearlyEqual(rect.width(), rect.height())) {
+        fp.reset(GrCircleBlurFragmentProcessor::Create(texProvider, rect, xformedSigma));
+
+        // expand the rect for the coverage geometry
+        int pad = SkScalarCeilToInt(6*xformedSigma)/2;
+        rect.outset(SkIntToScalar(pad), SkIntToScalar(pad));
+    } else {
+        return false;
+    }
+
     if (!fp) {
         return false;
     }
 
     grp->addCoverageFragmentProcessor(fp);
 
     SkMatrix inverse;
     if (!viewMatrix.invert(&inverse)) {
         return false;
     }
 
     drawContext->drawNonAARectWithLocalMatrix(rt, clip, *grp, SkMatrix::I(), rect, inverse);
     return true;
 }
 
+//////////////////////////////////////////////////////////////////////////////
+
 class GrRRectBlurEffect : public GrFragmentProcessor {
 public:
 
-    static GrFragmentProcessor* Create(GrTextureProvider*, float sigma, const SkRRect&);
+    static const GrFragmentProcessor* Create(GrTextureProvider*, float sigma, const SkRRect&);
 
     virtual ~GrRRectBlurEffect() {};
     const char* name() const override { return "GrRRectBlur"; }
 
     const SkRRect& getRRect() const { return fRRect; }
     float getSigma() const { return fSigma; }
 
 private:
     GrGLFragmentProcessor* onCreateGLInstance() const override;
 
     GrRRectBlurEffect(float sigma, const SkRRect&, GrTexture* profileTexture);
 
     virtual void onGetGLProcessorKey(const GrGLSLCaps& caps,
                                      GrProcessorKeyBuilder* b) const override;
 
     bool onIsEqual(const GrFragmentProcessor& other) const override;
 
     void onComputeInvariantOutput(GrInvariantOutput* inout) const override;
 
     SkRRect             fRRect;
     float               fSigma;
     GrTextureAccess     fNinePatchAccess;
 
     GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
 
     typedef GrFragmentProcessor INHERITED;
 };
 
 
-GrFragmentProcessor* GrRRectBlurEffect::Create(GrTextureProvider* texProvider, float sigma,
-                                               const SkRRect& rrect) {
+const GrFragmentProcessor* GrRRectBlurEffect::Create(GrTextureProvider* texProvider, float sigma,
+                                                     const SkRRect& rrect) {
+    if (rrect.isCircle()) {
+        return GrCircleBlurFragmentProcessor::Create(texProvider, rrect.rect(), sigma);
+    }
+
     if (!rrect.isSimpleCircular()) {
         return nullptr;
     }
 
     // Make sure we can successfully ninepatch this rrect -- the blur sigma has to be
     // sufficiently small relative to both the size of the corner radius and the
     // width (and height) of the rrect.
 
     unsigned int blurRadius = 3*SkScalarCeilToInt(sigma-1/6.0f);
     unsigned int cornerRadius = SkScalarCeilToInt(rrect.getSimpleRadii().x());
@@ skipping 204 matching lines @@
     if (!strokeRec.isFillStyle()) {
         return false;
     }
 
     SkScalar xformedSigma = this->computeXformedSigma(viewMatrix);
     float extra=3.f*SkScalarCeilToScalar(xformedSigma-1/6.0f);
 
     SkRect proxyRect = rrect.rect();
     proxyRect.outset(extra, extra);
 
-    SkAutoTUnref<GrFragmentProcessor> fp(GrRRectBlurEffect::Create(texProvider, 
-                                                                   xformedSigma, rrect));
+    SkAutoTUnref<const GrFragmentProcessor> fp(GrRRectBlurEffect::Create(texProvider, 
+                                                                         xformedSigma, rrect));
     if (!fp) {
         return false;
     }
 
     grp->addCoverageFragmentProcessor(fp);
 
     SkMatrix inverse;
     if (!viewMatrix.invert(&inverse)) {
         return false;
     }
 
     drawContext->drawNonAARectWithLocalMatrix(rt, clip, *grp, SkMatrix::I(), proxyRect, inverse);
     return true;
 }
 
-bool SkBlurMaskFilterImpl::canFilterMaskGPU(const SkRect& srcBounds,
+bool SkBlurMaskFilterImpl::canFilterMaskGPU(const SkRRect& devRRect,
                                             const SkIRect& clipBounds,
                                             const SkMatrix& ctm,
                                             SkRect* maskRect) const {
     SkScalar xformedSigma = this->computeXformedSigma(ctm);
     if (xformedSigma <= 0) {
         return false;
     }
 
-    static const SkScalar kMIN_GPU_BLUR_SIZE  = SkIntToScalar(64);
-    static const SkScalar kMIN_GPU_BLUR_SIGMA = SkIntToScalar(32);
+    // We always do circles on the GPU
+    if (!devRRect.isCircle()) {
+        static const SkScalar kMIN_GPU_BLUR_SIZE  = SkIntToScalar(64);
+        static const SkScalar kMIN_GPU_BLUR_SIGMA = SkIntToScalar(32);
 
-    if (srcBounds.width() <= kMIN_GPU_BLUR_SIZE &&
-        srcBounds.height() <= kMIN_GPU_BLUR_SIZE &&
-        xformedSigma <= kMIN_GPU_BLUR_SIGMA) {
-        // We prefer to blur small rect with small radius via CPU.
-        return false;
+        if (devRRect.width() <= kMIN_GPU_BLUR_SIZE &&
+            devRRect.height() <= kMIN_GPU_BLUR_SIZE &&
+            xformedSigma <= kMIN_GPU_BLUR_SIGMA) {
+            // We prefer to blur small rects with small radii on the CPU.
+            return false;
+        }
     }
 
     if (nullptr == maskRect) {
         // don't need to compute maskRect
         return true;
     }
 
     float sigma3 = 3 * SkScalarToFloat(xformedSigma);
 
     SkRect clipRect = SkRect::Make(clipBounds);
-    SkRect srcRect(srcBounds);
+    SkRect srcRect(devRRect.rect());
 
     // Outset srcRect and clipRect by 3 * sigma, to compute affected blur area.
     srcRect.outset(sigma3, sigma3);
     clipRect.outset(sigma3, sigma3);
     if (!srcRect.intersect(clipRect)) {
         srcRect.setEmpty();
     }
     *maskRect = srcRect;
     return true;
 }
@@ skipping 79 matching lines @@
     } else {
         str->append("None");
     }
     str->append("))");
 }
 #endif
 
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkBlurMaskFilter)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkBlurMaskFilterImpl)
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END