src/third_party/skia/tests/BlurTest.cpp

   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 "SkLayerDrawLooper.h"
  12 #include "SkEmbossMaskFilter.h"
  13 #include "SkCanvas.h"
  14 #include "SkMath.h"
  15 #include "SkPaint.h"
  16 #include "Test.h"
  17
  18 #if SK_SUPPORT_GPU
  19 #include "GrContextFactory.h"
  20 #include "SkGpuDevice.h"
  21 #endif
  22
  23 #define WRITE_CSV 0
  24
  25 ///////////////////////////////////////////////////////////////////////////////
  26
  27 #define ILLEGAL_MODE    ((SkXfermode::Mode)-1)
  28
  29 static const int outset = 100;
  30 static const SkColor bgColor = SK_ColorWHITE;
  31 static const int strokeWidth = 4;
  32
  33 static void create(SkBitmap* bm, const SkIRect& bound) {
  34     bm->allocN32Pixels(bound.width(), bound.height());
  35 }
  36
  37 static void drawBG(SkCanvas* canvas) {
  38     canvas->drawColor(bgColor);
  39 }
  40
  41
  42 struct BlurTest {
  43     void (*addPath)(SkPath*);
  44     int viewLen;
  45     SkIRect views[9];
  46 };
  47
  48 //Path Draw Procs
  49 //Beware that paths themselves my draw differently depending on the clip.
  50 static void draw50x50Rect(SkPath* path) {
  51     path->addRect(0, 0, SkIntToScalar(50), SkIntToScalar(50));
  52 }
  53
  54 //Tests
  55 static BlurTest tests[] = {
  56     { draw50x50Rect, 3, {
  57         //inner half of blur
  58         { 0, 0, 50, 50 },
  59         //blur, but no path.
  60         { 50 + strokeWidth/2, 50 + strokeWidth/2, 100, 100 },
  61         //just an edge
  62         { 40, strokeWidth, 60, 50 - strokeWidth },
  63     }},
  64 };
  65
  66 /** Assumes that the ref draw was completely inside ref canvas --
  67     implies that everything outside is "bgColor".
  68     Checks that all overlap is the same and that all non-overlap on the
  69     ref is "bgColor".
  70  */
  71 static bool compare(const SkBitmap& ref, const SkIRect& iref,
  72                     const SkBitmap& test, const SkIRect& itest)
  73 {
  74     const int xOff = itest.fLeft - iref.fLeft;
  75     const int yOff = itest.fTop - iref.fTop;
  76
  77     SkAutoLockPixels alpRef(ref);
  78     SkAutoLockPixels alpTest(test);
  79
  80     for (int y = 0; y < test.height(); ++y) {
  81         for (int x = 0; x < test.width(); ++x) {
  82             SkColor testColor = test.getColor(x, y);
  83             int refX = x + xOff;
  84             int refY = y + yOff;
  85             SkColor refColor;
  86             if (refX >= 0 && refX < ref.width() &&
  87                 refY >= 0 && refY < ref.height())
  88             {
  89                 refColor = ref.getColor(refX, refY);
  90             } else {
  91                 refColor = bgColor;
  92             }
  93             if (refColor != testColor) {
  94                 return false;
  95             }
  96         }
  97     }
  98     return true;
  99 }
 100
 101 static void test_blur_drawing(skiatest::Reporter* reporter) {
 102
 103     SkPaint paint;
 104     paint.setColor(SK_ColorGRAY);
 105     paint.setStyle(SkPaint::kStroke_Style);
 106     paint.setStrokeWidth(SkIntToScalar(strokeWidth));
 107
 108     SkScalar sigma = SkBlurMask::ConvertRadiusToSigma(SkIntToScalar(5));
 109     for (int style = 0; style <= kLastEnum_SkBlurStyle; ++style) {
 110         SkBlurStyle blurStyle = static_cast<SkBlurStyle>(style);
 111
 112         const uint32_t flagPermutations = SkBlurMaskFilter::kAll_BlurFlag;
 113         for (uint32_t flags = 0; flags < flagPermutations; ++flags) {
 114             SkMaskFilter* filter;
 115             filter = SkBlurMaskFilter::Create(blurStyle, sigma, flags);
 116
 117             paint.setMaskFilter(filter);
 118             filter->unref();
 119
 120             for (size_t test = 0; test < SK_ARRAY_COUNT(tests); ++test) {
 121                 SkPath path;
 122                 tests[test].addPath(&path);
 123                 SkPath strokedPath;
 124                 paint.getFillPath(path, &strokedPath);
 125                 SkRect refBound = strokedPath.getBounds();
 126                 SkIRect iref;
 127                 refBound.roundOut(&iref);
 128                 iref.inset(-outset, -outset);
 129                 SkBitmap refBitmap;
 130                 create(&refBitmap, iref);
 131
 132                 SkCanvas refCanvas(refBitmap);
 133                 refCanvas.translate(SkIntToScalar(-iref.fLeft),
 134                                     SkIntToScalar(-iref.fTop));
 135                 drawBG(&refCanvas);
 136                 refCanvas.drawPath(path, paint);
 137
 138                 for (int view = 0; view < tests[test].viewLen; ++view) {
 139                     SkIRect itest = tests[test].views[view];
 140                     SkBitmap testBitmap;
 141                     create(&testBitmap, itest);
 142
 143                     SkCanvas testCanvas(testBitmap);
 144                     testCanvas.translate(SkIntToScalar(-itest.fLeft),
 145                                          SkIntToScalar(-itest.fTop));
 146                     drawBG(&testCanvas);
 147                     testCanvas.drawPath(path, paint);
 148
 149                     REPORTER_ASSERT(reporter,
 150                         compare(refBitmap, iref, testBitmap, itest));
 151                 }
 152             }
 153         }
 154     }
 155 }
 156
 157 ///////////////////////////////////////////////////////////////////////////////
 158
 159 // Use SkBlurMask::BlurGroundTruth to blur a 'width' x 'height' solid
 160 // white rect. Return the right half of the middle row in 'result'.
 161 static void ground_truth_2d(int width, int height,
 162                             SkScalar sigma,
 163                             int* result, int resultCount) {
 164     SkMask src, dst;
 165
 166     src.fBounds.set(0, 0, width, height);
 167     src.fFormat = SkMask::kA8_Format;
 168     src.fRowBytes = src.fBounds.width();
 169     src.fImage = SkMask::AllocImage(src.computeTotalImageSize());
 170
 171     memset(src.fImage, 0xff, src.computeTotalImageSize());
 172
 173     dst.fImage = NULL;
 174     SkBlurMask::BlurGroundTruth(sigma, &dst, src, kNormal_SkBlurStyle);
 175
 176     int midX = dst.fBounds.centerX();
 177     int midY = dst.fBounds.centerY();
 178     uint8_t* bytes = dst.getAddr8(midX, midY);
 179     int i;
 180     for (i = 0; i < dst.fBounds.width()-(midX-dst.fBounds.fLeft); ++i) {
 181         if (i < resultCount) {
 182             result[i] = bytes[i];
 183         }
 184     }
 185     for ( ; i < resultCount; ++i) {
 186         result[i] = 0;
 187     }
 188
 189     SkMask::FreeImage(src.fImage);
 190     SkMask::FreeImage(dst.fImage);
 191 }
 192
 193 // Implement a step function that is 255 between min and max; 0 elsewhere.
 194 static int step(int x, SkScalar min, SkScalar max) {
 195     if (min < x && x < max) {
 196         return 255;
 197     }
 198     return 0;
 199 }
 200
 201 // Implement a Gaussian function with 0 mean and std.dev. of 'sigma'.
 202 static float gaussian(int x, SkScalar sigma) {
 203     float k = SK_Scalar1/(sigma * sqrtf(2.0f*SK_ScalarPI));
 204     float exponent = -(x * x) / (2 * sigma * sigma);
 205     return k * expf(exponent);
 206 }
 207
 208 // Perform a brute force convolution of a step function with a Gaussian.
 209 // Return the right half in 'result'
 210 static void brute_force_1d(SkScalar stepMin, SkScalar stepMax,
 211                            SkScalar gaussianSigma,
 212                            int* result, int resultCount) {
 213
 214     int gaussianRange = SkScalarCeilToInt(10 * gaussianSigma);
 215
 216     for (int i = 0; i < resultCount; ++i) {
 217         SkScalar sum = 0.0f;
 218         for (int j = -gaussianRange; j < gaussianRange; ++j) {
 219             sum += gaussian(j, gaussianSigma) * step(i-j, stepMin, stepMax);
 220         }
 221
 222         result[i] = SkClampMax(SkClampPos(int(sum + 0.5f)), 255);
 223     }
 224 }
 225
 226 static void blur_path(SkCanvas* canvas, const SkPath& path,
 227                       SkScalar gaussianSigma) {
 228
 229     SkScalar midX = path.getBounds().centerX();
 230     SkScalar midY = path.getBounds().centerY();
 231
 232     canvas->translate(-midX, -midY);
 233
 234     SkPaint blurPaint;
 235     blurPaint.setColor(SK_ColorWHITE);
 236     SkMaskFilter* filter = SkBlurMaskFilter::Create(kNormal_SkBlurStyle,
 237                                                     gaussianSigma,
 238                                                     SkBlurMaskFilter::kHighQuality_BlurFlag);
 239     blurPaint.setMaskFilter(filter)->unref();
 240
 241     canvas->drawColor(SK_ColorBLACK);
 242     canvas->drawPath(path, blurPaint);
 243 }
 244
 245 // Readback the blurred draw results from the canvas
 246 static void readback(SkCanvas* canvas, int* result, int resultCount) {
 247     SkBitmap readback;
 248     readback.allocN32Pixels(resultCount, 30);
 249
 250     SkIRect readBackRect = { 0, 0, resultCount, 30 };
 251
 252     canvas->readPixels(readBackRect, &readback);
 253
 254     readback.lockPixels();
 255     SkPMColor* pixels = (SkPMColor*) readback.getAddr32(0, 15);
 256
 257     for (int i = 0; i < resultCount; ++i) {
 258         result[i] = SkColorGetR(pixels[i]);
 259     }
 260 }
 261
 262 // Draw a blurred version of the provided path.
 263 // Return the right half of the middle row in 'result'.
 264 static void cpu_blur_path(const SkPath& path, SkScalar gaussianSigma,
 265                           int* result, int resultCount) {
 266
 267     SkBitmap bitmap;
 268     bitmap.allocN32Pixels(resultCount, 30);
 269     SkCanvas canvas(bitmap);
 270
 271     blur_path(&canvas, path, gaussianSigma);
 272     readback(&canvas, result, resultCount);
 273 }
 274
 275 #if SK_SUPPORT_GPU
 276 #if 0
 277 // temporary disable; see below for explanation
 278 static bool gpu_blur_path(GrContextFactory* factory, const SkPath& path,
 279                           SkScalar gaussianSigma,
 280                           int* result, int resultCount) {
 281
 282     GrContext* grContext = factory->get(GrContextFactory::kNative_GLContextType);
 283     if (NULL == grContext) {
 284         return false;
 285     }
 286
 287     GrTextureDesc desc;
 288     desc.fConfig = kSkia8888_GrPixelConfig;
 289     desc.fFlags = kRenderTarget_GrTextureFlagBit;
 290     desc.fWidth = resultCount;
 291     desc.fHeight = 30;
 292     desc.fSampleCnt = 0;
 293
 294     SkAutoTUnref<GrTexture> texture(grContext->createUncachedTexture(desc, NULL, 0));
 295     SkAutoTUnref<SkGpuDevice> device(SkNEW_ARGS(SkGpuDevice, (grContext, texture.get())));
 296     SkCanvas canvas(device.get());
 297
 298     blur_path(&canvas, path, gaussianSigma);
 299     readback(&canvas, result, resultCount);
 300     return true;
 301 }
 302 #endif
 303 #endif
 304
 305 #if WRITE_CSV
 306 static void write_as_csv(const char* label, SkScalar scale, int* data, int count) {
 307     SkDebugf("%s_%.2f,", label, scale);
 308     for (int i = 0; i < count-1; ++i) {
 309         SkDebugf("%d,", data[i]);
 310     }
 311     SkDebugf("%d\n", data[count-1]);
 312 }
 313 #endif
 314
 315 static bool match(int* first, int* second, int count, int tol) {
 316     int delta;
 317     for (int i = 0; i < count; ++i) {
 318         delta = first[i] - second[i];
 319         if (delta > tol || delta < -tol) {
 320             return false;
 321         }
 322     }
 323
 324     return true;
 325 }
 326
 327 // Test out the normal blur style with a wide range of sigmas
 328 static void test_sigma_range(skiatest::Reporter* reporter, GrContextFactory* factory) {
 329
 330     static const int kSize = 100;
 331
 332     // The geometry is offset a smidge to trigger:
 333     // https://code.google.com/p/chromium/issues/detail?id=282418
 334     SkPath rectPath;
 335     rectPath.addRect(0.3f, 0.3f, 100.3f, 100.3f);
 336
 337     SkPoint polyPts[] = {
 338         { 0.3f, 0.3f },
 339         { 100.3f, 0.3f },
 340         { 100.3f, 100.3f },
 341         { 0.3f, 100.3f },
 342         { 2.3f, 50.3f }     // a little divet to throw off the rect special case
 343     };
 344     SkPath polyPath;
 345     polyPath.addPoly(polyPts, SK_ARRAY_COUNT(polyPts), true);
 346
 347     int rectSpecialCaseResult[kSize];
 348     int generalCaseResult[kSize];
 349     int groundTruthResult[kSize];
 350     int bruteForce1DResult[kSize];
 351
 352     SkScalar sigma = 10.0f;
 353
 354     for (int i = 0; i < 4; ++i, sigma /= 10) {
 355
 356         cpu_blur_path(rectPath, sigma, rectSpecialCaseResult, kSize);
 357         cpu_blur_path(polyPath, sigma, generalCaseResult, kSize);
 358
 359         ground_truth_2d(100, 100, sigma, groundTruthResult, kSize);
 360         brute_force_1d(-50.0f, 50.0f, sigma, bruteForce1DResult, kSize);
 361
 362         REPORTER_ASSERT(reporter, match(rectSpecialCaseResult, bruteForce1DResult, kSize, 5));
 363         REPORTER_ASSERT(reporter, match(generalCaseResult, bruteForce1DResult, kSize, 15));
 364 #if SK_SUPPORT_GPU
 365 #if 0
 366         int gpuResult[kSize];
 367         bool haveGPUResult = gpu_blur_path(factory, rectPath, sigma, gpuResult, kSize);
 368         // Disabling this test for now -- I don't think it's a legit comparison.
 369         // Will continue to investigate this.
 370         if (haveGPUResult) {
 371             // 1 works everywhere but: Ubuntu13 & Nexus4
 372             REPORTER_ASSERT(reporter, match(gpuResult, bruteForce1DResult, kSize, 10));
 373         }
 374 #endif
 375 #endif
 376         REPORTER_ASSERT(reporter, match(groundTruthResult, bruteForce1DResult, kSize, 1));
 377
 378 #if WRITE_CSV
 379         write_as_csv("RectSpecialCase", sigma, rectSpecialCaseResult, kSize);
 380         write_as_csv("GeneralCase", sigma, generalCaseResult, kSize);
 381 #if SK_SUPPORT_GPU
 382         write_as_csv("GPU", sigma, gpuResult, kSize);
 383 #endif
 384         write_as_csv("GroundTruth2D", sigma, groundTruthResult, kSize);
 385         write_as_csv("BruteForce1D", sigma, bruteForce1DResult, kSize);
 386 #endif
 387     }
 388 }
 389
 390 ///////////////////////////////////////////////////////////////////////////////////////////
 391
 392 static SkBlurQuality blurMaskFilterFlags_as_quality(uint32_t blurMaskFilterFlags) {
 393     return (blurMaskFilterFlags & SkBlurMaskFilter::kHighQuality_BlurFlag) ?
 394             kHigh_SkBlurQuality : kLow_SkBlurQuality;
 395 }
 396
 397 static uint32_t blurMaskFilterFlags_to_blurDrawLooperFlags(uint32_t bmf) {
 398     const struct {
 399         uint32_t fBlurMaskFilterFlag;
 400         uint32_t fBlurDrawLooperFlag;
 401     } pairs[] = {
 402         { SkBlurMaskFilter::kIgnoreTransform_BlurFlag, SkBlurDrawLooper::kIgnoreTransform_BlurFlag },
 403         { SkBlurMaskFilter::kHighQuality_BlurFlag,     SkBlurDrawLooper::kHighQuality_BlurFlag },
 404     };
 405
 406     uint32_t bdl = 0;
 407     for (size_t i = 0; i < SK_ARRAY_COUNT(pairs); ++i) {
 408         if (bmf & pairs[i].fBlurMaskFilterFlag) {
 409             bdl |= pairs[i].fBlurDrawLooperFlag;
 410         }
 411     }
 412     return bdl;
 413 }
 414
 415 static void test_blurDrawLooper(skiatest::Reporter* reporter, SkScalar sigma,
 416                                 SkBlurStyle style, uint32_t blurMaskFilterFlags) {
 417     if (kNormal_SkBlurStyle != style) {
 418         return; // blurdrawlooper only supports normal
 419     }
 420
 421     const SkColor color = 0xFF335577;
 422     const SkScalar dx = 10;
 423     const SkScalar dy = -5;
 424     const SkBlurQuality quality = blurMaskFilterFlags_as_quality(blurMaskFilterFlags);
 425     uint32_t flags = blurMaskFilterFlags_to_blurDrawLooperFlags(blurMaskFilterFlags);
 426
 427     SkAutoTUnref<SkDrawLooper> lp(SkBlurDrawLooper::Create(color, sigma, dx, dy, flags));
 428
 429     const bool expectSuccess = sigma > 0 &&
 430                                0 == (flags & SkBlurDrawLooper::kIgnoreTransform_BlurFlag);
 431
 432     if (NULL == lp.get()) {
 433         REPORTER_ASSERT(reporter, sigma <= 0);
 434     } else {
 435         SkDrawLooper::BlurShadowRec rec;
 436         bool success = lp->asABlurShadow(&rec);
 437         REPORTER_ASSERT(reporter, success == expectSuccess);
 438         if (success) {
 439             REPORTER_ASSERT(reporter, rec.fSigma == sigma);
 440             REPORTER_ASSERT(reporter, rec.fOffset.x() == dx);
 441             REPORTER_ASSERT(reporter, rec.fOffset.y() == dy);
 442             REPORTER_ASSERT(reporter, rec.fColor == color);
 443             REPORTER_ASSERT(reporter, rec.fStyle == style);
 444             REPORTER_ASSERT(reporter, rec.fQuality == quality);
 445         }
 446     }
 447 }
 448
 449 static void test_delete_looper(skiatest::Reporter* reporter, SkDrawLooper* lp, SkScalar sigma,
 450                                SkBlurStyle style, SkBlurQuality quality, bool expectSuccess) {
 451     SkDrawLooper::BlurShadowRec rec;
 452     bool success = lp->asABlurShadow(&rec);
 453     REPORTER_ASSERT(reporter, success == expectSuccess);
 454     if (success != expectSuccess) {
 455         lp->asABlurShadow(&rec);
 456     }
 457     if (success) {
 458         REPORTER_ASSERT(reporter, rec.fSigma == sigma);
 459         REPORTER_ASSERT(reporter, rec.fStyle == style);
 460         REPORTER_ASSERT(reporter, rec.fQuality == quality);
 461     }
 462     lp->unref();
 463 }
 464
 465 static void make_noop_layer(SkLayerDrawLooper::Builder* builder) {
 466     SkLayerDrawLooper::LayerInfo info;
 467
 468     info.fPaintBits = 0;
 469     info.fColorMode = SkXfermode::kDst_Mode;
 470     builder->addLayer(info);
 471 }
 472
 473 static void make_blur_layer(SkLayerDrawLooper::Builder* builder, SkMaskFilter* mf) {
 474     SkLayerDrawLooper::LayerInfo info;
 475
 476     info.fPaintBits = SkLayerDrawLooper::kMaskFilter_Bit;
 477     info.fColorMode = SkXfermode::kSrc_Mode;
 478     SkPaint* paint = builder->addLayer(info);
 479     paint->setMaskFilter(mf);
 480 }
 481
 482 static void test_layerDrawLooper(skiatest::Reporter* reporter, SkMaskFilter* mf, SkScalar sigma,
 483                                  SkBlurStyle style, SkBlurQuality quality, bool expectSuccess) {
 484
 485     SkLayerDrawLooper::LayerInfo info;
 486     SkLayerDrawLooper::Builder builder;
 487
 488     // 1 layer is too few
 489     make_noop_layer(&builder);
 490     test_delete_looper(reporter, builder.detachLooper(), sigma, style, quality, false);
 491
 492     // 2 layers is good, but need blur
 493     make_noop_layer(&builder);
 494     make_noop_layer(&builder);
 495     test_delete_looper(reporter, builder.detachLooper(), sigma, style, quality, false);
 496
 497     // 2 layers is just right
 498     make_noop_layer(&builder);
 499     make_blur_layer(&builder, mf);
 500     test_delete_looper(reporter, builder.detachLooper(), sigma, style, quality, expectSuccess);
 501
 502     // 3 layers is too many
 503     make_noop_layer(&builder);
 504     make_blur_layer(&builder, mf);
 505     make_noop_layer(&builder);
 506     test_delete_looper(reporter, builder.detachLooper(), sigma, style, quality, false);
 507 }
 508
 509 static void test_asABlur(skiatest::Reporter* reporter) {
 510     const SkBlurStyle styles[] = {
 511         kNormal_SkBlurStyle, kSolid_SkBlurStyle, kOuter_SkBlurStyle, kInner_SkBlurStyle
 512     };
 513     const SkScalar sigmas[] = {
 514         // values <= 0 should not success for a blur
 515         -1, 0, 0.5f, 2
 516     };
 517
 518     // Test asABlur for SkBlurMaskFilter
 519     //
 520     for (size_t i = 0; i < SK_ARRAY_COUNT(styles); ++i) {
 521         const SkBlurStyle style = (SkBlurStyle)styles[i];
 522         for (size_t j = 0; j < SK_ARRAY_COUNT(sigmas); ++j) {
 523             const SkScalar sigma = sigmas[j];
 524             for (int flags = 0; flags <= SkBlurMaskFilter::kAll_BlurFlag; ++flags) {
 525                 const SkBlurQuality quality = blurMaskFilterFlags_as_quality(flags);
 526
 527                 SkAutoTUnref<SkMaskFilter> mf(SkBlurMaskFilter::Create(style, sigma, flags));
 528                 if (NULL == mf.get()) {
 529                     REPORTER_ASSERT(reporter, sigma <= 0);
 530                 } else {
 531                     REPORTER_ASSERT(reporter, sigma > 0);
 532                     SkMaskFilter::BlurRec rec;
 533                     bool success = mf->asABlur(&rec);
 534                     if (flags & SkBlurMaskFilter::kIgnoreTransform_BlurFlag) {
 535                         REPORTER_ASSERT(reporter, !success);
 536                     } else {
 537                         REPORTER_ASSERT(reporter, success);
 538                         REPORTER_ASSERT(reporter, rec.fSigma == sigma);
 539                         REPORTER_ASSERT(reporter, rec.fStyle == style);
 540                         REPORTER_ASSERT(reporter, rec.fQuality == quality);
 541                     }
 542                     test_layerDrawLooper(reporter, mf, sigma, style, quality, success);
 543                 }
 544                 test_blurDrawLooper(reporter, sigma, style, flags);
 545             }
 546         }
 547     }
 548
 549     // Test asABlur for SkEmbossMaskFilter -- should never succeed
 550     //
 551     {
 552         SkEmbossMaskFilter::Light light = {
 553             { 1, 1, 1 }, 0, 127, 127
 554         };
 555         for (size_t j = 0; j < SK_ARRAY_COUNT(sigmas); ++j) {
 556             const SkScalar sigma = sigmas[j];
 557             SkAutoTUnref<SkMaskFilter> mf(SkEmbossMaskFilter::Create(sigma, light));
 558             if (mf.get()) {
 559                 SkMaskFilter::BlurRec rec;
 560                 bool success = mf->asABlur(&rec);
 561                 REPORTER_ASSERT(reporter, !success);
 562             }
 563         }
 564     }
 565 }
 566
 567 ///////////////////////////////////////////////////////////////////////////////////////////
 568
 569 DEF_GPUTEST(Blur, reporter, factory) {
 570     test_blur_drawing(reporter);
 571     test_sigma_range(reporter, factory);
 572     test_asABlur(reporter);
 573 }