blob: 6c5ef269d7ea3b357ccc5aa5873f45d29319dc0e [file] [log] [blame]
epoger@google.comec3ed6a2011-07-28 14:26:00 +00001/*
2 * Copyright 2011 Google Inc.
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
reed@google.comdaaafa62014-04-29 15:20:16 +00007
robertphillips@google.com3dfa4cc2013-09-05 16:39:03 +00008#include "SkBlurMask.h"
reed@google.com2b75f422011-07-07 13:43:38 +00009#include "SkBlurMaskFilter.h"
reed@google.comdaaafa62014-04-29 15:20:16 +000010#include "SkBlurDrawLooper.h"
reedfb8c1fc2015-08-04 18:44:56 -070011#include "SkCanvas.h"
mtklein7a1f45f2016-08-04 06:19:33 -070012#include "SkColorFilter.h"
bungemand3ebb482015-08-05 13:57:49 -070013#include "SkEmbossMaskFilter.h"
14#include "SkLayerDrawLooper.h"
tomhudson@google.com889bd8b2011-09-27 17:38:17 +000015#include "SkMath.h"
bungeman@google.com5af16f82011-09-02 15:06:44 +000016#include "SkPaint.h"
bungemand3ebb482015-08-05 13:57:49 -070017#include "SkPath.h"
Florin Malita1ba5bfe2017-11-28 17:54:23 -050018#include "SkPerlinNoiseShader.h"
19#include "SkSurface.h"
tfarina@chromium.org4ee16bf2014-01-10 22:08:27 +000020#include "Test.h"
tfarina@chromium.org4ee16bf2014-01-10 22:08:27 +000021
robertphillips@google.com3dfa4cc2013-09-05 16:39:03 +000022#if SK_SUPPORT_GPU
23#include "GrContextFactory.h"
24#include "SkGpuDevice.h"
25#endif
26
27#define WRITE_CSV 0
reed@google.com2b75f422011-07-07 13:43:38 +000028
29///////////////////////////////////////////////////////////////////////////////
30
31#define ILLEGAL_MODE ((SkXfermode::Mode)-1)
32
bungeman@google.com5af16f82011-09-02 15:06:44 +000033static const int outset = 100;
34static const SkColor bgColor = SK_ColorWHITE;
35static const int strokeWidth = 4;
36
commit-bot@chromium.orgfa9e5fa2014-02-13 22:00:04 +000037static void create(SkBitmap* bm, const SkIRect& bound) {
38 bm->allocN32Pixels(bound.width(), bound.height());
bungeman@google.com5af16f82011-09-02 15:06:44 +000039}
40
41static void drawBG(SkCanvas* canvas) {
42 canvas->drawColor(bgColor);
43}
44
45
46struct BlurTest {
47 void (*addPath)(SkPath*);
48 int viewLen;
49 SkIRect views[9];
50};
51
52//Path Draw Procs
53//Beware that paths themselves my draw differently depending on the clip.
54static void draw50x50Rect(SkPath* path) {
55 path->addRect(0, 0, SkIntToScalar(50), SkIntToScalar(50));
56}
57
58//Tests
59static BlurTest tests[] = {
60 { draw50x50Rect, 3, {
61 //inner half of blur
62 { 0, 0, 50, 50 },
63 //blur, but no path.
64 { 50 + strokeWidth/2, 50 + strokeWidth/2, 100, 100 },
65 //just an edge
66 { 40, strokeWidth, 60, 50 - strokeWidth },
67 }},
68};
69
70/** Assumes that the ref draw was completely inside ref canvas --
71 implies that everything outside is "bgColor".
72 Checks that all overlap is the same and that all non-overlap on the
73 ref is "bgColor".
74 */
75static bool compare(const SkBitmap& ref, const SkIRect& iref,
76 const SkBitmap& test, const SkIRect& itest)
77{
78 const int xOff = itest.fLeft - iref.fLeft;
79 const int yOff = itest.fTop - iref.fTop;
80
bungeman@google.com5af16f82011-09-02 15:06:44 +000081 for (int y = 0; y < test.height(); ++y) {
82 for (int x = 0; x < test.width(); ++x) {
83 SkColor testColor = test.getColor(x, y);
84 int refX = x + xOff;
85 int refY = y + yOff;
86 SkColor refColor;
87 if (refX >= 0 && refX < ref.width() &&
88 refY >= 0 && refY < ref.height())
89 {
90 refColor = ref.getColor(refX, refY);
91 } else {
92 refColor = bgColor;
93 }
94 if (refColor != testColor) {
95 return false;
96 }
97 }
98 }
99 return true;
100}
101
kkinnunen15302832015-12-01 04:35:26 -0800102DEF_TEST(BlurDrawing, reporter) {
bungeman@google.com5af16f82011-09-02 15:06:44 +0000103 SkPaint paint;
104 paint.setColor(SK_ColorGRAY);
105 paint.setStyle(SkPaint::kStroke_Style);
106 paint.setStrokeWidth(SkIntToScalar(strokeWidth));
reed@google.com2b75f422011-07-07 13:43:38 +0000107
robertphillips@google.comb7061172013-09-06 14:16:12 +0000108 SkScalar sigma = SkBlurMask::ConvertRadiusToSigma(SkIntToScalar(5));
commit-bot@chromium.orge3964552014-04-28 16:25:35 +0000109 for (int style = 0; style <= kLastEnum_SkBlurStyle; ++style) {
110 SkBlurStyle blurStyle = static_cast<SkBlurStyle>(style);
reed@google.com2b75f422011-07-07 13:43:38 +0000111
bungeman@google.com5af16f82011-09-02 15:06:44 +0000112 const uint32_t flagPermutations = SkBlurMaskFilter::kAll_BlurFlag;
113 for (uint32_t flags = 0; flags < flagPermutations; ++flags) {
reedefdfd512016-04-04 10:02:58 -0700114 paint.setMaskFilter(SkBlurMaskFilter::Make(blurStyle, sigma, flags));
bungeman@google.com5af16f82011-09-02 15:06:44 +0000115
tomhudson@google.com83a44462011-10-27 15:27:51 +0000116 for (size_t test = 0; test < SK_ARRAY_COUNT(tests); ++test) {
bungeman@google.com5af16f82011-09-02 15:06:44 +0000117 SkPath path;
118 tests[test].addPath(&path);
bungeman@google.comd16872c2011-09-02 15:46:17 +0000119 SkPath strokedPath;
120 paint.getFillPath(path, &strokedPath);
121 SkRect refBound = strokedPath.getBounds();
bungeman@google.com5af16f82011-09-02 15:06:44 +0000122 SkIRect iref;
123 refBound.roundOut(&iref);
bungeman@google.comd16872c2011-09-02 15:46:17 +0000124 iref.inset(-outset, -outset);
bungeman@google.com5af16f82011-09-02 15:06:44 +0000125 SkBitmap refBitmap;
commit-bot@chromium.orgfa9e5fa2014-02-13 22:00:04 +0000126 create(&refBitmap, iref);
bungeman@google.com5af16f82011-09-02 15:06:44 +0000127
128 SkCanvas refCanvas(refBitmap);
129 refCanvas.translate(SkIntToScalar(-iref.fLeft),
130 SkIntToScalar(-iref.fTop));
131 drawBG(&refCanvas);
132 refCanvas.drawPath(path, paint);
133
134 for (int view = 0; view < tests[test].viewLen; ++view) {
135 SkIRect itest = tests[test].views[view];
136 SkBitmap testBitmap;
commit-bot@chromium.orgfa9e5fa2014-02-13 22:00:04 +0000137 create(&testBitmap, itest);
bungeman@google.com5af16f82011-09-02 15:06:44 +0000138
139 SkCanvas testCanvas(testBitmap);
140 testCanvas.translate(SkIntToScalar(-itest.fLeft),
141 SkIntToScalar(-itest.fTop));
142 drawBG(&testCanvas);
143 testCanvas.drawPath(path, paint);
144
145 REPORTER_ASSERT(reporter,
146 compare(refBitmap, iref, testBitmap, itest));
147 }
148 }
149 }
reed@google.com2b75f422011-07-07 13:43:38 +0000150 }
151}
152
robertphillips@google.com3dfa4cc2013-09-05 16:39:03 +0000153///////////////////////////////////////////////////////////////////////////////
154
155// Use SkBlurMask::BlurGroundTruth to blur a 'width' x 'height' solid
156// white rect. Return the right half of the middle row in 'result'.
skia.committer@gmail.com6fc1b492013-09-06 07:01:45 +0000157static void ground_truth_2d(int width, int height,
robertphillips@google.com3dfa4cc2013-09-05 16:39:03 +0000158 SkScalar sigma,
159 int* result, int resultCount) {
160 SkMask src, dst;
161
162 src.fBounds.set(0, 0, width, height);
163 src.fFormat = SkMask::kA8_Format;
164 src.fRowBytes = src.fBounds.width();
165 src.fImage = SkMask::AllocImage(src.computeTotalImageSize());
166
167 memset(src.fImage, 0xff, src.computeTotalImageSize());
168
robertphillipse80eb922015-12-17 11:33:12 -0800169 if (!SkBlurMask::BlurGroundTruth(sigma, &dst, src, kNormal_SkBlurStyle)) {
170 return;
171 }
robertphillips@google.com3dfa4cc2013-09-05 16:39:03 +0000172
173 int midX = dst.fBounds.centerX();
174 int midY = dst.fBounds.centerY();
175 uint8_t* bytes = dst.getAddr8(midX, midY);
176 int i;
177 for (i = 0; i < dst.fBounds.width()-(midX-dst.fBounds.fLeft); ++i) {
178 if (i < resultCount) {
179 result[i] = bytes[i];
180 }
181 }
182 for ( ; i < resultCount; ++i) {
183 result[i] = 0;
184 }
robertphillips@google.com6d837aa2013-10-11 14:38:46 +0000185
186 SkMask::FreeImage(src.fImage);
187 SkMask::FreeImage(dst.fImage);
robertphillips@google.com3dfa4cc2013-09-05 16:39:03 +0000188}
189
190// Implement a step function that is 255 between min and max; 0 elsewhere.
191static int step(int x, SkScalar min, SkScalar max) {
192 if (min < x && x < max) {
193 return 255;
194 }
195 return 0;
196}
197
198// Implement a Gaussian function with 0 mean and std.dev. of 'sigma'.
199static float gaussian(int x, SkScalar sigma) {
robertphillips@google.comb85564a2013-09-05 17:53:34 +0000200 float k = SK_Scalar1/(sigma * sqrtf(2.0f*SK_ScalarPI));
robertphillips@google.com3dfa4cc2013-09-05 16:39:03 +0000201 float exponent = -(x * x) / (2 * sigma * sigma);
robertphillips@google.comb85564a2013-09-05 17:53:34 +0000202 return k * expf(exponent);
robertphillips@google.com3dfa4cc2013-09-05 16:39:03 +0000203}
204
205// Perform a brute force convolution of a step function with a Gaussian.
206// Return the right half in 'result'
skia.committer@gmail.com6fc1b492013-09-06 07:01:45 +0000207static void brute_force_1d(SkScalar stepMin, SkScalar stepMax,
robertphillips@google.com3dfa4cc2013-09-05 16:39:03 +0000208 SkScalar gaussianSigma,
209 int* result, int resultCount) {
210
211 int gaussianRange = SkScalarCeilToInt(10 * gaussianSigma);
212
213 for (int i = 0; i < resultCount; ++i) {
214 SkScalar sum = 0.0f;
215 for (int j = -gaussianRange; j < gaussianRange; ++j) {
216 sum += gaussian(j, gaussianSigma) * step(i-j, stepMin, stepMax);
217 }
218
219 result[i] = SkClampMax(SkClampPos(int(sum + 0.5f)), 255);
220 }
221}
222
skia.committer@gmail.com6fc1b492013-09-06 07:01:45 +0000223static void blur_path(SkCanvas* canvas, const SkPath& path,
robertphillips@google.com3dfa4cc2013-09-05 16:39:03 +0000224 SkScalar gaussianSigma) {
225
226 SkScalar midX = path.getBounds().centerX();
227 SkScalar midY = path.getBounds().centerY();
228
229 canvas->translate(-midX, -midY);
230
231 SkPaint blurPaint;
232 blurPaint.setColor(SK_ColorWHITE);
reedefdfd512016-04-04 10:02:58 -0700233 blurPaint.setMaskFilter(SkBlurMaskFilter::Make(kNormal_SkBlurStyle, gaussianSigma,
234 SkBlurMaskFilter::kHighQuality_BlurFlag));
robertphillips@google.com3dfa4cc2013-09-05 16:39:03 +0000235
236 canvas->drawColor(SK_ColorBLACK);
237 canvas->drawPath(path, blurPaint);
238}
239
240// Readback the blurred draw results from the canvas
Mike Reedf1942192017-07-21 14:24:29 -0400241static void readback(const SkBitmap& src, int* result, int resultCount) {
robertphillips@google.com3dfa4cc2013-09-05 16:39:03 +0000242 SkBitmap readback;
commit-bot@chromium.orgfa9e5fa2014-02-13 22:00:04 +0000243 readback.allocN32Pixels(resultCount, 30);
Mike Reedf1942192017-07-21 14:24:29 -0400244 SkPixmap pm;
245 readback.peekPixels(&pm);
246 src.readPixels(pm, 0, 0);
robertphillips@google.com3dfa4cc2013-09-05 16:39:03 +0000247
Mike Reedf1942192017-07-21 14:24:29 -0400248 const SkPMColor* pixels = pm.addr32(0, 15);
robertphillips@google.com3dfa4cc2013-09-05 16:39:03 +0000249
250 for (int i = 0; i < resultCount; ++i) {
251 result[i] = SkColorGetR(pixels[i]);
252 }
253}
254
skia.committer@gmail.com6fc1b492013-09-06 07:01:45 +0000255// Draw a blurred version of the provided path.
robertphillips@google.com3dfa4cc2013-09-05 16:39:03 +0000256// Return the right half of the middle row in 'result'.
257static void cpu_blur_path(const SkPath& path, SkScalar gaussianSigma,
258 int* result, int resultCount) {
259
260 SkBitmap bitmap;
commit-bot@chromium.orgfa9e5fa2014-02-13 22:00:04 +0000261 bitmap.allocN32Pixels(resultCount, 30);
robertphillips@google.com3dfa4cc2013-09-05 16:39:03 +0000262 SkCanvas canvas(bitmap);
263
264 blur_path(&canvas, path, gaussianSigma);
Mike Reedf1942192017-07-21 14:24:29 -0400265 readback(bitmap, result, resultCount);
robertphillips@google.com3dfa4cc2013-09-05 16:39:03 +0000266}
267
robertphillips@google.com3dfa4cc2013-09-05 16:39:03 +0000268#if WRITE_CSV
269static void write_as_csv(const char* label, SkScalar scale, int* data, int count) {
270 SkDebugf("%s_%.2f,", label, scale);
271 for (int i = 0; i < count-1; ++i) {
272 SkDebugf("%d,", data[i]);
273 }
274 SkDebugf("%d\n", data[count-1]);
275}
276#endif
277
278static bool match(int* first, int* second, int count, int tol) {
279 int delta;
280 for (int i = 0; i < count; ++i) {
281 delta = first[i] - second[i];
282 if (delta > tol || delta < -tol) {
283 return false;
284 }
285 }
286
287 return true;
288}
289
290// Test out the normal blur style with a wide range of sigmas
bsalomonf2f1c172016-04-05 12:59:06 -0700291DEF_TEST(BlurSigmaRange, reporter) {
robertphillips@google.com3dfa4cc2013-09-05 16:39:03 +0000292 static const int kSize = 100;
293
294 // The geometry is offset a smidge to trigger:
295 // https://code.google.com/p/chromium/issues/detail?id=282418
296 SkPath rectPath;
297 rectPath.addRect(0.3f, 0.3f, 100.3f, 100.3f);
298
299 SkPoint polyPts[] = {
300 { 0.3f, 0.3f },
301 { 100.3f, 0.3f },
302 { 100.3f, 100.3f },
303 { 0.3f, 100.3f },
304 { 2.3f, 50.3f } // a little divet to throw off the rect special case
305 };
306 SkPath polyPath;
307 polyPath.addPoly(polyPts, SK_ARRAY_COUNT(polyPts), true);
308
309 int rectSpecialCaseResult[kSize];
310 int generalCaseResult[kSize];
robertphillips@google.com3dfa4cc2013-09-05 16:39:03 +0000311 int groundTruthResult[kSize];
312 int bruteForce1DResult[kSize];
313
commit-bot@chromium.org4b413c82013-11-25 19:44:07 +0000314 SkScalar sigma = 10.0f;
robertphillips@google.com3dfa4cc2013-09-05 16:39:03 +0000315
316 for (int i = 0; i < 4; ++i, sigma /= 10) {
317
318 cpu_blur_path(rectPath, sigma, rectSpecialCaseResult, kSize);
319 cpu_blur_path(polyPath, sigma, generalCaseResult, kSize);
humper4a24cd82014-06-17 13:39:29 -0700320
robertphillips@google.com3dfa4cc2013-09-05 16:39:03 +0000321 ground_truth_2d(100, 100, sigma, groundTruthResult, kSize);
322 brute_force_1d(-50.0f, 50.0f, sigma, bruteForce1DResult, kSize);
323
324 REPORTER_ASSERT(reporter, match(rectSpecialCaseResult, bruteForce1DResult, kSize, 5));
325 REPORTER_ASSERT(reporter, match(generalCaseResult, bruteForce1DResult, kSize, 15));
robertphillips@google.com3dfa4cc2013-09-05 16:39:03 +0000326 REPORTER_ASSERT(reporter, match(groundTruthResult, bruteForce1DResult, kSize, 1));
327
328#if WRITE_CSV
329 write_as_csv("RectSpecialCase", sigma, rectSpecialCaseResult, kSize);
330 write_as_csv("GeneralCase", sigma, generalCaseResult, kSize);
331#if SK_SUPPORT_GPU
332 write_as_csv("GPU", sigma, gpuResult, kSize);
333#endif
334 write_as_csv("GroundTruth2D", sigma, groundTruthResult, kSize);
335 write_as_csv("BruteForce1D", sigma, bruteForce1DResult, kSize);
336#endif
337 }
338}
339
reed@google.comdaaafa62014-04-29 15:20:16 +0000340///////////////////////////////////////////////////////////////////////////////////////////
341
342static SkBlurQuality blurMaskFilterFlags_as_quality(uint32_t blurMaskFilterFlags) {
343 return (blurMaskFilterFlags & SkBlurMaskFilter::kHighQuality_BlurFlag) ?
344 kHigh_SkBlurQuality : kLow_SkBlurQuality;
345}
346
reed@google.comdaaafa62014-04-29 15:20:16 +0000347static void test_blurDrawLooper(skiatest::Reporter* reporter, SkScalar sigma,
348 SkBlurStyle style, uint32_t blurMaskFilterFlags) {
349 if (kNormal_SkBlurStyle != style) {
350 return; // blurdrawlooper only supports normal
351 }
352
353 const SkColor color = 0xFF335577;
354 const SkScalar dx = 10;
355 const SkScalar dy = -5;
Matt Sarettf160ad42017-03-23 16:23:38 -0400356 sk_sp<SkDrawLooper> lp(SkBlurDrawLooper::Make(color, sigma, dx, dy));
357 const bool expectSuccess = sigma > 0;
reed@google.comdaaafa62014-04-29 15:20:16 +0000358
reed7b380d02016-03-21 13:25:16 -0700359 if (nullptr == lp) {
reed@google.comdaaafa62014-04-29 15:20:16 +0000360 REPORTER_ASSERT(reporter, sigma <= 0);
361 } else {
362 SkDrawLooper::BlurShadowRec rec;
363 bool success = lp->asABlurShadow(&rec);
364 REPORTER_ASSERT(reporter, success == expectSuccess);
365 if (success) {
366 REPORTER_ASSERT(reporter, rec.fSigma == sigma);
367 REPORTER_ASSERT(reporter, rec.fOffset.x() == dx);
368 REPORTER_ASSERT(reporter, rec.fOffset.y() == dy);
369 REPORTER_ASSERT(reporter, rec.fColor == color);
370 REPORTER_ASSERT(reporter, rec.fStyle == style);
Matt Sarettf160ad42017-03-23 16:23:38 -0400371 REPORTER_ASSERT(reporter, rec.fQuality == kLow_SkBlurQuality);
reed@google.comdaaafa62014-04-29 15:20:16 +0000372 }
373 }
374}
375
reed7b380d02016-03-21 13:25:16 -0700376static void test_looper(skiatest::Reporter* reporter, sk_sp<SkDrawLooper> lp, SkScalar sigma,
377 SkBlurStyle style, SkBlurQuality quality, bool expectSuccess) {
reed@google.comdaaafa62014-04-29 15:20:16 +0000378 SkDrawLooper::BlurShadowRec rec;
379 bool success = lp->asABlurShadow(&rec);
380 REPORTER_ASSERT(reporter, success == expectSuccess);
381 if (success != expectSuccess) {
382 lp->asABlurShadow(&rec);
383 }
384 if (success) {
385 REPORTER_ASSERT(reporter, rec.fSigma == sigma);
386 REPORTER_ASSERT(reporter, rec.fStyle == style);
387 REPORTER_ASSERT(reporter, rec.fQuality == quality);
388 }
reed@google.comdaaafa62014-04-29 15:20:16 +0000389}
390
391static void make_noop_layer(SkLayerDrawLooper::Builder* builder) {
392 SkLayerDrawLooper::LayerInfo info;
393
394 info.fPaintBits = 0;
Mike Reedfaba3712016-11-03 14:45:31 -0400395 info.fColorMode = SkBlendMode::kDst;
reed@google.comdaaafa62014-04-29 15:20:16 +0000396 builder->addLayer(info);
397}
398
reedefdfd512016-04-04 10:02:58 -0700399static void make_blur_layer(SkLayerDrawLooper::Builder* builder, sk_sp<SkMaskFilter> mf) {
reed@google.comdaaafa62014-04-29 15:20:16 +0000400 SkLayerDrawLooper::LayerInfo info;
401
402 info.fPaintBits = SkLayerDrawLooper::kMaskFilter_Bit;
Mike Reedfaba3712016-11-03 14:45:31 -0400403 info.fColorMode = SkBlendMode::kSrc;
reed@google.comdaaafa62014-04-29 15:20:16 +0000404 SkPaint* paint = builder->addLayer(info);
reedefdfd512016-04-04 10:02:58 -0700405 paint->setMaskFilter(std::move(mf));
reed@google.comdaaafa62014-04-29 15:20:16 +0000406}
407
reedefdfd512016-04-04 10:02:58 -0700408static void test_layerDrawLooper(skiatest::Reporter* reporter, sk_sp<SkMaskFilter> mf,
409 SkScalar sigma, SkBlurStyle style, SkBlurQuality quality,
410 bool expectSuccess) {
reed@google.comdaaafa62014-04-29 15:20:16 +0000411
412 SkLayerDrawLooper::LayerInfo info;
413 SkLayerDrawLooper::Builder builder;
414
415 // 1 layer is too few
416 make_noop_layer(&builder);
reed7b380d02016-03-21 13:25:16 -0700417 test_looper(reporter, builder.detach(), sigma, style, quality, false);
reed@google.comdaaafa62014-04-29 15:20:16 +0000418
419 // 2 layers is good, but need blur
420 make_noop_layer(&builder);
421 make_noop_layer(&builder);
reed7b380d02016-03-21 13:25:16 -0700422 test_looper(reporter, builder.detach(), sigma, style, quality, false);
reed@google.comdaaafa62014-04-29 15:20:16 +0000423
424 // 2 layers is just right
425 make_noop_layer(&builder);
426 make_blur_layer(&builder, mf);
reed7b380d02016-03-21 13:25:16 -0700427 test_looper(reporter, builder.detach(), sigma, style, quality, expectSuccess);
reed@google.comdaaafa62014-04-29 15:20:16 +0000428
429 // 3 layers is too many
430 make_noop_layer(&builder);
431 make_blur_layer(&builder, mf);
432 make_noop_layer(&builder);
reed7b380d02016-03-21 13:25:16 -0700433 test_looper(reporter, builder.detach(), sigma, style, quality, false);
reed@google.comdaaafa62014-04-29 15:20:16 +0000434}
435
kkinnunen15302832015-12-01 04:35:26 -0800436DEF_TEST(BlurAsABlur, reporter) {
reed@google.comdaaafa62014-04-29 15:20:16 +0000437 const SkBlurStyle styles[] = {
438 kNormal_SkBlurStyle, kSolid_SkBlurStyle, kOuter_SkBlurStyle, kInner_SkBlurStyle
439 };
440 const SkScalar sigmas[] = {
441 // values <= 0 should not success for a blur
442 -1, 0, 0.5f, 2
443 };
444
445 // Test asABlur for SkBlurMaskFilter
446 //
447 for (size_t i = 0; i < SK_ARRAY_COUNT(styles); ++i) {
Robert Phillips98624d22016-12-19 11:37:37 -0500448 const SkBlurStyle style = styles[i];
reed@google.comdaaafa62014-04-29 15:20:16 +0000449 for (size_t j = 0; j < SK_ARRAY_COUNT(sigmas); ++j) {
450 const SkScalar sigma = sigmas[j];
451 for (int flags = 0; flags <= SkBlurMaskFilter::kAll_BlurFlag; ++flags) {
452 const SkBlurQuality quality = blurMaskFilterFlags_as_quality(flags);
453
reedefdfd512016-04-04 10:02:58 -0700454 sk_sp<SkMaskFilter> mf(SkBlurMaskFilter::Make(style, sigma, flags));
halcanary96fcdcc2015-08-27 07:41:13 -0700455 if (nullptr == mf.get()) {
reed@google.comdaaafa62014-04-29 15:20:16 +0000456 REPORTER_ASSERT(reporter, sigma <= 0);
457 } else {
458 REPORTER_ASSERT(reporter, sigma > 0);
459 SkMaskFilter::BlurRec rec;
460 bool success = mf->asABlur(&rec);
461 if (flags & SkBlurMaskFilter::kIgnoreTransform_BlurFlag) {
462 REPORTER_ASSERT(reporter, !success);
463 } else {
464 REPORTER_ASSERT(reporter, success);
465 REPORTER_ASSERT(reporter, rec.fSigma == sigma);
466 REPORTER_ASSERT(reporter, rec.fStyle == style);
467 REPORTER_ASSERT(reporter, rec.fQuality == quality);
468 }
reedefdfd512016-04-04 10:02:58 -0700469 test_layerDrawLooper(reporter, std::move(mf), sigma, style, quality, success);
reed@google.comdaaafa62014-04-29 15:20:16 +0000470 }
471 test_blurDrawLooper(reporter, sigma, style, flags);
472 }
473 }
474 }
475
476 // Test asABlur for SkEmbossMaskFilter -- should never succeed
477 //
478 {
479 SkEmbossMaskFilter::Light light = {
480 { 1, 1, 1 }, 0, 127, 127
481 };
482 for (size_t j = 0; j < SK_ARRAY_COUNT(sigmas); ++j) {
483 const SkScalar sigma = sigmas[j];
reedefdfd512016-04-04 10:02:58 -0700484 auto mf(SkEmbossMaskFilter::Make(sigma, light));
485 if (mf) {
reed@google.comdaaafa62014-04-29 15:20:16 +0000486 SkMaskFilter::BlurRec rec;
487 bool success = mf->asABlur(&rec);
488 REPORTER_ASSERT(reporter, !success);
489 }
490 }
491 }
492}
493
robertphillips4abb0c12016-01-04 11:20:25 -0800494#if SK_SUPPORT_GPU
495
halcanary9d524f22016-03-29 09:03:52 -0700496// This exercises the problem discovered in crbug.com/570232. The return value from
robertphillips4abb0c12016-01-04 11:20:25 -0800497// SkBlurMask::BoxBlur wasn't being checked in SkBlurMaskFilter.cpp::GrRRectBlurEffect::Create
egdanielab527a52016-06-28 08:07:26 -0700498DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SmallBoxBlurBug, reporter, ctxInfo) {
robertphillips4abb0c12016-01-04 11:20:25 -0800499
500 SkImageInfo info = SkImageInfo::MakeN32Premul(128, 128);
bsalomon8b7451a2016-05-11 06:33:06 -0700501 auto surface(SkSurface::MakeRenderTarget(ctxInfo.grContext(), SkBudgeted::kNo, info));
robertphillips4abb0c12016-01-04 11:20:25 -0800502 SkCanvas* canvas = surface->getCanvas();
503
504 SkRect r = SkRect::MakeXYWH(10, 10, 100, 100);
505 SkRRect rr = SkRRect::MakeRectXY(r, 10, 10);
506
507 SkPaint p;
reedefdfd512016-04-04 10:02:58 -0700508 p.setMaskFilter(SkBlurMaskFilter::Make(kNormal_SkBlurStyle, 0.01f));
robertphillips4abb0c12016-01-04 11:20:25 -0800509
510 canvas->drawRRect(rr, p);
511}
512
513#endif
514
robertphillipsf5a83e82016-08-10 12:00:09 -0700515
516DEF_TEST(BlurredRRectNinePatchComputation, reporter) {
517 const SkRect r = SkRect::MakeXYWH(10, 10, 100, 100);
robertphillipsc4d2f902016-08-16 09:30:03 -0700518 static const SkScalar kBlurRad = 3.0f;
robertphillipsf5a83e82016-08-10 12:00:09 -0700519
520 bool ninePatchable;
521 SkRRect rrectToDraw;
522 SkISize size;
robertphillipsc4d2f902016-08-16 09:30:03 -0700523 SkScalar rectXs[SkBlurMaskFilter::kMaxDivisions], rectYs[SkBlurMaskFilter::kMaxDivisions];
524 SkScalar texXs[SkBlurMaskFilter::kMaxDivisions], texYs[SkBlurMaskFilter::kMaxDivisions];
525 int numX, numY;
526 uint32_t skipMask;
robertphillipsf5a83e82016-08-10 12:00:09 -0700527
528 // not nine-patchable
529 {
530 SkVector radii[4] = { { 100, 100 }, { 0, 0 }, { 100, 100 }, { 0, 0 } };
531
532 SkRRect rr;
533 rr.setRectRadii(r, radii);
534
robertphillipsc4d2f902016-08-16 09:30:03 -0700535 ninePatchable = SkBlurMaskFilter::ComputeBlurredRRectParams(rr, rr, SkRect::MakeEmpty(),
536 kBlurRad, kBlurRad,
537 &rrectToDraw, &size,
538 rectXs, rectYs, texXs, texYs,
Ben Wagner63fd7602017-10-09 15:45:33 -0400539 &numX, &numY, &skipMask);
robertphillipsf5a83e82016-08-10 12:00:09 -0700540 REPORTER_ASSERT(reporter, !ninePatchable);
541 }
542
543 // simple circular
544 {
robertphillipsc4d2f902016-08-16 09:30:03 -0700545 static const SkScalar kCornerRad = 10.0f;
robertphillipsf5a83e82016-08-10 12:00:09 -0700546 SkRRect rr;
robertphillipsc4d2f902016-08-16 09:30:03 -0700547 rr.setRectXY(r, kCornerRad, kCornerRad);
robertphillipsf5a83e82016-08-10 12:00:09 -0700548
robertphillipsc4d2f902016-08-16 09:30:03 -0700549 ninePatchable = SkBlurMaskFilter::ComputeBlurredRRectParams(rr, rr, SkRect::MakeEmpty(),
550 kBlurRad, kBlurRad,
551 &rrectToDraw, &size,
552 rectXs, rectYs, texXs, texYs,
553 &numX, &numY, &skipMask);
554
555 static const SkScalar kAns = 12.0f * kBlurRad + 2.0f * kCornerRad + 1.0f;
robertphillipsf5a83e82016-08-10 12:00:09 -0700556 REPORTER_ASSERT(reporter, ninePatchable);
robertphillipsc4d2f902016-08-16 09:30:03 -0700557 REPORTER_ASSERT(reporter, SkScalarNearlyEqual(SkIntToScalar(size.fWidth), kAns));
558 REPORTER_ASSERT(reporter, SkScalarNearlyEqual(SkIntToScalar(size.fHeight), kAns));
559 REPORTER_ASSERT(reporter, 4 == numX && 4 == numY);
560 REPORTER_ASSERT(reporter, !skipMask);
robertphillipsf5a83e82016-08-10 12:00:09 -0700561 }
562
563 // simple elliptical
564 {
robertphillipsc4d2f902016-08-16 09:30:03 -0700565 static const SkScalar kXCornerRad = 2.0f;
566 static const SkScalar kYCornerRad = 10.0f;
robertphillipsf5a83e82016-08-10 12:00:09 -0700567 SkRRect rr;
robertphillipsc4d2f902016-08-16 09:30:03 -0700568 rr.setRectXY(r, kXCornerRad, kYCornerRad);
robertphillipsf5a83e82016-08-10 12:00:09 -0700569
robertphillipsc4d2f902016-08-16 09:30:03 -0700570 ninePatchable = SkBlurMaskFilter::ComputeBlurredRRectParams(rr, rr, SkRect::MakeEmpty(),
571 kBlurRad, kBlurRad,
572 &rrectToDraw, &size,
573 rectXs, rectYs, texXs, texYs,
574 &numX, &numY, &skipMask);
575
576 static const SkScalar kXAns = 12.0f * kBlurRad + 2.0f * kXCornerRad + 1.0f;
577 static const SkScalar kYAns = 12.0f * kBlurRad + 2.0f * kYCornerRad + 1.0f;
578
robertphillipsf5a83e82016-08-10 12:00:09 -0700579 REPORTER_ASSERT(reporter, ninePatchable);
robertphillipsc4d2f902016-08-16 09:30:03 -0700580 REPORTER_ASSERT(reporter, SkScalarNearlyEqual(SkIntToScalar(size.fWidth), kXAns));
581 REPORTER_ASSERT(reporter, SkScalarNearlyEqual(SkIntToScalar(size.fHeight), kYAns));
582 REPORTER_ASSERT(reporter, 4 == numX && 4 == numY);
583 REPORTER_ASSERT(reporter, !skipMask);
584 }
585
586 // test-out occlusion
587 {
588 static const SkScalar kCornerRad = 10.0f;
589 SkRRect rr;
590 rr.setRectXY(r, kCornerRad, kCornerRad);
591
592 // The rectXs & rectYs should be { 1, 29, 91, 119 }. Add two more points around each.
593 SkScalar testLocs[] = {
594 -18.0f, -9.0f,
595 1.0f,
Ben Wagner63fd7602017-10-09 15:45:33 -0400596 9.0f, 18.0f,
597 29.0f,
robertphillipsc4d2f902016-08-16 09:30:03 -0700598 39.0f, 49.0f,
599 91.0f,
600 109.0f, 118.0f,
601 119.0f,
602 139.0f, 149.0f
603 };
604
605 for (int minY = 0; minY < (int)SK_ARRAY_COUNT(testLocs); ++minY) {
606 for (int maxY = minY+1; maxY < (int)SK_ARRAY_COUNT(testLocs); ++maxY) {
607 for (int minX = 0; minX < (int)SK_ARRAY_COUNT(testLocs); ++minX) {
608 for (int maxX = minX+1; maxX < (int)SK_ARRAY_COUNT(testLocs); ++maxX) {
609 SkRect occluder = SkRect::MakeLTRB(testLocs[minX], testLocs[minY],
610 testLocs[maxX], testLocs[maxY]);
611 if (occluder.isEmpty()) {
612 continue;
613 }
614
615 ninePatchable = SkBlurMaskFilter::ComputeBlurredRRectParams(
616 rr, rr, occluder,
617 kBlurRad, kBlurRad,
618 &rrectToDraw, &size,
619 rectXs, rectYs, texXs, texYs,
Ben Wagner63fd7602017-10-09 15:45:33 -0400620 &numX, &numY, &skipMask);
robertphillipsc4d2f902016-08-16 09:30:03 -0700621
622 static const SkScalar kAns = 12.0f * kBlurRad + 2.0f * kCornerRad + 1.0f;
623 REPORTER_ASSERT(reporter, ninePatchable);
624 REPORTER_ASSERT(reporter,
625 SkScalarNearlyEqual(SkIntToScalar(size.fWidth), kAns));
626 REPORTER_ASSERT(reporter,
627 SkScalarNearlyEqual(SkIntToScalar(size.fHeight), kAns));
628
629 int checkBit = 0x1;
630 for (int y = 0; y < numY-1; ++y) {
631 for (int x = 0; x < numX-1; ++x) {
632 SkRect cell = SkRect::MakeLTRB(rectXs[x], rectYs[y],
633 rectXs[x+1], rectYs[y+1]);
634 REPORTER_ASSERT(reporter,
635 SkToBool(skipMask & checkBit) ==
636 (cell.isEmpty() || occluder.contains(cell)));
637
638 REPORTER_ASSERT(reporter, texXs[x] >= 0 &&
639 texXs[x] <= size.fWidth);
640 REPORTER_ASSERT(reporter, texYs[y] >= 0 &&
641 texXs[y] <= size.fHeight);
642
643 checkBit <<= 1;
644 }
645 }
646 }
647 }
648 }
robertphillipsf5a83e82016-08-10 12:00:09 -0700649 }
robertphillipsc4d2f902016-08-16 09:30:03 -0700650
651
robertphillipsf5a83e82016-08-10 12:00:09 -0700652 }
653
654}
655
Florin Malita1ba5bfe2017-11-28 17:54:23 -0500656// https://crbugs.com/787712
657DEF_TEST(EmbossPerlinCrash, reporter) {
658 SkPaint p;
659
660 static constexpr SkEmbossMaskFilter::Light light = {
661 { 1, 1, 1 }, 0, 127, 127
662 };
663 p.setMaskFilter(SkEmbossMaskFilter::Make(1, light));
664 p.setShader(SkPerlinNoiseShader::MakeFractalNoise(1.0f, 1.0f, 2, 0.0f));
665
666 sk_sp<SkSurface> surface = SkSurface::MakeRasterN32Premul(100, 100);
667 surface->getCanvas()->drawPaint(p);
668}
669
reed@google.comdaaafa62014-04-29 15:20:16 +0000670///////////////////////////////////////////////////////////////////////////////////////////