Optimize the blur convolution by only applying domain clamping where necessary. Split the blur con…

src/effects/SkGpuBlurUtils.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkGpuBlurUtils.h"
 
 #include "SkRect.h"
@@ skipping 22 matching lines @@
     while (sigma > MAX_BLUR_SIGMA) {
         *scaleFactor *= 2;
         sigma *= 0.5f;
     }
     *radius = static_cast<int>(ceilf(sigma * 3.0f));
     GrAssert(*radius <= GrConvolutionEffect::kMaxKernelRadius);
     return sigma;
 }
 
 static void convolve_gaussian(GrContext* context,
-                              GrTexture* texture,
                               const SkRect& srcRect,
                               const SkRect& dstRect,
-                              bool cropToSrcRect,
+                              GrTexture* texture,
+                              Gr1DKernelEffect::Direction direction,
+                              int radius,
                               float sigma,
-                              int radius,
-                              Gr1DKernelEffect::Direction direction) {
+                              bool useBounds,
+                              float bounds[2]) {
     GrPaint paint;
     paint.reset();
-    float bounds[2] = { 0.0f, 1.0f };
-    if (cropToSrcRect) {
-        if (direction == Gr1DKernelEffect::kX_Direction) {
-            bounds[0] = SkScalarToFloat(srcRect.left()) / texture->width();
-            bounds[1] = SkScalarToFloat(srcRect.right()) / texture->width();
-        } else {
-            bounds[0] = SkScalarToFloat(srcRect.top()) / texture->height();
-            bounds[1] = SkScalarToFloat(srcRect.bottom()) / texture->height();
-        }
-    }
-
-    SkAutoTUnref<GrEffectRef> conv(GrConvolutionEffect::CreateGaussian(texture,
-                                                                       direction,
-                                                                       radius,
-                                                                       sigma,
-                                                                       cropToSrcRect,
-                                                                       bounds));
+    SkAutoTUnref<GrEffectRef> conv(GrConvolutionEffect::CreateGaussian(
+        texture, direction, radius, sigma, useBounds, bounds));
+    paint.reset();
     paint.addColorEffect(conv);
     context->drawRectToRect(paint, dstRect, srcRect);
 }
 
+static void convolve_gaussian(GrContext* context,
+                              const SkRect& srcRect,
+                              const SkRect& dstRect,
+                              GrTexture* texture,
+                              Gr1DKernelEffect::Direction direction,
+                              int radius,
+                              float sigma,
+                              bool cropToSrcRect) {
+    float bounds[2] = { 0.0f, 1.0f };
+    if (!cropToSrcRect) {
+        convolve_gaussian(context, srcRect, dstRect, texture,
+                          direction, radius, sigma, false, bounds);
+        return;
+    }
+    SkRect lowerSrcRect = srcRect, lowerDstRect = dstRect;
+    SkRect middleSrcRect = srcRect, middleDstRect = dstRect;
+    SkRect upperSrcRect = srcRect, upperDstRect = dstRect;
+    SkScalar size;
+    SkScalar rad = SkIntToScalar(radius);
+    if (direction == Gr1DKernelEffect::kX_Direction) {
+        bounds[0] = SkScalarToFloat(srcRect.left()) / texture->width();
+        bounds[1] = SkScalarToFloat(srcRect.right()) / texture->width();
+        size = srcRect.width();
+        lowerSrcRect.fRight = srcRect.left() + rad;
+        lowerDstRect.fRight = dstRect.left() + rad;
+        upperSrcRect.fLeft = srcRect.right() - rad;
+        upperDstRect.fLeft = dstRect.right() - rad;
+        middleSrcRect.inset(rad, 0);
+        middleDstRect.inset(rad, 0);
+    } else {
+        bounds[0] = SkScalarToFloat(srcRect.top()) / texture->height();
+        bounds[1] = SkScalarToFloat(srcRect.bottom()) / texture->height();
+        size = srcRect.height();
+        lowerSrcRect.fBottom = srcRect.top() + rad;
+        lowerDstRect.fBottom = dstRect.top() + rad;
+        upperSrcRect.fTop = srcRect.bottom() - rad;
+        upperDstRect.fTop = dstRect.bottom() - rad;
+        middleSrcRect.inset(0, rad);
+        middleDstRect.inset(0, rad);
+    }
+    if (radius >= size * SK_ScalarHalf) {
+        // Blur radius covers srcRect; use bounds over entire draw
+        convolve_gaussian(context, srcRect, dstRect, texture,
+                          direction, radius, sigma, true, bounds);
+    } else {
+        // Draw upper and lower margins with bounds; middle without.
+        convolve_gaussian(context, lowerSrcRect, lowerDstRect, texture,
+                          direction, radius, sigma, true, bounds);
+        convolve_gaussian(context, upperSrcRect, upperDstRect, texture,
+                          direction, radius, sigma, true, bounds);
+        convolve_gaussian(context, middleSrcRect, middleDstRect, texture,
+                          direction, radius, sigma, false, bounds);
+    }
+}
+
 GrTexture* GaussianBlur(GrContext* context,
                         GrTexture* srcTexture,
                         bool canClobberSrc,
                         const SkRect& rect,
                         bool cropToRect,
                         float sigmaX,
                         float sigmaY) {
     GrAssert(NULL != context);
 
     GrContext::AutoRenderTarget art(context);
@@ skipping 69 matching lines @@
     if (sigmaX > 0.0f) {
         if (scaleFactorX > 1) {
             // Clear out a radius to the right of the srcRect to prevent the
             // X convolution from reading garbage.
             clearRect = SkIRect::MakeXYWH(srcIRect.fRight, srcIRect.fTop,
                                           radiusX, srcIRect.height());
             context->clear(&clearRect, 0x0);
         }
         context->setRenderTarget(dstTexture->asRenderTarget());
         SkRect dstRect = SkRect::MakeWH(srcRect.width(), srcRect.height());
-        convolve_gaussian(context, srcTexture, srcRect, dstRect, cropToRect,
-                          sigmaX, radiusX, Gr1DKernelEffect::kX_Direction);
+        convolve_gaussian(context, srcRect, dstRect, srcTexture,
+                          Gr1DKernelEffect::kX_Direction, radiusX, sigmaX, cropToRect);
         srcTexture = dstTexture;
         srcRect = dstRect;
         SkTSwap(dstTexture, tempTexture);
     }
 
     if (sigmaY > 0.0f) {
         if (scaleFactorY > 1 || sigmaX > 0.0f) {
             // Clear out a radius below the srcRect to prevent the Y
             // convolution from reading garbage.
             clearRect = SkIRect::MakeXYWH(srcIRect.fLeft, srcIRect.fBottom,
                                           srcIRect.width(), radiusY);
             context->clear(&clearRect, 0x0);
         }
 
         context->setRenderTarget(dstTexture->asRenderTarget());
         SkRect dstRect = SkRect::MakeWH(srcRect.width(), srcRect.height());
-        convolve_gaussian(context, srcTexture, srcRect, dstRect, cropToRect,
-                          sigmaY, radiusY, Gr1DKernelEffect::kY_Direction);
+        convolve_gaussian(context, srcRect, dstRect, srcTexture,
+                          Gr1DKernelEffect::kY_Direction, radiusY, sigmaY, cropToRect);
         srcTexture = dstTexture;
         srcRect = dstRect;
         SkTSwap(dstTexture, tempTexture);
     }
 
     if (scaleFactorX > 1 || scaleFactorY > 1) {
         // Clear one pixel to the right and below, to accommodate bilinear
         // upsampling.
         clearRect = SkIRect::MakeXYWH(srcIRect.fLeft, srcIRect.fBottom,
                                       srcIRect.width() + 1, 1);
@@ skipping 22 matching lines @@
     } else if (srcTexture == temp2.texture()) {
         return temp2.detach();
     } else {
         srcTexture->ref();
         return srcTexture;
     }
 }
 #endif
 
 }