OLD | NEW |
1 | |
2 /* | 1 /* |
3 * Copyright 2011 Google Inc. | 2 * Copyright 2011 Google Inc. |
4 * | 3 * |
5 * Use of this source code is governed by a BSD-style license that can be | 4 * Use of this source code is governed by a BSD-style license that can be |
6 * found in the LICENSE file. | 5 * found in the LICENSE file. |
7 */ | 6 */ |
| 7 |
8 #include "SkBlurMask.h" | 8 #include "SkBlurMask.h" |
9 #include "SkBlurMaskFilter.h" | 9 #include "SkBlurMaskFilter.h" |
| 10 #include "SkBlurDrawLooper.h" |
| 11 #include "SkLayerDrawLooper.h" |
| 12 #include "SkEmbossMaskFilter.h" |
10 #include "SkCanvas.h" | 13 #include "SkCanvas.h" |
11 #include "SkMath.h" | 14 #include "SkMath.h" |
12 #include "SkPaint.h" | 15 #include "SkPaint.h" |
13 #include "Test.h" | 16 #include "Test.h" |
14 | 17 |
15 #if SK_SUPPORT_GPU | 18 #if SK_SUPPORT_GPU |
16 #include "GrContextFactory.h" | 19 #include "GrContextFactory.h" |
17 #include "SkGpuDevice.h" | 20 #include "SkGpuDevice.h" |
18 #endif | 21 #endif |
19 | 22 |
(...skipping 353 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
373 write_as_csv("GeneralCase", sigma, generalCaseResult, kSize); | 376 write_as_csv("GeneralCase", sigma, generalCaseResult, kSize); |
374 #if SK_SUPPORT_GPU | 377 #if SK_SUPPORT_GPU |
375 write_as_csv("GPU", sigma, gpuResult, kSize); | 378 write_as_csv("GPU", sigma, gpuResult, kSize); |
376 #endif | 379 #endif |
377 write_as_csv("GroundTruth2D", sigma, groundTruthResult, kSize); | 380 write_as_csv("GroundTruth2D", sigma, groundTruthResult, kSize); |
378 write_as_csv("BruteForce1D", sigma, bruteForce1DResult, kSize); | 381 write_as_csv("BruteForce1D", sigma, bruteForce1DResult, kSize); |
379 #endif | 382 #endif |
380 } | 383 } |
381 } | 384 } |
382 | 385 |
| 386 ////////////////////////////////////////////////////////////////////////////////
/////////// |
| 387 |
| 388 static SkBlurQuality blurMaskFilterFlags_as_quality(uint32_t blurMaskFilterFlags
) { |
| 389 return (blurMaskFilterFlags & SkBlurMaskFilter::kHighQuality_BlurFlag) ? |
| 390 kHigh_SkBlurQuality : kLow_SkBlurQuality; |
| 391 } |
| 392 |
| 393 static uint32_t blurMaskFilterFlags_to_blurDrawLooperFlags(uint32_t bmf) { |
| 394 const struct { |
| 395 uint32_t fBlurMaskFilterFlag; |
| 396 uint32_t fBlurDrawLooperFlag; |
| 397 } pairs[] = { |
| 398 { SkBlurMaskFilter::kIgnoreTransform_BlurFlag, SkBlurDrawLooper::kIgnore
Transform_BlurFlag }, |
| 399 { SkBlurMaskFilter::kHighQuality_BlurFlag, SkBlurDrawLooper::kHighQu
ality_BlurFlag }, |
| 400 }; |
| 401 |
| 402 uint32_t bdl = 0; |
| 403 for (size_t i = 0; i < SK_ARRAY_COUNT(pairs); ++i) { |
| 404 if (bmf & pairs[i].fBlurMaskFilterFlag) { |
| 405 bdl |= pairs[i].fBlurDrawLooperFlag; |
| 406 } |
| 407 } |
| 408 return bdl; |
| 409 } |
| 410 |
| 411 static void test_blurDrawLooper(skiatest::Reporter* reporter, SkScalar sigma, |
| 412 SkBlurStyle style, uint32_t blurMaskFilterFlags)
{ |
| 413 if (kNormal_SkBlurStyle != style) { |
| 414 return; // blurdrawlooper only supports normal |
| 415 } |
| 416 |
| 417 const SkColor color = 0xFF335577; |
| 418 const SkScalar dx = 10; |
| 419 const SkScalar dy = -5; |
| 420 const SkBlurQuality quality = blurMaskFilterFlags_as_quality(blurMaskFilterF
lags); |
| 421 uint32_t flags = blurMaskFilterFlags_to_blurDrawLooperFlags(blurMaskFilterFl
ags); |
| 422 |
| 423 SkAutoTUnref<SkDrawLooper> lp(SkBlurDrawLooper::Create(color, sigma, dx, dy,
flags)); |
| 424 |
| 425 const bool expectSuccess = sigma > 0 && |
| 426 0 == (flags & SkBlurDrawLooper::kIgnoreTransform_
BlurFlag); |
| 427 |
| 428 if (NULL == lp.get()) { |
| 429 REPORTER_ASSERT(reporter, sigma <= 0); |
| 430 } else { |
| 431 SkDrawLooper::BlurShadowRec rec; |
| 432 bool success = lp->asABlurShadow(&rec); |
| 433 REPORTER_ASSERT(reporter, success == expectSuccess); |
| 434 if (success) { |
| 435 REPORTER_ASSERT(reporter, rec.fSigma == sigma); |
| 436 REPORTER_ASSERT(reporter, rec.fOffset.x() == dx); |
| 437 REPORTER_ASSERT(reporter, rec.fOffset.y() == dy); |
| 438 REPORTER_ASSERT(reporter, rec.fColor == color); |
| 439 REPORTER_ASSERT(reporter, rec.fStyle == style); |
| 440 REPORTER_ASSERT(reporter, rec.fQuality == quality); |
| 441 } |
| 442 } |
| 443 } |
| 444 |
| 445 static void test_delete_looper(skiatest::Reporter* reporter, SkDrawLooper* lp, S
kScalar sigma, |
| 446 SkBlurStyle style, SkBlurQuality quality, bool ex
pectSuccess) { |
| 447 SkDrawLooper::BlurShadowRec rec; |
| 448 bool success = lp->asABlurShadow(&rec); |
| 449 REPORTER_ASSERT(reporter, success == expectSuccess); |
| 450 if (success != expectSuccess) { |
| 451 lp->asABlurShadow(&rec); |
| 452 } |
| 453 if (success) { |
| 454 REPORTER_ASSERT(reporter, rec.fSigma == sigma); |
| 455 REPORTER_ASSERT(reporter, rec.fStyle == style); |
| 456 REPORTER_ASSERT(reporter, rec.fQuality == quality); |
| 457 } |
| 458 lp->unref(); |
| 459 } |
| 460 |
| 461 static void make_noop_layer(SkLayerDrawLooper::Builder* builder) { |
| 462 SkLayerDrawLooper::LayerInfo info; |
| 463 |
| 464 info.fPaintBits = 0; |
| 465 info.fColorMode = SkXfermode::kDst_Mode; |
| 466 builder->addLayer(info); |
| 467 } |
| 468 |
| 469 static void make_blur_layer(SkLayerDrawLooper::Builder* builder, SkMaskFilter* m
f) { |
| 470 SkLayerDrawLooper::LayerInfo info; |
| 471 |
| 472 info.fPaintBits = SkLayerDrawLooper::kMaskFilter_Bit; |
| 473 info.fColorMode = SkXfermode::kSrc_Mode; |
| 474 SkPaint* paint = builder->addLayer(info); |
| 475 paint->setMaskFilter(mf); |
| 476 } |
| 477 |
| 478 static void test_layerDrawLooper(skiatest::Reporter* reporter, SkMaskFilter* mf,
SkScalar sigma, |
| 479 SkBlurStyle style, SkBlurQuality quality, bool
expectSuccess) { |
| 480 |
| 481 SkLayerDrawLooper::LayerInfo info; |
| 482 SkLayerDrawLooper::Builder builder; |
| 483 |
| 484 // 1 layer is too few |
| 485 make_noop_layer(&builder); |
| 486 test_delete_looper(reporter, builder.detachLooper(), sigma, style, quality,
false); |
| 487 |
| 488 // 2 layers is good, but need blur |
| 489 make_noop_layer(&builder); |
| 490 make_noop_layer(&builder); |
| 491 test_delete_looper(reporter, builder.detachLooper(), sigma, style, quality,
false); |
| 492 |
| 493 // 2 layers is just right |
| 494 make_noop_layer(&builder); |
| 495 make_blur_layer(&builder, mf); |
| 496 test_delete_looper(reporter, builder.detachLooper(), sigma, style, quality,
expectSuccess); |
| 497 |
| 498 // 3 layers is too many |
| 499 make_noop_layer(&builder); |
| 500 make_blur_layer(&builder, mf); |
| 501 make_noop_layer(&builder); |
| 502 test_delete_looper(reporter, builder.detachLooper(), sigma, style, quality,
false); |
| 503 } |
| 504 |
| 505 static void test_asABlur(skiatest::Reporter* reporter) { |
| 506 const SkBlurStyle styles[] = { |
| 507 kNormal_SkBlurStyle, kSolid_SkBlurStyle, kOuter_SkBlurStyle, kInner_SkBl
urStyle |
| 508 }; |
| 509 const SkScalar sigmas[] = { |
| 510 // values <= 0 should not success for a blur |
| 511 -1, 0, 0.5f, 2 |
| 512 }; |
| 513 |
| 514 // Test asABlur for SkBlurMaskFilter |
| 515 // |
| 516 for (size_t i = 0; i < SK_ARRAY_COUNT(styles); ++i) { |
| 517 const SkBlurStyle style = (SkBlurStyle)styles[i]; |
| 518 for (size_t j = 0; j < SK_ARRAY_COUNT(sigmas); ++j) { |
| 519 const SkScalar sigma = sigmas[j]; |
| 520 for (int flags = 0; flags <= SkBlurMaskFilter::kAll_BlurFlag; ++flag
s) { |
| 521 const SkBlurQuality quality = blurMaskFilterFlags_as_quality(fla
gs); |
| 522 |
| 523 SkAutoTUnref<SkMaskFilter> mf(SkBlurMaskFilter::Create(style, si
gma, flags)); |
| 524 if (NULL == mf.get()) { |
| 525 REPORTER_ASSERT(reporter, sigma <= 0); |
| 526 } else { |
| 527 REPORTER_ASSERT(reporter, sigma > 0); |
| 528 SkMaskFilter::BlurRec rec; |
| 529 bool success = mf->asABlur(&rec); |
| 530 if (flags & SkBlurMaskFilter::kIgnoreTransform_BlurFlag) { |
| 531 REPORTER_ASSERT(reporter, !success); |
| 532 } else { |
| 533 REPORTER_ASSERT(reporter, success); |
| 534 REPORTER_ASSERT(reporter, rec.fSigma == sigma); |
| 535 REPORTER_ASSERT(reporter, rec.fStyle == style); |
| 536 REPORTER_ASSERT(reporter, rec.fQuality == quality); |
| 537 } |
| 538 test_layerDrawLooper(reporter, mf, sigma, style, quality, su
ccess); |
| 539 } |
| 540 test_blurDrawLooper(reporter, sigma, style, flags); |
| 541 } |
| 542 } |
| 543 } |
| 544 |
| 545 // Test asABlur for SkEmbossMaskFilter -- should never succeed |
| 546 // |
| 547 { |
| 548 SkEmbossMaskFilter::Light light = { |
| 549 { 1, 1, 1 }, 0, 127, 127 |
| 550 }; |
| 551 for (size_t j = 0; j < SK_ARRAY_COUNT(sigmas); ++j) { |
| 552 const SkScalar sigma = sigmas[j]; |
| 553 SkAutoTUnref<SkMaskFilter> mf(SkEmbossMaskFilter::Create(sigma, ligh
t)); |
| 554 if (mf.get()) { |
| 555 SkMaskFilter::BlurRec rec; |
| 556 bool success = mf->asABlur(&rec); |
| 557 REPORTER_ASSERT(reporter, !success); |
| 558 } |
| 559 } |
| 560 } |
| 561 } |
| 562 |
| 563 ////////////////////////////////////////////////////////////////////////////////
/////////// |
| 564 |
383 DEF_GPUTEST(Blur, reporter, factory) { | 565 DEF_GPUTEST(Blur, reporter, factory) { |
384 test_blur_drawing(reporter); | 566 test_blur_drawing(reporter); |
385 test_sigma_range(reporter, factory); | 567 test_sigma_range(reporter, factory); |
| 568 test_asABlur(reporter); |
386 } | 569 } |
OLD | NEW |