1/* 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 */ 7 8#include "SkBlurMask.h" 9#include "SkBlurMaskFilter.h" 10#include "SkBlurDrawLooper.h" 11#include "SkCanvas.h" 12#include "SkColorFilter.h" 13#include "SkColorPriv.h" 14#include "SkEmbossMaskFilter.h" 15#include "SkLayerDrawLooper.h" 16#include "SkMaskFilterBase.h" 17#include "SkMath.h" 18#include "SkPaint.h" 19#include "SkPath.h" 20#include "SkPerlinNoiseShader.h" 21#include "SkSurface.h" 22#include "Test.h" 23 24#if SK_SUPPORT_GPU 25#include "GrContextFactory.h" 26#include "SkGpuDevice.h" 27#endif 28 29#define WRITE_CSV 0 30 31/////////////////////////////////////////////////////////////////////////////// 32 33#define ILLEGAL_MODE ((SkXfermode::Mode)-1) 34 35static const int outset = 100; 36static const SkColor bgColor = SK_ColorWHITE; 37static const int strokeWidth = 4; 38 39static void create(SkBitmap* bm, const SkIRect& bound) { 40 bm->allocN32Pixels(bound.width(), bound.height()); 41} 42 43static void drawBG(SkCanvas* canvas) { 44 canvas->drawColor(bgColor); 45} 46 47 48struct BlurTest { 49 void (*addPath)(SkPath*); 50 int viewLen; 51 SkIRect views[9]; 52}; 53 54//Path Draw Procs 55//Beware that paths themselves my draw differently depending on the clip. 56static void draw50x50Rect(SkPath* path) { 57 path->addRect(0, 0, SkIntToScalar(50), SkIntToScalar(50)); 58} 59 60//Tests 61static BlurTest tests[] = { 62 { draw50x50Rect, 3, { 63 //inner half of blur 64 { 0, 0, 50, 50 }, 65 //blur, but no path. 66 { 50 + strokeWidth/2, 50 + strokeWidth/2, 100, 100 }, 67 //just an edge 68 { 40, strokeWidth, 60, 50 - strokeWidth }, 69 }}, 70}; 71 72/** Assumes that the ref draw was completely inside ref canvas -- 73 implies that everything outside is "bgColor". 74 Checks that all overlap is the same and that all non-overlap on the 75 ref is "bgColor". 76 */ 77static bool compare(const SkBitmap& ref, const SkIRect& iref, 78 const SkBitmap& test, const SkIRect& itest) 79{ 80 const int xOff = itest.fLeft - iref.fLeft; 81 const int yOff = itest.fTop - iref.fTop; 82 83 for (int y = 0; y < test.height(); ++y) { 84 for (int x = 0; x < test.width(); ++x) { 85 SkColor testColor = test.getColor(x, y); 86 int refX = x + xOff; 87 int refY = y + yOff; 88 SkColor refColor; 89 if (refX >= 0 && refX < ref.width() && 90 refY >= 0 && refY < ref.height()) 91 { 92 refColor = ref.getColor(refX, refY); 93 } else { 94 refColor = bgColor; 95 } 96 if (refColor != testColor) { 97 return false; 98 } 99 } 100 } 101 return true; 102} 103 104DEF_TEST(BlurDrawing, reporter) { 105 SkPaint paint; 106 paint.setColor(SK_ColorGRAY); 107 paint.setStyle(SkPaint::kStroke_Style); 108 paint.setStrokeWidth(SkIntToScalar(strokeWidth)); 109 110 SkScalar sigma = SkBlurMask::ConvertRadiusToSigma(SkIntToScalar(5)); 111 for (int style = 0; style <= kLastEnum_SkBlurStyle; ++style) { 112 SkBlurStyle blurStyle = static_cast<SkBlurStyle>(style); 113 114 const uint32_t flagPermutations = SkBlurMaskFilter::kAll_BlurFlag; 115 for (uint32_t flags = 0; flags < flagPermutations; ++flags) { 116 paint.setMaskFilter(SkBlurMaskFilter::Make(blurStyle, sigma, flags)); 117 118 for (size_t test = 0; test < SK_ARRAY_COUNT(tests); ++test) { 119 SkPath path; 120 tests[test].addPath(&path); 121 SkPath strokedPath; 122 paint.getFillPath(path, &strokedPath); 123 SkRect refBound = strokedPath.getBounds(); 124 SkIRect iref; 125 refBound.roundOut(&iref); 126 iref.inset(-outset, -outset); 127 SkBitmap refBitmap; 128 create(&refBitmap, iref); 129 130 SkCanvas refCanvas(refBitmap); 131 refCanvas.translate(SkIntToScalar(-iref.fLeft), 132 SkIntToScalar(-iref.fTop)); 133 drawBG(&refCanvas); 134 refCanvas.drawPath(path, paint); 135 136 for (int view = 0; view < tests[test].viewLen; ++view) { 137 SkIRect itest = tests[test].views[view]; 138 SkBitmap testBitmap; 139 create(&testBitmap, itest); 140 141 SkCanvas testCanvas(testBitmap); 142 testCanvas.translate(SkIntToScalar(-itest.fLeft), 143 SkIntToScalar(-itest.fTop)); 144 drawBG(&testCanvas); 145 testCanvas.drawPath(path, paint); 146 147 REPORTER_ASSERT(reporter, 148 compare(refBitmap, iref, testBitmap, itest)); 149 } 150 } 151 } 152 } 153} 154 155/////////////////////////////////////////////////////////////////////////////// 156 157// Use SkBlurMask::BlurGroundTruth to blur a 'width' x 'height' solid 158// white rect. Return the right half of the middle row in 'result'. 159static void ground_truth_2d(int width, int height, 160 SkScalar sigma, 161 int* result, int resultCount) { 162 SkMask src, dst; 163 164 src.fBounds.set(0, 0, width, height); 165 src.fFormat = SkMask::kA8_Format; 166 src.fRowBytes = src.fBounds.width(); 167 src.fImage = SkMask::AllocImage(src.computeTotalImageSize()); 168 169 memset(src.fImage, 0xff, src.computeTotalImageSize()); 170 171 if (!SkBlurMask::BlurGroundTruth(sigma, &dst, src, kNormal_SkBlurStyle)) { 172 return; 173 } 174 175 int midX = dst.fBounds.centerX(); 176 int midY = dst.fBounds.centerY(); 177 uint8_t* bytes = dst.getAddr8(midX, midY); 178 int i; 179 for (i = 0; i < dst.fBounds.width()-(midX-dst.fBounds.fLeft); ++i) { 180 if (i < resultCount) { 181 result[i] = bytes[i]; 182 } 183 } 184 for ( ; i < resultCount; ++i) { 185 result[i] = 0; 186 } 187 188 SkMask::FreeImage(src.fImage); 189 SkMask::FreeImage(dst.fImage); 190} 191 192// Implement a step function that is 255 between min and max; 0 elsewhere. 193static int step(int x, SkScalar min, SkScalar max) { 194 if (min < x && x < max) { 195 return 255; 196 } 197 return 0; 198} 199 200// Implement a Gaussian function with 0 mean and std.dev. of 'sigma'. 201static float gaussian(int x, SkScalar sigma) { 202 float k = SK_Scalar1/(sigma * sqrtf(2.0f*SK_ScalarPI)); 203 float exponent = -(x * x) / (2 * sigma * sigma); 204 return k * expf(exponent); 205} 206 207// Perform a brute force convolution of a step function with a Gaussian. 208// Return the right half in 'result' 209static void brute_force_1d(SkScalar stepMin, SkScalar stepMax, 210 SkScalar gaussianSigma, 211 int* result, int resultCount) { 212 213 int gaussianRange = SkScalarCeilToInt(10 * gaussianSigma); 214 215 for (int i = 0; i < resultCount; ++i) { 216 SkScalar sum = 0.0f; 217 for (int j = -gaussianRange; j < gaussianRange; ++j) { 218 sum += gaussian(j, gaussianSigma) * step(i-j, stepMin, stepMax); 219 } 220 221 result[i] = SkClampMax(SkClampPos(int(sum + 0.5f)), 255); 222 } 223} 224 225static void blur_path(SkCanvas* canvas, const SkPath& path, 226 SkScalar gaussianSigma) { 227 228 SkScalar midX = path.getBounds().centerX(); 229 SkScalar midY = path.getBounds().centerY(); 230 231 canvas->translate(-midX, -midY); 232 233 SkPaint blurPaint; 234 blurPaint.setColor(SK_ColorWHITE); 235 blurPaint.setMaskFilter(SkBlurMaskFilter::Make(kNormal_SkBlurStyle, gaussianSigma, 236 SkBlurMaskFilter::kHighQuality_BlurFlag)); 237 238 canvas->drawColor(SK_ColorBLACK); 239 canvas->drawPath(path, blurPaint); 240} 241 242// Readback the blurred draw results from the canvas 243static void readback(const SkBitmap& src, int* result, int resultCount) { 244 SkBitmap readback; 245 readback.allocN32Pixels(resultCount, 30); 246 SkPixmap pm; 247 readback.peekPixels(&pm); 248 src.readPixels(pm, 0, 0); 249 250 const SkPMColor* pixels = pm.addr32(0, 15); 251 252 for (int i = 0; i < resultCount; ++i) { 253 result[i] = SkColorGetR(pixels[i]); 254 } 255} 256 257// Draw a blurred version of the provided path. 258// Return the right half of the middle row in 'result'. 259static void cpu_blur_path(const SkPath& path, SkScalar gaussianSigma, 260 int* result, int resultCount) { 261 262 SkBitmap bitmap; 263 bitmap.allocN32Pixels(resultCount, 30); 264 SkCanvas canvas(bitmap); 265 266 blur_path(&canvas, path, gaussianSigma); 267 readback(bitmap, result, resultCount); 268} 269 270#if WRITE_CSV 271static void write_as_csv(const char* label, SkScalar scale, int* data, int count) { 272 SkDebugf("%s_%.2f,", label, scale); 273 for (int i = 0; i < count-1; ++i) { 274 SkDebugf("%d,", data[i]); 275 } 276 SkDebugf("%d\n", data[count-1]); 277} 278#endif 279 280static bool match(int* first, int* second, int count, int tol) { 281 int delta; 282 for (int i = 0; i < count; ++i) { 283 delta = first[i] - second[i]; 284 if (delta > tol || delta < -tol) { 285 return false; 286 } 287 } 288 289 return true; 290} 291 292// Test out the normal blur style with a wide range of sigmas 293DEF_TEST(BlurSigmaRange, reporter) { 294 static const int kSize = 100; 295 296 // The geometry is offset a smidge to trigger: 297 // https://code.google.com/p/chromium/issues/detail?id=282418 298 SkPath rectPath; 299 rectPath.addRect(0.3f, 0.3f, 100.3f, 100.3f); 300 301 SkPoint polyPts[] = { 302 { 0.3f, 0.3f }, 303 { 100.3f, 0.3f }, 304 { 100.3f, 100.3f }, 305 { 0.3f, 100.3f }, 306 { 2.3f, 50.3f } // a little divet to throw off the rect special case 307 }; 308 SkPath polyPath; 309 polyPath.addPoly(polyPts, SK_ARRAY_COUNT(polyPts), true); 310 311 int rectSpecialCaseResult[kSize]; 312 int generalCaseResult[kSize]; 313 int groundTruthResult[kSize]; 314 int bruteForce1DResult[kSize]; 315 316 SkScalar sigma = 10.0f; 317 318 for (int i = 0; i < 4; ++i, sigma /= 10) { 319 320 cpu_blur_path(rectPath, sigma, rectSpecialCaseResult, kSize); 321 cpu_blur_path(polyPath, sigma, generalCaseResult, kSize); 322 323 ground_truth_2d(100, 100, sigma, groundTruthResult, kSize); 324 brute_force_1d(-50.0f, 50.0f, sigma, bruteForce1DResult, kSize); 325 326 REPORTER_ASSERT(reporter, match(rectSpecialCaseResult, bruteForce1DResult, kSize, 5)); 327 REPORTER_ASSERT(reporter, match(generalCaseResult, bruteForce1DResult, kSize, 15)); 328 REPORTER_ASSERT(reporter, match(groundTruthResult, bruteForce1DResult, kSize, 1)); 329 330#if WRITE_CSV 331 write_as_csv("RectSpecialCase", sigma, rectSpecialCaseResult, kSize); 332 write_as_csv("GeneralCase", sigma, generalCaseResult, kSize); 333#if SK_SUPPORT_GPU 334 write_as_csv("GPU", sigma, gpuResult, kSize); 335#endif 336 write_as_csv("GroundTruth2D", sigma, groundTruthResult, kSize); 337 write_as_csv("BruteForce1D", sigma, bruteForce1DResult, kSize); 338#endif 339 } 340} 341 342/////////////////////////////////////////////////////////////////////////////////////////// 343 344static SkBlurQuality blurMaskFilterFlags_as_quality(uint32_t blurMaskFilterFlags) { 345 return (blurMaskFilterFlags & SkBlurMaskFilter::kHighQuality_BlurFlag) ? 346 kHigh_SkBlurQuality : kLow_SkBlurQuality; 347} 348 349static void test_blurDrawLooper(skiatest::Reporter* reporter, SkScalar sigma, 350 SkBlurStyle style, uint32_t blurMaskFilterFlags) { 351 if (kNormal_SkBlurStyle != style) { 352 return; // blurdrawlooper only supports normal 353 } 354 355 const SkColor color = 0xFF335577; 356 const SkScalar dx = 10; 357 const SkScalar dy = -5; 358 sk_sp<SkDrawLooper> lp(SkBlurDrawLooper::Make(color, sigma, dx, dy)); 359 const bool expectSuccess = sigma > 0; 360 361 if (nullptr == lp) { 362 REPORTER_ASSERT(reporter, sigma <= 0); 363 } else { 364 SkDrawLooper::BlurShadowRec rec; 365 bool success = lp->asABlurShadow(&rec); 366 REPORTER_ASSERT(reporter, success == expectSuccess); 367 if (success) { 368 REPORTER_ASSERT(reporter, rec.fSigma == sigma); 369 REPORTER_ASSERT(reporter, rec.fOffset.x() == dx); 370 REPORTER_ASSERT(reporter, rec.fOffset.y() == dy); 371 REPORTER_ASSERT(reporter, rec.fColor == color); 372 REPORTER_ASSERT(reporter, rec.fStyle == style); 373 REPORTER_ASSERT(reporter, rec.fQuality == kLow_SkBlurQuality); 374 } 375 } 376} 377 378static void test_looper(skiatest::Reporter* reporter, sk_sp<SkDrawLooper> lp, SkScalar sigma, 379 SkBlurStyle style, SkBlurQuality quality, bool expectSuccess) { 380 SkDrawLooper::BlurShadowRec rec; 381 bool success = lp->asABlurShadow(&rec); 382 REPORTER_ASSERT(reporter, success == expectSuccess); 383 if (success != expectSuccess) { 384 lp->asABlurShadow(&rec); 385 } 386 if (success) { 387 REPORTER_ASSERT(reporter, rec.fSigma == sigma); 388 REPORTER_ASSERT(reporter, rec.fStyle == style); 389 REPORTER_ASSERT(reporter, rec.fQuality == quality); 390 } 391} 392 393static void make_noop_layer(SkLayerDrawLooper::Builder* builder) { 394 SkLayerDrawLooper::LayerInfo info; 395 396 info.fPaintBits = 0; 397 info.fColorMode = SkBlendMode::kDst; 398 builder->addLayer(info); 399} 400 401static void make_blur_layer(SkLayerDrawLooper::Builder* builder, sk_sp<SkMaskFilter> mf) { 402 SkLayerDrawLooper::LayerInfo info; 403 404 info.fPaintBits = SkLayerDrawLooper::kMaskFilter_Bit; 405 info.fColorMode = SkBlendMode::kSrc; 406 SkPaint* paint = builder->addLayer(info); 407 paint->setMaskFilter(std::move(mf)); 408} 409 410static void test_layerDrawLooper(skiatest::Reporter* reporter, sk_sp<SkMaskFilter> mf, 411 SkScalar sigma, SkBlurStyle style, SkBlurQuality quality, 412 bool expectSuccess) { 413 414 SkLayerDrawLooper::LayerInfo info; 415 SkLayerDrawLooper::Builder builder; 416 417 // 1 layer is too few 418 make_noop_layer(&builder); 419 test_looper(reporter, builder.detach(), sigma, style, quality, false); 420 421 // 2 layers is good, but need blur 422 make_noop_layer(&builder); 423 make_noop_layer(&builder); 424 test_looper(reporter, builder.detach(), sigma, style, quality, false); 425 426 // 2 layers is just right 427 make_noop_layer(&builder); 428 make_blur_layer(&builder, mf); 429 test_looper(reporter, builder.detach(), sigma, style, quality, expectSuccess); 430 431 // 3 layers is too many 432 make_noop_layer(&builder); 433 make_blur_layer(&builder, mf); 434 make_noop_layer(&builder); 435 test_looper(reporter, builder.detach(), sigma, style, quality, false); 436} 437 438DEF_TEST(BlurAsABlur, reporter) { 439 const SkBlurStyle styles[] = { 440 kNormal_SkBlurStyle, kSolid_SkBlurStyle, kOuter_SkBlurStyle, kInner_SkBlurStyle 441 }; 442 const SkScalar sigmas[] = { 443 // values <= 0 should not success for a blur 444 -1, 0, 0.5f, 2 445 }; 446 447 // Test asABlur for SkBlurMaskFilter 448 // 449 for (size_t i = 0; i < SK_ARRAY_COUNT(styles); ++i) { 450 const SkBlurStyle style = styles[i]; 451 for (size_t j = 0; j < SK_ARRAY_COUNT(sigmas); ++j) { 452 const SkScalar sigma = sigmas[j]; 453 for (int flags = 0; flags <= SkBlurMaskFilter::kAll_BlurFlag; ++flags) { 454 const SkBlurQuality quality = blurMaskFilterFlags_as_quality(flags); 455 456 sk_sp<SkMaskFilter> mf(SkBlurMaskFilter::Make(style, sigma, flags)); 457 if (nullptr == mf.get()) { 458 REPORTER_ASSERT(reporter, sigma <= 0); 459 } else { 460 REPORTER_ASSERT(reporter, sigma > 0); 461 SkMaskFilterBase::BlurRec rec; 462 bool success = as_MFB(mf)->asABlur(&rec); 463 if (flags & SkBlurMaskFilter::kIgnoreTransform_BlurFlag) { 464 REPORTER_ASSERT(reporter, !success); 465 } else { 466 REPORTER_ASSERT(reporter, success); 467 REPORTER_ASSERT(reporter, rec.fSigma == sigma); 468 REPORTER_ASSERT(reporter, rec.fStyle == style); 469 REPORTER_ASSERT(reporter, rec.fQuality == quality); 470 } 471 test_layerDrawLooper(reporter, std::move(mf), sigma, style, quality, success); 472 } 473 test_blurDrawLooper(reporter, sigma, style, flags); 474 } 475 } 476 } 477 478 // Test asABlur for SkEmbossMaskFilter -- should never succeed 479 // 480 { 481 SkEmbossMaskFilter::Light light = { 482 { 1, 1, 1 }, 0, 127, 127 483 }; 484 for (size_t j = 0; j < SK_ARRAY_COUNT(sigmas); ++j) { 485 const SkScalar sigma = sigmas[j]; 486 auto mf(SkEmbossMaskFilter::Make(sigma, light)); 487 if (mf) { 488 SkMaskFilterBase::BlurRec rec; 489 bool success = as_MFB(mf)->asABlur(&rec); 490 REPORTER_ASSERT(reporter, !success); 491 } 492 } 493 } 494} 495 496#if SK_SUPPORT_GPU 497 498// This exercises the problem discovered in crbug.com/570232. The return value from 499// SkBlurMask::BoxBlur wasn't being checked in SkBlurMaskFilter.cpp::GrRRectBlurEffect::Create 500DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SmallBoxBlurBug, reporter, ctxInfo) { 501 502 SkImageInfo info = SkImageInfo::MakeN32Premul(128, 128); 503 auto surface(SkSurface::MakeRenderTarget(ctxInfo.grContext(), SkBudgeted::kNo, info)); 504 SkCanvas* canvas = surface->getCanvas(); 505 506 SkRect r = SkRect::MakeXYWH(10, 10, 100, 100); 507 SkRRect rr = SkRRect::MakeRectXY(r, 10, 10); 508 509 SkPaint p; 510 p.setMaskFilter(SkBlurMaskFilter::Make(kNormal_SkBlurStyle, 0.01f)); 511 512 canvas->drawRRect(rr, p); 513} 514 515#endif 516 517 518DEF_TEST(BlurredRRectNinePatchComputation, reporter) { 519 const SkRect r = SkRect::MakeXYWH(10, 10, 100, 100); 520 static const SkScalar kBlurRad = 3.0f; 521 522 bool ninePatchable; 523 SkRRect rrectToDraw; 524 SkISize size; 525 SkScalar rectXs[SkBlurMaskFilter::kMaxDivisions], rectYs[SkBlurMaskFilter::kMaxDivisions]; 526 SkScalar texXs[SkBlurMaskFilter::kMaxDivisions], texYs[SkBlurMaskFilter::kMaxDivisions]; 527 int numX, numY; 528 uint32_t skipMask; 529 530 // not nine-patchable 531 { 532 SkVector radii[4] = { { 100, 100 }, { 0, 0 }, { 100, 100 }, { 0, 0 } }; 533 534 SkRRect rr; 535 rr.setRectRadii(r, radii); 536 537 ninePatchable = SkBlurMaskFilter::ComputeBlurredRRectParams(rr, rr, SkRect::MakeEmpty(), 538 kBlurRad, kBlurRad, 539 &rrectToDraw, &size, 540 rectXs, rectYs, texXs, texYs, 541 &numX, &numY, &skipMask); 542 REPORTER_ASSERT(reporter, !ninePatchable); 543 } 544 545 // simple circular 546 { 547 static const SkScalar kCornerRad = 10.0f; 548 SkRRect rr; 549 rr.setRectXY(r, kCornerRad, kCornerRad); 550 551 ninePatchable = SkBlurMaskFilter::ComputeBlurredRRectParams(rr, rr, SkRect::MakeEmpty(), 552 kBlurRad, kBlurRad, 553 &rrectToDraw, &size, 554 rectXs, rectYs, texXs, texYs, 555 &numX, &numY, &skipMask); 556 557 static const SkScalar kAns = 12.0f * kBlurRad + 2.0f * kCornerRad + 1.0f; 558 REPORTER_ASSERT(reporter, ninePatchable); 559 REPORTER_ASSERT(reporter, SkScalarNearlyEqual(SkIntToScalar(size.fWidth), kAns)); 560 REPORTER_ASSERT(reporter, SkScalarNearlyEqual(SkIntToScalar(size.fHeight), kAns)); 561 REPORTER_ASSERT(reporter, 4 == numX && 4 == numY); 562 REPORTER_ASSERT(reporter, !skipMask); 563 } 564 565 // simple elliptical 566 { 567 static const SkScalar kXCornerRad = 2.0f; 568 static const SkScalar kYCornerRad = 10.0f; 569 SkRRect rr; 570 rr.setRectXY(r, kXCornerRad, kYCornerRad); 571 572 ninePatchable = SkBlurMaskFilter::ComputeBlurredRRectParams(rr, rr, SkRect::MakeEmpty(), 573 kBlurRad, kBlurRad, 574 &rrectToDraw, &size, 575 rectXs, rectYs, texXs, texYs, 576 &numX, &numY, &skipMask); 577 578 static const SkScalar kXAns = 12.0f * kBlurRad + 2.0f * kXCornerRad + 1.0f; 579 static const SkScalar kYAns = 12.0f * kBlurRad + 2.0f * kYCornerRad + 1.0f; 580 581 REPORTER_ASSERT(reporter, ninePatchable); 582 REPORTER_ASSERT(reporter, SkScalarNearlyEqual(SkIntToScalar(size.fWidth), kXAns)); 583 REPORTER_ASSERT(reporter, SkScalarNearlyEqual(SkIntToScalar(size.fHeight), kYAns)); 584 REPORTER_ASSERT(reporter, 4 == numX && 4 == numY); 585 REPORTER_ASSERT(reporter, !skipMask); 586 } 587 588 // test-out occlusion 589 { 590 static const SkScalar kCornerRad = 10.0f; 591 SkRRect rr; 592 rr.setRectXY(r, kCornerRad, kCornerRad); 593 594 // The rectXs & rectYs should be { 1, 29, 91, 119 }. Add two more points around each. 595 SkScalar testLocs[] = { 596 -18.0f, -9.0f, 597 1.0f, 598 9.0f, 18.0f, 599 29.0f, 600 39.0f, 49.0f, 601 91.0f, 602 109.0f, 118.0f, 603 119.0f, 604 139.0f, 149.0f 605 }; 606 607 for (int minY = 0; minY < (int)SK_ARRAY_COUNT(testLocs); ++minY) { 608 for (int maxY = minY+1; maxY < (int)SK_ARRAY_COUNT(testLocs); ++maxY) { 609 for (int minX = 0; minX < (int)SK_ARRAY_COUNT(testLocs); ++minX) { 610 for (int maxX = minX+1; maxX < (int)SK_ARRAY_COUNT(testLocs); ++maxX) { 611 SkRect occluder = SkRect::MakeLTRB(testLocs[minX], testLocs[minY], 612 testLocs[maxX], testLocs[maxY]); 613 if (occluder.isEmpty()) { 614 continue; 615 } 616 617 ninePatchable = SkBlurMaskFilter::ComputeBlurredRRectParams( 618 rr, rr, occluder, 619 kBlurRad, kBlurRad, 620 &rrectToDraw, &size, 621 rectXs, rectYs, texXs, texYs, 622 &numX, &numY, &skipMask); 623 624 static const SkScalar kAns = 12.0f * kBlurRad + 2.0f * kCornerRad + 1.0f; 625 REPORTER_ASSERT(reporter, ninePatchable); 626 REPORTER_ASSERT(reporter, 627 SkScalarNearlyEqual(SkIntToScalar(size.fWidth), kAns)); 628 REPORTER_ASSERT(reporter, 629 SkScalarNearlyEqual(SkIntToScalar(size.fHeight), kAns)); 630 631 int checkBit = 0x1; 632 for (int y = 0; y < numY-1; ++y) { 633 for (int x = 0; x < numX-1; ++x) { 634 SkRect cell = SkRect::MakeLTRB(rectXs[x], rectYs[y], 635 rectXs[x+1], rectYs[y+1]); 636 REPORTER_ASSERT(reporter, 637 SkToBool(skipMask & checkBit) == 638 (cell.isEmpty() || occluder.contains(cell))); 639 640 REPORTER_ASSERT(reporter, texXs[x] >= 0 && 641 texXs[x] <= size.fWidth); 642 REPORTER_ASSERT(reporter, texYs[y] >= 0 && 643 texXs[y] <= size.fHeight); 644 645 checkBit <<= 1; 646 } 647 } 648 } 649 } 650 } 651 } 652 653 654 } 655 656} 657 658// https://crbugs.com/787712 659DEF_TEST(EmbossPerlinCrash, reporter) { 660 SkPaint p; 661 662 static constexpr SkEmbossMaskFilter::Light light = { 663 { 1, 1, 1 }, 0, 127, 127 664 }; 665 p.setMaskFilter(SkEmbossMaskFilter::Make(1, light)); 666 p.setShader(SkPerlinNoiseShader::MakeFractalNoise(1.0f, 1.0f, 2, 0.0f)); 667 668 sk_sp<SkSurface> surface = SkSurface::MakeRasterN32Premul(100, 100); 669 surface->getCanvas()->drawPaint(p); 670} 671 672/////////////////////////////////////////////////////////////////////////////////////////// 673#include "SkSurface.h" 674#include "sk_pixel_iter.h" 675 676DEF_TEST(BlurZeroSigma, reporter) { 677 auto surf = SkSurface::MakeRasterN32Premul(20, 20); 678 SkPaint paint; 679 paint.setAntiAlias(true); 680 681 const SkIRect ir = { 5, 5, 15, 15 }; 682 const SkRect r = SkRect::Make(ir); 683 684 const SkScalar sigmas[] = { 0, SkBits2Float(1) }; 685 // if sigma is zero (or nearly so), we need to draw correctly (unblurred) and not crash 686 // or assert. 687 for (auto sigma : sigmas) { 688 paint.setMaskFilter(SkBlurMaskFilter::Make(kNormal_SkBlurStyle, sigma)); 689 surf->getCanvas()->drawRect(r, paint); 690 691 sk_tool_utils::PixelIter iter(surf.get()); 692 SkIPoint loc; 693 while (const SkPMColor* p = (const SkPMColor*)iter.next(&loc)) { 694 if (ir.contains(loc.fX, loc.fY)) { 695 // inside the rect we draw (opaque black) 696 REPORTER_ASSERT(reporter, *p == SkPackARGB32(0xFF, 0, 0, 0)); 697 } else { 698 // outside the rect we didn't draw at all, no blurred edges 699 REPORTER_ASSERT(reporter, *p == 0); 700 } 701 } 702 } 703} 704 705