Fix for GM:bigblurs not actually blurring some of the rectangles on Nexus 10.

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 288 matching lines @@
 static SkCachedData* add_cached_rects(SkMask* mask, SkScalar sigma, SkBlurStyle style,
                                       SkBlurQuality quality, const SkRect rects[], int count) {
     SkCachedData* cache = copy_mask_to_cacheddata(mask);
     if (cache) {
         SkMaskCache::Add(sigma, style, quality, rects, count, *mask, cache);
     }
     return cache;
 }
 
 #ifdef SK_IGNORE_FAST_RRECT_BLUR
-SK_CONF_DECLARE( bool, c_analyticBlurRRect, "mask.filter.blur.analyticblurrrect", false, "Use the faster analytic blur approach for ninepatch rects" );
+SK_CONF_DECLARE(bool, c_analyticBlurRRect, "mask.filter.blur.analyticblurrrect", false, "Use the faster analytic blur approach for ninepatch rects");
 #else
-SK_CONF_DECLARE( bool, c_analyticBlurRRect, "mask.filter.blur.analyticblurrrect", true, "Use the faster analytic blur approach for ninepatch round rects" );
+SK_CONF_DECLARE(bool, c_analyticBlurRRect, "mask.filter.blur.analyticblurrrect", true, "Use the faster analytic blur approach for ninepatch round rects");
 #endif
 
 SkMaskFilter::FilterReturn
 SkBlurMaskFilterImpl::filterRRectToNine(const SkRRect& rrect, const SkMatrix& matrix,
                                         const SkIRect& clipBounds,
                                         NinePatch* patch) const {
     SkASSERT(patch != nullptr);
     switch (rrect.getType()) {
         case SkRRect::kEmpty_Type:
             // Nothing to draw.
@@ skipping 117 matching lines @@
 
     patch->fMask.fBounds.offsetTo(0, 0);
     patch->fOuterRect = dstM.fBounds;
     patch->fCenter.fX = SkScalarCeilToInt(leftUnstretched) + 1;
     patch->fCenter.fY = SkScalarCeilToInt(topUnstretched) + 1;
     SkASSERT(nullptr == patch->fCache);
     patch->fCache = cache;  // transfer ownership to patch
     return kTrue_FilterReturn;
 }
 
-SK_CONF_DECLARE( bool, c_analyticBlurNinepatch, "mask.filter.analyticNinePatch", true, "Use the faster analytic blur approach for ninepatch rects" );
+SK_CONF_DECLARE(bool, c_analyticBlurNinepatch, "mask.filter.analyticNinePatch", true, "Use the faster analytic blur approach for ninepatch rects");
 
 SkMaskFilter::FilterReturn
 SkBlurMaskFilterImpl::filterRectsToNine(const SkRect rects[], int count,
                                         const SkMatrix& matrix,
                                         const SkIRect& clipBounds,
                                         NinePatch* patch) const {
     if (count < 1 || count > 2) {
         return kUnimplemented_FilterReturn;
     }
 
@@ skipping 156 matching lines @@
 
         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) {
            return nullptr;
         }

[robertphillips, 2015/10/19 13:48:39]

// why is this here ? how was the constant determined ?

[ethannicholas, 2015/10/19 14:11:41]

It was originally determined by "this is the size that things go wonky on the
Nexus 10", but after double-checking the OpenGL ES spec I actually should drop
it down to 16000 for safety's sake. Technically 16384 should work, but I don't
see any reason to push our luck.

-        return new GrRectBlurEffect(rect, sigma, blurProfile);
+        static const SkScalar kMAX_BLUR_COORD = SkIntToScalar(32000);
+        GrSLPrecision precision;
+        if (rect.top() > kMAX_BLUR_COORD ||
+            rect.left() > kMAX_BLUR_COORD ||
+            rect.bottom() > kMAX_BLUR_COORD ||
+            rect.right() > kMAX_BLUR_COORD ||
+            rect.width() > kMAX_BLUR_COORD ||
+            rect.height() > kMAX_BLUR_COORD) {
+            precision = kHigh_GrSLPrecision;
+        }
+        else {
+            precision = kDefault_GrSLPrecision;
+        }
+        return new GrRectBlurEffect(rect, sigma, blurProfile, precision);
     }
 
     const SkRect& getRect() const { return fRect; }
     float getSigma() const { return fSigma; }
 
 private:
-    GrRectBlurEffect(const SkRect& rect, float sigma, GrTexture *blurProfile);
+    GrRectBlurEffect(const SkRect& rect, float sigma, GrTexture *blurProfile,
+                     GrSLPrecision fPrecision);
 
     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);
 
     SkRect          fRect;
     float           fSigma;
     GrTextureAccess fBlurProfileAccess;
+    GrSLPrecision   fPrecision;
 
     GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
 
     typedef GrFragmentProcessor INHERITED;
 };
 
 class GrGLRectBlurEffect : public GrGLFragmentProcessor {
 public:
-    GrGLRectBlurEffect(const GrProcessor&) {}
+    GrGLRectBlurEffect(const GrProcessor&, GrSLPrecision precision) 
+    : fPrecision(precision) {
+    }
     void emitCode(EmitArgs&) override;
 
+    static void GenKey(GrSLPrecision precision, GrProcessorKeyBuilder* b);
+
 protected:
     void onSetData(const GrGLProgramDataManager&, const GrProcessor&) override;
 
 private:
     typedef GrGLProgramDataManager::UniformHandle UniformHandle;
 
     UniformHandle       fProxyRectUniform;
     UniformHandle       fProfileSizeUniform;
+    GrSLPrecision       fPrecision;
 
     typedef GrGLFragmentProcessor INHERITED;
 };
 
 void OutputRectBlurProfileLookup(GrGLFragmentBuilder* fsBuilder,
                                  const GrGLShaderBuilder::TextureSampler& sampler,
                                  const char *output,
                                  const char *profileSize, const char *loc,
                                  const char *blurred_width,
                                  const char *sharp_width) {
-    fsBuilder->codeAppendf("\tfloat %s;\n", output);
-    fsBuilder->codeAppendf("\t\t{\n");
-    fsBuilder->codeAppendf("\t\t\tfloat coord = (0.5 * (abs(2.0*%s - %s) - %s))/%s;\n",
+    fsBuilder->codeAppendf("float %s;", output);
+    fsBuilder->codeAppendf("{");
+    fsBuilder->codeAppendf("float coord = ((abs(%s - 0.5 * %s) - 0.5 * %s)) / %s;",
                            loc, blurred_width, sharp_width, profileSize);
-    fsBuilder->codeAppendf("\t\t\t%s = ", output);
+    fsBuilder->codeAppendf("%s = ", output);
     fsBuilder->appendTextureLookup(sampler, "vec2(coord,0.5)");
-    fsBuilder->codeAppend(".a;\n");
-    fsBuilder->codeAppendf("\t\t}\n");
+    fsBuilder->codeAppend(".a;");
+    fsBuilder->codeAppendf("}");
 }
 
+

[joshualitt, 2015/10/16 20:50:44]

\n

+void GrGLRectBlurEffect::GenKey(GrSLPrecision precision, GrProcessorKeyBuilder* b) {
+    b->add32(precision);
+}
+
+

[joshualitt, 2015/10/16 20:50:44]

\n

 void GrGLRectBlurEffect::emitCode(EmitArgs& args) {
 

[joshualitt, 2015/10/16 20:50:44]

\n

     const char *rectName;
     const char *profileSizeName;
 
+    const char* precisionString = GrGLShaderVar::PrecisionString(fPrecision, kGLES_GrGLStandard);
     fProxyRectUniform = args.fBuilder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
                                             kVec4f_GrSLType,
-                                            kDefault_GrSLPrecision,
+                                            fPrecision,
                                             "proxyRect",
                                             &rectName);
     fProfileSizeUniform = args.fBuilder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
                                             kFloat_GrSLType,
                                             kDefault_GrSLPrecision,
                                             "profileSize",
                                             &profileSizeName);
 
     GrGLFragmentBuilder* fsBuilder = args.fBuilder->getFragmentShaderBuilder();
     const char *fragmentPos = fsBuilder->fragmentPosition();
 
     if (args.fInputColor) {
-        fsBuilder->codeAppendf("\tvec4 src=%s;\n", args.fInputColor);
+        fsBuilder->codeAppendf("vec4 src=%s;", args.fInputColor);
     } else {
-        fsBuilder->codeAppendf("\tvec4 src=vec4(1)\n;");
+        fsBuilder->codeAppendf("vec4 src=vec4(1);");
     }
 
-    fsBuilder->codeAppendf("\tvec2 translatedPos = %s.xy - %s.xy;\n", fragmentPos, rectName );
-    fsBuilder->codeAppendf("\tfloat width = %s.z - %s.x;\n", rectName, rectName);
-    fsBuilder->codeAppendf("\tfloat height = %s.w - %s.y;\n", rectName, rectName);
+    fsBuilder->codeAppendf("%s vec2 translatedPos = %s.xy - %s.xy;", precisionString, fragmentPos, 
+                           rectName);
+    fsBuilder->codeAppendf("%s float width = %s.z - %s.x;", precisionString, rectName, rectName);
+    fsBuilder->codeAppendf("%s float height = %s.w - %s.y;", precisionString, rectName, rectName);
 
-    fsBuilder->codeAppendf("\tvec2 smallDims = vec2(width - %s, height-%s);\n", profileSizeName, profileSizeName);
-    fsBuilder->codeAppendf("\tfloat center = 2.0 * floor(%s/2.0 + .25) - 1.0;\n", profileSizeName);
-    fsBuilder->codeAppendf("\tvec2 wh = smallDims - vec2(center,center);\n");
+    fsBuilder->codeAppendf("%s vec2 smallDims = vec2(width - %s, height - %s);", precisionString, 
+                           profileSizeName, profileSizeName);
+    fsBuilder->codeAppendf("%s float center = 2.0 * floor(%s/2.0 + .25) - 1.0;", precisionString,
+                           profileSizeName);
+    fsBuilder->codeAppendf("%s vec2 wh = smallDims - vec2(center,center);", precisionString);
 
     OutputRectBlurProfileLookup(fsBuilder, args.fSamplers[0], "horiz_lookup", profileSizeName,
                                 "translatedPos.x", "width", "wh.x");
-    OutputRectBlurProfileLookup(fsBuilder, args.fSamplers[0], "vert_lookup", profileSizeName,
+    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 );
+    fsBuilder->codeAppendf("float final = horiz_lookup * vert_lookup;");
+    fsBuilder->codeAppendf("%s = src * final;", args.fOutputColor);
 }
 
 void GrGLRectBlurEffect::onSetData(const GrGLProgramDataManager& pdman,
                                    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()));
 }
@@ skipping 21 matching lines @@
 
         blurProfile = textureProvider->createTexture(texDesc, true, profile.get(), 0);
         if (blurProfile) {
             textureProvider->assignUniqueKeyToTexture(key, blurProfile);
         }
     }
 
     return blurProfile;
 }
 
-GrRectBlurEffect::GrRectBlurEffect(const SkRect& rect, float sigma, GrTexture *blurProfile)
+GrRectBlurEffect::GrRectBlurEffect(const SkRect& rect, float sigma, GrTexture *blurProfile,
+                                   GrSLPrecision precision)
     : fRect(rect)
     , fSigma(sigma)
-    , fBlurProfileAccess(blurProfile) {
+    , fBlurProfileAccess(blurProfile)
+    , fPrecision(precision) {
     this->initClassID<GrRectBlurEffect>();
     this->addTextureAccess(&fBlurProfileAccess);
     this->setWillReadFragmentPosition();
 }
 
 void GrRectBlurEffect::onGetGLProcessorKey(const GrGLSLCaps& caps,
                                          GrProcessorKeyBuilder* b) const {
-    GrGLRectBlurEffect::GenKey(*this, caps, b);
+    GrGLRectBlurEffect::GenKey(fPrecision, b);

[joshualitt, 2015/10/16 20:50:44]

We typically add a getter to this, and then just  pass it in.

 }
 
 GrGLFragmentProcessor* GrRectBlurEffect::onCreateGLInstance() const {
-    return new GrGLRectBlurEffect(*this);
+    return new GrGLRectBlurEffect(*this, fPrecision);
 }
 
 bool GrRectBlurEffect::onIsEqual(const GrFragmentProcessor& sBase) const {
     const GrRectBlurEffect& s = sBase.cast<GrRectBlurEffect>();
     return this->getSigma() == s.getSigma() && this->getRect() == s.getRect();
 }
 
 void GrRectBlurEffect::onComputeInvariantOutput(GrInvariantOutput* inout) const {
     inout->mulByUnknownSingleComponent();
 }
@@ skipping 141 matching lines @@
 
         memset(mask.fImage, 0, mask.computeTotalImageSize());
 
         SkRect smallRect;
         smallRect.setWH(SkIntToScalar(smallRectSide), SkIntToScalar(smallRectSide));
 
         SkRRect smallRRect;
         smallRRect.setRectXY(smallRect, SkIntToScalar(cornerRadius), SkIntToScalar(cornerRadius));
 
         SkPath path;
-        path.addRRect( smallRRect );
+        path.addRRect(smallRRect);
 
         SkDraw::DrawToMask(path, &mask.fBounds, nullptr, nullptr, &mask,
                            SkMask::kJustRenderImage_CreateMode, SkPaint::kFill_Style);
 
         SkMask blurredMask;
         SkBlurMask::BoxBlur(&blurredMask, mask, sigma, kNormal_SkBlurStyle, kHigh_SkBlurQuality,
-                            nullptr, true );
+                            nullptr, true);
 
         unsigned int texSide = smallRectSide + 2*blurRadius;
         GrSurfaceDesc texDesc;
         texDesc.fWidth = texSide;
         texDesc.fHeight = texSide;
         texDesc.fConfig = kAlpha_8_GrPixelConfig;
 
         blurNinePatchTexture.reset(
             texProvider->createTexture(texDesc, true, blurredMask.fImage, 0));
         SkMask::FreeImage(blurredMask.fImage);
@@ skipping 77 matching lines @@
                                              kFloat_GrSLType,
                                               kDefault_GrSLPrecision,
                                               "blurRadius",
                                               &blurRadiusName);
 
     GrGLFragmentBuilder* fsBuilder = args.fBuilder->getFragmentShaderBuilder();
     const char* fragmentPos = fsBuilder->fragmentPosition();
 
     // warp the fragment position to the appropriate part of the 9patch blur texture
 
-    fsBuilder->codeAppendf("\t\tvec2 rectCenter = (%s.xy + %s.zw)/2.0;\n", rectName, rectName);
-    fsBuilder->codeAppendf("\t\tvec2 translatedFragPos = %s.xy - %s.xy;\n", fragmentPos, rectName);
-    fsBuilder->codeAppendf("\t\tfloat threshold = %s + 2.0*%s;\n", cornerRadiusName, blurRadiusName );
-    fsBuilder->codeAppendf("\t\tvec2 middle = %s.zw - %s.xy - 2.0*threshold;\n", rectName, rectName );
+    fsBuilder->codeAppendf("vec2 rectCenter = (%s.xy + %s.zw)/2.0;", rectName, rectName);
+    fsBuilder->codeAppendf("vec2 translatedFragPos = %s.xy - %s.xy;", fragmentPos, rectName);
+    fsBuilder->codeAppendf("float threshold = %s + 2.0*%s;", cornerRadiusName, blurRadiusName);
+    fsBuilder->codeAppendf("vec2 middle = %s.zw - %s.xy - 2.0*threshold;", rectName, rectName);
 
-    fsBuilder->codeAppendf("\t\tif (translatedFragPos.x >= threshold && translatedFragPos.x < (middle.x+threshold)) {\n" );
-    fsBuilder->codeAppendf("\t\t\ttranslatedFragPos.x = threshold;\n");
-    fsBuilder->codeAppendf("\t\t} else if (translatedFragPos.x >= (middle.x + threshold)) {\n");
-    fsBuilder->codeAppendf("\t\t\ttranslatedFragPos.x -= middle.x - 1.0;\n");
-    fsBuilder->codeAppendf("\t\t}\n");
+    fsBuilder->codeAppendf("if (translatedFragPos.x >= threshold && translatedFragPos.x < (middle.x+threshold)) {");
+    fsBuilder->codeAppendf("translatedFragPos.x = threshold;\n");
+    fsBuilder->codeAppendf("} else if (translatedFragPos.x >= (middle.x + threshold)) {");
+    fsBuilder->codeAppendf("translatedFragPos.x -= middle.x - 1.0;");
+    fsBuilder->codeAppendf("}");
 
-    fsBuilder->codeAppendf("\t\tif (translatedFragPos.y > threshold && translatedFragPos.y < (middle.y+threshold)) {\n" );
-    fsBuilder->codeAppendf("\t\t\ttranslatedFragPos.y = threshold;\n");
-    fsBuilder->codeAppendf("\t\t} else if (translatedFragPos.y >= (middle.y + threshold)) {\n");
-    fsBuilder->codeAppendf("\t\t\ttranslatedFragPos.y -= middle.y - 1.0;\n");
-    fsBuilder->codeAppendf("\t\t}\n");
+    fsBuilder->codeAppendf("if (translatedFragPos.y > threshold && translatedFragPos.y < (middle.y+threshold)) {");
+    fsBuilder->codeAppendf("translatedFragPos.y = threshold;");
+    fsBuilder->codeAppendf("} else if (translatedFragPos.y >= (middle.y + threshold)) {");
+    fsBuilder->codeAppendf("translatedFragPos.y -= middle.y - 1.0;");
+    fsBuilder->codeAppendf("}");
 
-    fsBuilder->codeAppendf("\t\tvec2 proxyDims = vec2(2.0*threshold+1.0);\n");
-    fsBuilder->codeAppendf("\t\tvec2 texCoord = translatedFragPos / proxyDims;\n");
+    fsBuilder->codeAppendf("vec2 proxyDims = vec2(2.0*threshold+1.0);");
+    fsBuilder->codeAppendf("vec2 texCoord = translatedFragPos / proxyDims;");
 
-    fsBuilder->codeAppendf("\t%s = ", args.fOutputColor);
+    fsBuilder->codeAppendf("%s = ", args.fOutputColor);
     fsBuilder->appendTextureLookupAndModulate(args.fInputColor, args.fSamplers[0], "texCoord");
-    fsBuilder->codeAppend(";\n");
+    fsBuilder->codeAppend(";");
 }
 
 void GrGLRRectBlurEffect::onSetData(const GrGLProgramDataManager& pdman,
                                   const GrProcessor& proc) {
     const GrRRectBlurEffect& brre = proc.cast<GrRRectBlurEffect>();
     SkRRect rrect = brre.getRRect();
 
     float blurRadius = 3.f*SkScalarCeilToScalar(brre.getSigma()-1/6.0f);
     pdman.set1f(fBlurRadiusUniform, blurRadius);
 
@@ skipping 178 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