Make SkBlurImageFilter capable of cropping during blur

src/opts/SkBlurImageFilter_opts.h

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkBlurImageFilter_opts_DEFINED
 #define SkBlurImageFilter_opts_DEFINED
 
@@ skipping 66 matching lines @@
         vst1_lane_u32(dptr + width, px2, 1); \
     } else { \
         vst1_u8((uint8_t*)dptr, vmovn_u16(resultPixels)); \
     }
 
 #define INCREMENT_SUMS_DOUBLE(p) sum = vaddw_u8(sum, load_2_pixels(p))
 #define DECREMENT_SUMS_DOUBLE(p) sum = vsubw_u8(sum, load_2_pixels(p))
 
 // Fast path for kernel sizes between 2 and 127, working on two rows at a time.
 template<BlurDirection srcDirection, BlurDirection dstDirection>
-void box_blur_double(const SkPMColor** src, int srcStride, SkPMColor** dst, int kernelSize,
-                     int leftOffset, int rightOffset, int width, int* height) {
+int box_blur_double(const SkPMColor** src, int srcStride, const SkIRect& srcBounds, SkPMColor** dst, int kernelSize,
+                     int leftOffset, int rightOffset, int width, int height) {
     // Load 2 pixels from adjacent rows.
     auto load_2_pixels = [&](const SkPMColor* s) {
         if (srcDirection == BlurDirection::kX) {
             // 10% faster by adding these 2 prefetches
             SK_PREFETCH(s + 16);
             SK_PREFETCH(s + 16 + srcStride);
             auto one = vld1_lane_u32(s +         0, vdup_n_u32(0), 0),
                  two = vld1_lane_u32(s + srcStride,           one, 1);
             return vreinterpret_u8_u32(two);
         } else {
             return vld1_u8((uint8_t*)s);
         }
     };
-    int incrementStart = SkMax32(-rightOffset - 1, -width);
-    int incrementEnd = SkMax32(width - rightOffset - 1, 0);
-    int decrementStart = SkMin32(leftOffset, width);
+    int left = srcBounds.left();
+    int right = srcBounds.right();
+    int top = srcBounds.top();
+    int bottom = srcBounds.bottom();
+    int incrementStart = SkMax32(left - rightOffset - 1, -width);
+    int incrementEnd = SkMax32(right - rightOffset - 1, 0);
+    int decrementStart = SkMin32(left + leftOffset, width);
+    int decrementEnd = SkMin32(right + leftOffset, width);
     const int srcStrideX = srcDirection == BlurDirection::kX ? 1 : srcStride;
-    const int dstStrideX = dstDirection == BlurDirection::kX ? 1 : *height;
+    const int dstStrideX = dstDirection == BlurDirection::kX ? 1 : height;
     const int srcStrideY = srcDirection == BlurDirection::kX ? srcStride : 1;
     const int dstStrideY = dstDirection == BlurDirection::kX ? width : 1;
     const uint16x8_t scale = vdupq_n_u16((1 << 15) / kernelSize);
 
-    for (; *height >= 2; *height -= 2) {
+    for (; bottom - top >= 2; top += 2) {
         uint16x8_t sum = vdupq_n_u16(0);
         const SkPMColor* lptr = *src;
         const SkPMColor* rptr = *src;
         SkPMColor* dptr = *dst;
         int x;
         for (x = incrementStart; x < 0; ++x) {
             INCREMENT_SUMS_DOUBLE(rptr);
             rptr += srcStrideX;
         }
+        for (x = 0; x < incrementStart; ++x) {
+            STORE_SUMS_DOUBLE

[mtklein, 2015/11/02 16:55:44]

Should we not be zeroing here and at 155?

[Stephen White, 2015/11/02 17:08:58]

We are: "sum" is always zero in both cases. It's zero here because we
initialized it to zero at 117 (and the loop above this one does nothing in this
case, since incrementStart > 0), and it's zero at the end because we've
decremented all the pixels off, leaving it at zero.

+            dptr += dstStrideX;
+        }
         for (; x < decrementStart && x < incrementEnd; ++x) {
             STORE_SUMS_DOUBLE
             dptr += dstStrideX;
             INCREMENT_SUMS_DOUBLE(rptr);
             rptr += srcStrideX;
         }
         for (x = decrementStart; x < incrementEnd; ++x) {
             STORE_SUMS_DOUBLE
             dptr += dstStrideX;
             INCREMENT_SUMS_DOUBLE(rptr);
             rptr += srcStrideX;
             DECREMENT_SUMS_DOUBLE(lptr);
             lptr += srcStrideX;
         }
         for (x = incrementEnd; x < decrementStart; ++x) {
             STORE_SUMS_DOUBLE
             dptr += dstStrideX;
         }
-        for (; x < width; ++x) {
+        for (; x < decrementEnd; ++x) {
             STORE_SUMS_DOUBLE
             dptr += dstStrideX;
             DECREMENT_SUMS_DOUBLE(lptr);
             lptr += srcStrideX;
         }
+        for (; x < width; ++x) {
+            STORE_SUMS_DOUBLE
+            dptr += dstStrideX;
+        }
         *src += srcStrideY * 2;
         *dst += dstStrideY * 2;
     }
+    return top;
 }
 
 // ARGB -> 0A0R 0G0B
 static inline uint16x4_t expand(SkPMColor p) {
     return vget_low_u16(vmovl_u8(vreinterpret_u8_u32(vdup_n_u32(p))));
 };
 
 #define INIT_SCALE const uint32x4_t scale = vdupq_n_u32((1 << 24) / kernelSize);
 #define INIT_HALF const uint32x4_t half = vdupq_n_u32(1 << 23);
 #define INIT_SUMS uint32x4_t sum = vdupq_n_u32(0);
 #define INCREMENT_SUMS(c) sum = vaddw_u16(sum, expand(c));
 #define DECREMENT_SUMS(c) sum = vsubw_u16(sum, expand(c));
 
 #define STORE_SUMS \
     uint32x4_t result = vmlaq_u32(half, sum, scale); \
     uint16x4_t result16 = vqshrn_n_u32(result, 16); \
     uint8x8_t result8 = vqshrn_n_u16(vcombine_u16(result16, result16), 8); \
     vst1_lane_u32(dptr, vreinterpret_u32_u8(result8), 0);
 
 #define DOUBLE_ROW_OPTIMIZATION \
     if (1 < kernelSize && kernelSize < 128) { \
-        box_blur_double<srcDirection, dstDirection>(&src, srcStride, &dst, kernelSize, \
-                                                    leftOffset, rightOffset, width, &height); \
+        top = box_blur_double<srcDirection, dstDirection>(&src, srcStride, srcBounds, &dst, \
+                                                          kernelSize, leftOffset, rightOffset, \
+                                                          width, height); \
     }
 
 #else  // Neither NEON nor >=SSE2.
 
 #define INIT_SCALE uint32_t scale = (1 << 24) / kernelSize;
 #define INIT_HALF  uint32_t half = 1 << 23;
 #define INIT_SUMS int sumA = 0, sumR = 0, sumG = 0, sumB = 0;
 #define INCREMENT_SUMS(c) \
     sumA += SkGetPackedA32(c); \
     sumR += SkGetPackedR32(c); \
@@ skipping 12 matching lines @@
 #define DOUBLE_ROW_OPTIMIZATION
 
 #endif
 
 #define PREFETCH_RPTR \
     if (srcDirection == BlurDirection::kY) { \
         SK_PREFETCH(rptr); \
     }
 
 template<BlurDirection srcDirection, BlurDirection dstDirection>
-static void box_blur(const SkPMColor* src, int srcStride, SkPMColor* dst, int kernelSize,
-                     int leftOffset, int rightOffset, int width, int height) {
-    int incrementStart = SkMax32(-rightOffset - 1, -width);
-    int incrementEnd = SkMax32(width - rightOffset - 1, 0);
-    int decrementStart = SkMin32(leftOffset, width);
+static void box_blur(const SkPMColor* src, int srcStride, const SkIRect& srcBounds, SkPMColor* dst,
+                     int kernelSize, int leftOffset, int rightOffset, int width, int height) {
+    int left = srcBounds.left();
+    int right = srcBounds.right();
+    int top = srcBounds.top();
+    int bottom = srcBounds.bottom();
+    int incrementStart = SkMax32(left - rightOffset - 1, -width);
+    int incrementEnd = SkMax32(right - rightOffset - 1, 0);
+    int decrementStart = SkMin32(left + leftOffset, width);
+    int decrementEnd = SkMin32(right + leftOffset, width);
     int srcStrideX = srcDirection == BlurDirection::kX ? 1 : srcStride;
     int dstStrideX = dstDirection == BlurDirection::kX ? 1 : height;
     int srcStrideY = srcDirection == BlurDirection::kX ? srcStride : 1;
     int dstStrideY = dstDirection == BlurDirection::kX ? width : 1;
     INIT_SCALE
     INIT_HALF
 
+    // Clear to zero when sampling above our domain.
+    for (int y = 0; y < top; y++) {
+        SkColor* dptr = dst;
+        for (int x = 0; x < width; ++x) {
+            *dptr = 0;
+            dptr += dstStrideX;
+        }
+        dst += dstStrideY;
+    }
+
     DOUBLE_ROW_OPTIMIZATION
 
-    for (int y = 0; y < height; ++y) {
+    for (int y = top; y < bottom; ++y) {
         INIT_SUMS
         const SkPMColor* lptr = src;
         const SkPMColor* rptr = src;
         SkColor* dptr = dst;
         int x;
         for (x = incrementStart; x < 0; ++x) {
             INCREMENT_SUMS(*rptr);
             rptr += srcStrideX;
             PREFETCH_RPTR
         }
+        // Clear to zero when sampling to the left of our domain.
+        for (x = 0; x < incrementStart; ++x) {
+            *dptr = 0;
+            dptr += dstStrideX;
+        }
         for (; x < decrementStart && x < incrementEnd; ++x) {
             STORE_SUMS
             dptr += dstStrideX;
             INCREMENT_SUMS(*rptr);
             rptr += srcStrideX;
             PREFETCH_RPTR
         }
         for (x = decrementStart; x < incrementEnd; ++x) {
             STORE_SUMS
             dptr += dstStrideX;
             INCREMENT_SUMS(*rptr);
             rptr += srcStrideX;
             PREFETCH_RPTR
             DECREMENT_SUMS(*lptr);
             lptr += srcStrideX;
         }
         for (x = incrementEnd; x < decrementStart; ++x) {
             STORE_SUMS
             dptr += dstStrideX;
         }
-        for (; x < width; ++x) {
+        for (; x < decrementEnd; ++x) {
             STORE_SUMS
             dptr += dstStrideX;
             DECREMENT_SUMS(*lptr);
             lptr += srcStrideX;
         }
+        // Clear to zero when sampling to the right of our domain.
+        for (; x < width; ++x) {
+            *dptr = 0;
+            dptr += dstStrideX;
+        }
         src += srcStrideY;
         dst += dstStrideY;
     }
+    // Clear to zero when sampling below our domain.
+    for (int y = bottom; y < height; ++y) {
+        SkColor* dptr = dst;
+        for (int x = 0; x < width; ++x) {
+            *dptr = 0;
+            dptr += dstStrideX;
+        }
+        dst += dstStrideY;
+    }
 }
 
 static auto box_blur_xx = &box_blur<BlurDirection::kX, BlurDirection::kX>,
             box_blur_xy = &box_blur<BlurDirection::kX, BlurDirection::kY>,
             box_blur_yx = &box_blur<BlurDirection::kY, BlurDirection::kX>;
 
 }  // namespace SK_OPTS_NS
 
 #endif