Refugee from Dead Machine 4: MDB Monster

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"
@@ skipping 594 matching lines @@
 
 class GrGLRectBlurEffect;
 
 class GrRectBlurEffect : public GrFragmentProcessor {
 public:
     ~GrRectBlurEffect() override { }
 
     const char* name() const override { return "RectBlur"; }
 
     static GrFragmentProcessor* Create(GrTextureProvider *textureProvider,
-                                       const SkRect& rect, float sigma) {
+                                       const SkRect& rect, float sigma, GrRenderTarget* dst) {
         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;
         }
 
         SkAutoTUnref<GrTexture> blurProfile(CreateBlurProfileTexture(textureProvider, sigma));
         if (!blurProfile) {
@@ skipping 12 matching lines @@
             SkScalarAbs(rect.left()) > kMAX_BLUR_COORD ||
             SkScalarAbs(rect.bottom()) > kMAX_BLUR_COORD ||
             SkScalarAbs(rect.right()) > kMAX_BLUR_COORD ||
             SkScalarAbs(rect.width()) > kMAX_BLUR_COORD ||
             SkScalarAbs(rect.height()) > kMAX_BLUR_COORD) {
             precision = kHigh_GrSLPrecision;
         }
         else {
             precision = kDefault_GrSLPrecision;
         }
-        return new GrRectBlurEffect(rect, sigma, blurProfile, precision);
+        return new GrRectBlurEffect(rect, sigma, blurProfile, precision, dst);
     }
 
     const SkRect& getRect() const { return fRect; }
     float getSigma() const { return fSigma; }
 
 private:
     GrRectBlurEffect(const SkRect& rect, float sigma, GrTexture *blurProfile,
-                     GrSLPrecision fPrecision);
+                     GrSLPrecision fPrecision, GrRenderTarget* dstRT);
 
     GrGLFragmentProcessor* onCreateGLInstance() const override;
 
     void onGetGLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const override;
 
     bool onIsEqual(const GrFragmentProcessor&) const override;
 
     void onComputeInvariantOutput(GrInvariantOutput* inout) const override;
 
     static GrTexture* CreateBlurProfileTexture(GrTextureProvider*, float sigma);
@@ skipping 126 matching lines @@
 
     GrTexture *blurProfile = textureProvider->findAndRefTextureByUniqueKey(key);
 
     if (!blurProfile) {
         SkAutoTDeleteArray<uint8_t> profile(SkBlurMask::ComputeBlurProfile(sigma));
 
         blurProfile = textureProvider->createTexture(texDesc, true, profile.get(), 0);
         if (blurProfile) {
             textureProvider->assignUniqueKeyToTexture(key, blurProfile);
         }
+        blurProfile->setFromRawPixels(true);
     }
 
     return blurProfile;
 }
 
 GrRectBlurEffect::GrRectBlurEffect(const SkRect& rect, float sigma, GrTexture *blurProfile,
-                                   GrSLPrecision precision)
+                                   GrSLPrecision precision, GrRenderTarget* dst)
     : fRect(rect)
     , fSigma(sigma)
-    , fBlurProfileAccess(blurProfile)
+    , fBlurProfileAccess(blurProfile, GrTextureParams::kNone_FilterMode,SkShader::kClamp_TileMode, dst)
     , fPrecision(precision) {
     this->initClassID<GrRectBlurEffect>();
     this->addTextureAccess(&fBlurProfileAccess);
     this->setWillReadFragmentPosition();
 }
 
 void GrRectBlurEffect::onGetGLProcessorKey(const GrGLSLCaps& caps,
                                            GrProcessorKeyBuilder* b) const {
     GrGLRectBlurEffect::GenKey(fPrecision, b);
 }
@@ skipping 11 matching lines @@
     inout->mulByUnknownSingleComponent();
 }
 
 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrRectBlurEffect);
 
 const GrFragmentProcessor* GrRectBlurEffect::TestCreate(GrProcessorTestData* d) {
     float sigma = d->fRandom->nextRangeF(3,8);
     float width = d->fRandom->nextRangeF(200,300);
     float height = d->fRandom->nextRangeF(200,300);
     return GrRectBlurEffect::Create(d->fContext->textureProvider(), SkRect::MakeWH(width, height),
-                                    sigma);
+                                    sigma, NULL);
 }
 
 
 bool SkBlurMaskFilterImpl::directFilterMaskGPU(GrTextureProvider* texProvider,
                                                GrDrawContext* drawContext,
                                                GrPaint* grp,
                                                const GrClip& clip,
                                                const SkMatrix& viewMatrix,
                                                const SkStrokeRec& strokeRec,
                                                const SkPath& path) const {
@@ skipping 10 matching lines @@
 
     SkScalar xformedSigma = this->computeXformedSigma(viewMatrix);
 
     SkAutoTUnref<const GrFragmentProcessor> fp;
 
     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));
+        fp.reset(GrRectBlurEffect::Create(texProvider, rect, xformedSigma, drawContext->rt_remove_me()));
     } else if (path.isOval(&rect) && SkScalarNearlyEqual(rect.width(), rect.height())) {
-        fp.reset(GrCircleBlurFragmentProcessor::Create(texProvider, rect, xformedSigma));
+        fp.reset(GrCircleBlurFragmentProcessor::Create(texProvider, rect, xformedSigma, drawContext->rt_remove_me()));
 
         // 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->fillRectWithLocalMatrix(clip, *grp, SkMatrix::I(), rect, inverse);
     return true;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 class GrRRectBlurEffect : public GrFragmentProcessor {
 public:
 
-    static const GrFragmentProcessor* Create(GrTextureProvider*, float sigma, const SkRRect&);
+    static const GrFragmentProcessor* Create(GrTextureProvider*, float sigma, const SkRRect&, GrRenderTarget* dst);
 
     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);
+    GrRRectBlurEffect(float sigma, const SkRRect&, GrTexture* profileTexture, GrRenderTarget* dst);
 
     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;
 };
 
 
 const GrFragmentProcessor* GrRRectBlurEffect::Create(GrTextureProvider* texProvider, float sigma,
-                                                     const SkRRect& rrect) {
+                                                     const SkRRect& rrect, GrRenderTarget* dst) {
     if (rrect.isCircle()) {
-        return GrCircleBlurFragmentProcessor::Create(texProvider, rrect.rect(), sigma);
+        return GrCircleBlurFragmentProcessor::Create(texProvider, rrect.rect(), sigma, dst);
     }
 
     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.
 
@@ skipping 48 matching lines @@
         texDesc.fHeight = texSide;
         texDesc.fConfig = kAlpha_8_GrPixelConfig;
 
         blurNinePatchTexture.reset(
             texProvider->createTexture(texDesc, true, blurredMask.fImage, 0));
         SkMask::FreeImage(blurredMask.fImage);
         if (!blurNinePatchTexture) {
             return nullptr;
         }
         texProvider->assignUniqueKeyToTexture(key, blurNinePatchTexture);
+        blurNinePatchTexture->setFromRawPixels(true);
     }
-    return new GrRRectBlurEffect(sigma, rrect, blurNinePatchTexture);
+    return new GrRRectBlurEffect(sigma, rrect, blurNinePatchTexture, dst);
 }
 
 void GrRRectBlurEffect::onComputeInvariantOutput(GrInvariantOutput* inout) const {
     inout->mulByUnknownSingleComponent();
 }
 
-GrRRectBlurEffect::GrRRectBlurEffect(float sigma, const SkRRect& rrect, GrTexture *ninePatchTexture)
+GrRRectBlurEffect::GrRRectBlurEffect(float sigma, const SkRRect& rrect, GrTexture *ninePatchTexture, GrRenderTarget* dst)
     : fRRect(rrect),
       fSigma(sigma),
-      fNinePatchAccess(ninePatchTexture) {
+      fNinePatchAccess(ninePatchTexture, GrTextureParams::kNone_FilterMode,SkShader::kClamp_TileMode, dst) {
     this->initClassID<GrRRectBlurEffect>();
     this->addTextureAccess(&fNinePatchAccess);
     this->setWillReadFragmentPosition();
 }
 
 bool GrRRectBlurEffect::onIsEqual(const GrFragmentProcessor& other) const {
     const GrRRectBlurEffect& rrbe = other.cast<GrRRectBlurEffect>();
     return fRRect.getSimpleRadii().fX == rrbe.fRRect.getSimpleRadii().fX && fSigma == rrbe.fSigma;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrRRectBlurEffect);
 
 const GrFragmentProcessor* GrRRectBlurEffect::TestCreate(GrProcessorTestData* d) {
     SkScalar w = d->fRandom->nextRangeScalar(100.f, 1000.f);
     SkScalar h = d->fRandom->nextRangeScalar(100.f, 1000.f);
     SkScalar r = d->fRandom->nextRangeF(1.f, 9.f);
     SkScalar sigma = d->fRandom->nextRangeF(1.f,10.f);
     SkRRect rrect;
     rrect.setRectXY(SkRect::MakeWH(w, h), r, r);
-    return GrRRectBlurEffect::Create(d->fContext->textureProvider(), sigma, rrect);
+    return GrRRectBlurEffect::Create(d->fContext->textureProvider(), sigma, rrect, NULL);
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 class GrGLRRectBlurEffect : public GrGLFragmentProcessor {
 public:
     GrGLRRectBlurEffect(const GrProcessor&) {}
 
     virtual void emitCode(EmitArgs&) override;
 
@@ skipping 104 matching lines @@
         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<const GrFragmentProcessor> fp(GrRRectBlurEffect::Create(texProvider, 
-                                                                         xformedSigma, rrect));
+                                                                         xformedSigma, rrect, drawContext->rt_remove_me()));
     if (!fp) {
         return false;
     }
 
     grp->addCoverageFragmentProcessor(fp);
 
     SkMatrix inverse;
     if (!viewMatrix.invert(&inverse)) {
         return false;
     }
@@ skipping 37 matching lines @@
     // 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;
 }
 
+#include "GrDrawTarget.h"
+
 bool SkBlurMaskFilterImpl::filterMaskGPU(GrTexture* src,
                                          const SkMatrix& ctm,
                                          const SkRect& maskRect,
                                          GrTexture** result,
                                          bool canOverwriteSrc) const {
     SkRect clipRect = SkRect::MakeWH(maskRect.width(), maskRect.height());
 
     GrContext* context = src->getContext();
 
     SkScalar xformedSigma = this->computeXformedSigma(ctm);
     SkASSERT(xformedSigma > 0);
 
     // If we're doing a normal blur, we can clobber the pathTexture in the
     // gaussianBlur.  Otherwise, we need to save it for later compositing.
     bool isNormalBlur = (kNormal_SkBlurStyle == fBlurStyle);
     *result = SkGpuBlurUtils::GaussianBlur(context, src, isNormalBlur && canOverwriteSrc,
                                            clipRect, nullptr, xformedSigma, xformedSigma,
                                            GrTextureProvider::kApprox_SizeConstraint);
     if (nullptr == *result) {
         return false;
     }
 
     if (!isNormalBlur) {
         GrPaint paint;
         SkMatrix matrix;
         matrix.setIDiv(src->width(), src->height());
         // Blend pathTexture over blurTexture.
-        paint.addCoverageFragmentProcessor(GrSimpleTextureEffect::Create(src, matrix))->unref();
+        paint.addCoverageFragmentProcessor(
+            GrSimpleTextureEffect::Create(src, matrix, kLocal_GrCoordSet,
+                                          (*result)->asRenderTarget()))->unref();
+
         if (kInner_SkBlurStyle == fBlurStyle) {
             // inner:  dst = dst * src
             paint.setCoverageSetOpXPFactory(SkRegion::kIntersect_Op);
         } else if (kSolid_SkBlurStyle == fBlurStyle) {
             // solid:  dst = src + dst - src * dst
             //             = src + (1 - src) * dst
             paint.setCoverageSetOpXPFactory(SkRegion::kUnion_Op);
         } else if (kOuter_SkBlurStyle == fBlurStyle) {
             // outer:  dst = dst * (1 - src)
             //             = 0 * src + (1 - src) * dst
             paint.setCoverageSetOpXPFactory(SkRegion::kDifference_Op);
         }
 
+        GrRenderTarget* rt = (*result)->asRenderTarget();
+        SkASSERT(rt);
+        GrDrawTarget* dt = rt->getLastDrawTarget();
+        SkASSERT(dt);
+        SkASSERT(!dt->isClosed());
+
         SkAutoTUnref<GrDrawContext> drawContext(context->drawContext((*result)->asRenderTarget()));
         if (!drawContext) {
             return false;
         }
 
         drawContext->drawRect(GrClip::WideOpen(), paint, SkMatrix::I(), clipRect);
     }
 
     return true;
 }
@@ skipping 26 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