Allow negative values in SkBlurImageFilter sigma.

src/effects/SkBlurImageFilter.cpp

 /*
  * Copyright 2011 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 "SkBitmap.h"
 #include "SkBlurImageFilter.h"
 #include "SkColorPriv.h"
 #include "SkReadBuffer.h"
 #include "SkWriteBuffer.h"
 #include "SkGpuBlurUtils.h"
 #include "SkBlurImage_opts.h"
 #if SK_SUPPORT_GPU
 #include "GrContext.h"
 #endif
 
 // This rather arbitrary-looking value results in a maximum box blur kernel size
 // of 1000 pixels on the raster path, which matches the WebKit and Firefox
 // implementations. Since the GPU path does not compute a box blur, putting
 // the limit on sigma ensures consistent behaviour between the GPU and
 // raster paths.
 #define MAX_SIGMA SkIntToScalar(532)
 
+static SkVector mapSigma(const SkSize& localSigma, const SkMatrix& ctm) {
+    SkVector sigma = SkVector::Make(localSigma.width(), localSigma.height());
+    ctm.mapVectors(&sigma, 1);
+    sigma.fX = SkMinScalar(sigma.fX, MAX_SIGMA);
+    sigma.fY = SkMinScalar(sigma.fY, MAX_SIGMA);

[sugoi1, 2014/09/09 15:42:39]

Shouldn't this happen after line 37? What if sigma.fX is a very large negative
number?

Or why not just replace lines 29 to 37 by :
sigma.fX = SkMinScalar(SkScalarAbs(sigma.fX), MAX_SIGMA);
sigma.fY = SkMinScalar(SkScalarAbs(sigma.fY), MAX_SIGMA);

[Stephen White, 2014/09/09 16:03:59]

Good catch. Fixed.

+    if (sigma.fX < 0) {

[reed1, 2014/09/09 15:37:38]

SkScalarAbs() 

[Stephen White, 2014/09/09 15:48:15]

Done.

+        sigma.fX = -sigma.fX;
+    }
+
+    if (sigma.fY < 0) {
+        sigma.fY = -sigma.fY;
+    }
+    return sigma;
+}
+
 #ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
 SkBlurImageFilter::SkBlurImageFilter(SkReadBuffer& buffer)
   : INHERITED(1, buffer) {
     fSigma.fWidth = buffer.readScalar();
     fSigma.fHeight = buffer.readScalar();
     buffer.validate(SkScalarIsFinite(fSigma.fWidth) &&
-                    SkScalarIsFinite(fSigma.fHeight) &&
-                    (fSigma.fWidth >= 0) &&
-                    (fSigma.fHeight >= 0));
+                    SkScalarIsFinite(fSigma.fHeight));
 }
 #endif
 
 SkBlurImageFilter::SkBlurImageFilter(SkScalar sigmaX,
                                      SkScalar sigmaY,
                                      SkImageFilter* input,
                                      const CropRect* cropRect,
                                      uint32_t uniqueID)
     : INHERITED(1, &input, cropRect, uniqueID), fSigma(SkSize::Make(sigmaX, sigmaY)) {
 }
@@ skipping 125 matching lines @@
     SkAutoLockPixels alp(src);
     if (!src.getPixels()) {
         return false;
     }
 
     if (!dst->tryAllocPixels(src.info().makeWH(srcBounds.width(), srcBounds.height()))) {
         return false;
     }
     dst->getBounds(&dstBounds);
 
-    SkVector sigma = SkVector::Make(fSigma.width(), fSigma.height());
-    ctx.ctm().mapVectors(&sigma, 1);
-    sigma.fX = SkMinScalar(sigma.fX, MAX_SIGMA);
-    sigma.fY = SkMinScalar(sigma.fY, MAX_SIGMA);
+    SkVector sigma = mapSigma(fSigma, ctx.ctm());
 
     int kernelSizeX, kernelSizeX3, lowOffsetX, highOffsetX;
     int kernelSizeY, kernelSizeY3, lowOffsetY, highOffsetY;
     getBox3Params(sigma.x(), &kernelSizeX, &kernelSizeX3, &lowOffsetX, &highOffsetX);
     getBox3Params(sigma.y(), &kernelSizeY, &kernelSizeY3, &lowOffsetY, &highOffsetY);
 
     if (kernelSizeX < 0 || kernelSizeY < 0) {
         return false;
     }
 
@@ skipping 52 matching lines @@
         *dst = src;
     }
 
     dst->outset(SkScalarMul(fSigma.width(), SkIntToScalar(3)),
                 SkScalarMul(fSigma.height(), SkIntToScalar(3)));
 }
 
 bool SkBlurImageFilter::onFilterBounds(const SkIRect& src, const SkMatrix& ctm,
                                        SkIRect* dst) const {
     SkIRect bounds = src;
-    SkVector sigma = SkVector::Make(fSigma.width(), fSigma.height());
-    ctm.mapVectors(&sigma, 1);
+    SkVector sigma = mapSigma(fSigma, ctm);
     bounds.outset(SkScalarCeilToInt(SkScalarMul(sigma.x(), SkIntToScalar(3))),
                   SkScalarCeilToInt(SkScalarMul(sigma.y(), SkIntToScalar(3))));
     if (getInput(0) && !getInput(0)->filterBounds(bounds, ctm, &bounds)) {
         return false;
     }
     *dst = bounds;
     return true;
 }
 
 bool SkBlurImageFilter::filterImageGPU(Proxy* proxy, const SkBitmap& src, const Context& ctx,
                                        SkBitmap* result, SkIPoint* offset) const {
 #if SK_SUPPORT_GPU
     SkBitmap input = src;
     SkIPoint srcOffset = SkIPoint::Make(0, 0);
     if (getInput(0) && !getInput(0)->getInputResultGPU(proxy, src, ctx, &input, &srcOffset)) {
         return false;
     }
     SkIRect rect;
     if (!this->applyCropRect(ctx, proxy, input, &srcOffset, &rect, &input)) {
         return false;
     }
     GrTexture* source = input.getTexture();
-    SkVector sigma = SkVector::Make(fSigma.width(), fSigma.height());
-    ctx.ctm().mapVectors(&sigma, 1);
-    sigma.fX = SkMinScalar(sigma.fX, MAX_SIGMA);
-    sigma.fY = SkMinScalar(sigma.fY, MAX_SIGMA);
+    SkVector sigma = mapSigma(fSigma, ctx.ctm());
     offset->fX = rect.fLeft;
     offset->fY = rect.fTop;
     rect.offset(-srcOffset);
     SkAutoTUnref<GrTexture> tex(SkGpuBlurUtils::GaussianBlur(source->getContext(),
                                                              source,
                                                              false,
                                                              SkRect::Make(rect),
                                                              true,
                                                              sigma.x(),
                                                              sigma.y()));
     WrapTexture(tex, rect.width(), rect.height(), result);
     return true;
 #else
     SkDEBUGFAIL("Should not call in GPU-less build");
     return false;
 #endif
 }