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 "SkCanvas.h" 9 #include "SkColorPriv.h" 10 #include "SkColorShader.h" 11 #include "SkGradientShader.h" 12 #include "SkShader.h" 13 #include "SkSurface.h" 14 #include "SkTemplates.h" 15 #include "SkTLazy.h" 16 #include "Test.h" 17 18 // https://code.google.com/p/chromium/issues/detail?id=448299 19 // Giant (inverse) matrix causes overflow when converting/computing using 32.32 20 // Before the fix, we would assert (and then crash). 21 static void test_big_grad(skiatest::Reporter* reporter) { 22 const SkColor colors[] = { SK_ColorRED, SK_ColorBLUE }; 23 const SkPoint pts[] = {{ 15, 14.7112684f }, { 0.709064007f, 12.6108112f }}; 24 SkPaint paint; 25 paint.setShader(SkGradientShader::MakeLinear(pts, colors, nullptr, 2, 26 SkShader::kClamp_TileMode)); 27 28 SkBitmap bm; 29 bm.allocN32Pixels(2000, 1); 30 SkCanvas c(bm); 31 32 const SkScalar affine[] = { 33 1.06608627e-06f, 4.26434525e-07f, 6.2855f, 2.6611f, 273.4393f, 244.0046f 34 }; 35 SkMatrix matrix; 36 matrix.setAffine(affine); 37 c.concat(matrix); 38 39 c.drawPaint(paint); 40 } 41 42 struct GradRec { 43 int fColorCount; 44 const SkColor* fColors; 45 const SkScalar* fPos; 46 const SkPoint* fPoint; // 2 47 const SkScalar* fRadius; // 2 48 SkShader::TileMode fTileMode; 49 50 void gradCheck(skiatest::Reporter* reporter, const sk_sp<SkShader>& shader, 51 SkShader::GradientInfo* info, 52 SkShader::GradientType gt) const { 53 SkAutoTMalloc<SkColor> colorStorage(fColorCount); 54 SkAutoTMalloc<SkScalar> posStorage(fColorCount); 55 56 info->fColorCount = fColorCount; 57 info->fColors = colorStorage; 58 info->fColorOffsets = posStorage.get(); 59 REPORTER_ASSERT(reporter, shader->asAGradient(info) == gt); 60 61 REPORTER_ASSERT(reporter, info->fColorCount == fColorCount); 62 REPORTER_ASSERT(reporter, 63 !memcmp(info->fColors, fColors, fColorCount * sizeof(SkColor))); 64 REPORTER_ASSERT(reporter, 65 !memcmp(info->fColorOffsets, fPos, fColorCount * sizeof(SkScalar))); 66 REPORTER_ASSERT(reporter, fTileMode == info->fTileMode); 67 } 68 }; 69 70 71 static void none_gradproc(skiatest::Reporter* reporter, const GradRec&, const GradRec&) { 72 sk_sp<SkShader> s(SkShader::MakeEmptyShader()); 73 REPORTER_ASSERT(reporter, SkShader::kNone_GradientType == s->asAGradient(nullptr)); 74 } 75 76 static void color_gradproc(skiatest::Reporter* reporter, const GradRec& rec, const GradRec&) { 77 sk_sp<SkShader> s(new SkColorShader(rec.fColors[0])); 78 REPORTER_ASSERT(reporter, SkShader::kColor_GradientType == s->asAGradient(nullptr)); 79 80 SkShader::GradientInfo info; 81 info.fColors = nullptr; 82 info.fColorCount = 0; 83 s->asAGradient(&info); 84 REPORTER_ASSERT(reporter, 1 == info.fColorCount); 85 } 86 87 static void linear_gradproc(skiatest::Reporter* reporter, const GradRec& buildRec, 88 const GradRec& checkRec) { 89 sk_sp<SkShader> s(SkGradientShader::MakeLinear(buildRec.fPoint, buildRec.fColors, buildRec.fPos, 90 buildRec.fColorCount, buildRec.fTileMode)); 91 92 SkShader::GradientInfo info; 93 checkRec.gradCheck(reporter, s, &info, SkShader::kLinear_GradientType); 94 REPORTER_ASSERT(reporter, !memcmp(info.fPoint, checkRec.fPoint, 2 * sizeof(SkPoint))); 95 } 96 97 static void radial_gradproc(skiatest::Reporter* reporter, const GradRec& buildRec, 98 const GradRec& checkRec) { 99 sk_sp<SkShader> s(SkGradientShader::MakeRadial(buildRec.fPoint[0], buildRec.fRadius[0], 100 buildRec.fColors, buildRec.fPos, 101 buildRec.fColorCount, buildRec.fTileMode)); 102 103 SkShader::GradientInfo info; 104 checkRec.gradCheck(reporter, s, &info, SkShader::kRadial_GradientType); 105 REPORTER_ASSERT(reporter, info.fPoint[0] == checkRec.fPoint[0]); 106 REPORTER_ASSERT(reporter, info.fRadius[0] == checkRec.fRadius[0]); 107 } 108 109 static void sweep_gradproc(skiatest::Reporter* reporter, const GradRec& buildRec, 110 const GradRec& checkRec) { 111 sk_sp<SkShader> s(SkGradientShader::MakeSweep(buildRec.fPoint[0].fX, buildRec.fPoint[0].fY, 112 buildRec.fColors, buildRec.fPos, 113 buildRec.fColorCount)); 114 115 SkShader::GradientInfo info; 116 checkRec.gradCheck(reporter, s, &info, SkShader::kSweep_GradientType); 117 REPORTER_ASSERT(reporter, info.fPoint[0] == checkRec.fPoint[0]); 118 } 119 120 static void conical_gradproc(skiatest::Reporter* reporter, const GradRec& buildRec, 121 const GradRec& checkRec) { 122 sk_sp<SkShader> s(SkGradientShader::MakeTwoPointConical(buildRec.fPoint[0], 123 buildRec.fRadius[0], 124 buildRec.fPoint[1], 125 buildRec.fRadius[1], 126 buildRec.fColors, 127 buildRec.fPos, 128 buildRec.fColorCount, 129 buildRec.fTileMode)); 130 131 SkShader::GradientInfo info; 132 checkRec.gradCheck(reporter, s, &info, SkShader::kConical_GradientType); 133 REPORTER_ASSERT(reporter, !memcmp(info.fPoint, checkRec.fPoint, 2 * sizeof(SkPoint))); 134 REPORTER_ASSERT(reporter, !memcmp(info.fRadius, checkRec.fRadius, 2 * sizeof(SkScalar))); 135 } 136 137 // Ensure that repeated color gradients behave like drawing a single color 138 static void TestConstantGradient(skiatest::Reporter*) { 139 const SkPoint pts[] = { 140 { 0, 0 }, 141 { SkIntToScalar(10), 0 } 142 }; 143 SkColor colors[] = { SK_ColorBLUE, SK_ColorBLUE }; 144 const SkScalar pos[] = { 0, SK_Scalar1 }; 145 SkPaint paint; 146 paint.setShader(SkGradientShader::MakeLinear(pts, colors, pos, 2, SkShader::kClamp_TileMode)); 147 SkBitmap outBitmap; 148 outBitmap.allocN32Pixels(10, 1); 149 SkCanvas canvas(outBitmap); 150 canvas.drawPaint(paint); 151 for (int i = 0; i < 10; i++) { 152 // The following is commented out because it currently fails 153 // Related bug: https://code.google.com/p/skia/issues/detail?id=1098 154 155 // REPORTER_ASSERT(reporter, SK_ColorBLUE == outBitmap.getColor(i, 0)); 156 } 157 } 158 159 typedef void (*GradProc)(skiatest::Reporter* reporter, const GradRec&, const GradRec&); 160 161 static void TestGradientShaders(skiatest::Reporter* reporter) { 162 static const SkColor gColors[] = { SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE }; 163 static const SkScalar gPos[] = { 0, SK_ScalarHalf, SK_Scalar1 }; 164 static const SkPoint gPts[] = { 165 { 0, 0 }, 166 { SkIntToScalar(10), SkIntToScalar(20) } 167 }; 168 static const SkScalar gRad[] = { SkIntToScalar(1), SkIntToScalar(2) }; 169 170 GradRec rec; 171 rec.fColorCount = SK_ARRAY_COUNT(gColors); 172 rec.fColors = gColors; 173 rec.fPos = gPos; 174 rec.fPoint = gPts; 175 rec.fRadius = gRad; 176 rec.fTileMode = SkShader::kClamp_TileMode; 177 178 static const GradProc gProcs[] = { 179 none_gradproc, 180 color_gradproc, 181 linear_gradproc, 182 radial_gradproc, 183 sweep_gradproc, 184 conical_gradproc, 185 }; 186 187 for (size_t i = 0; i < SK_ARRAY_COUNT(gProcs); ++i) { 188 gProcs[i](reporter, rec, rec); 189 } 190 } 191 192 static void TestGradientOptimization(skiatest::Reporter* reporter) { 193 static const struct { 194 GradProc fProc; 195 bool fIsClampRestricted; 196 } gProcInfo[] = { 197 { linear_gradproc , false }, 198 { radial_gradproc , false }, 199 { sweep_gradproc , true }, // sweep is funky in that it always pretends to be kClamp. 200 { conical_gradproc, false }, 201 }; 202 203 static const SkColor gC_00[] = { 0xff000000, 0xff000000 }; 204 static const SkColor gC_01[] = { 0xff000000, 0xffffffff }; 205 static const SkColor gC_11[] = { 0xffffffff, 0xffffffff }; 206 static const SkColor gC_001[] = { 0xff000000, 0xff000000, 0xffffffff }; 207 static const SkColor gC_011[] = { 0xff000000, 0xffffffff, 0xffffffff }; 208 static const SkColor gC_0011[] = { 0xff000000, 0xff000000, 0xffffffff, 0xffffffff }; 209 210 static const SkScalar gP_01[] = { 0, 1 }; 211 static const SkScalar gP_001[] = { 0, 0, 1 }; 212 static const SkScalar gP_011[] = { 0, 1, 1 }; 213 static const SkScalar gP_0x1[] = { 0, .5f, 1 }; 214 static const SkScalar gP_0011[] = { 0, 0, 1, 1 }; 215 216 static const SkPoint gPts[] = { {0, 0}, {1, 1} }; 217 static const SkScalar gRadii[] = { 1, 2 }; 218 219 static const struct { 220 const SkColor* fCol; 221 const SkScalar* fPos; 222 int fCount; 223 224 const SkColor* fExpectedCol; 225 const SkScalar* fExpectedPos; 226 int fExpectedCount; 227 bool fRequiresNonClamp; 228 } gTests[] = { 229 { gC_001, gP_001, 3, gC_01, gP_01, 2, false }, 230 { gC_001, gP_011, 3, gC_00, gP_01, 2, true }, 231 { gC_001, gP_0x1, 3, gC_001, gP_0x1, 3, false }, 232 { gC_001, nullptr, 3, gC_001, gP_0x1, 3, false }, 233 234 { gC_011, gP_001, 3, gC_11, gP_01, 2, true }, 235 { gC_011, gP_011, 3, gC_01, gP_01, 2, false }, 236 { gC_011, gP_0x1, 3, gC_011, gP_0x1, 3, false }, 237 { gC_011, nullptr, 3, gC_011, gP_0x1, 3, false }, 238 239 { gC_0011, gP_0011, 4, gC_0011, gP_0011, 4, false }, 240 }; 241 242 for (size_t i = 0; i < SK_ARRAY_COUNT(gProcInfo); ++i) { 243 for (int mode = 0; mode < SkShader::kTileModeCount; ++mode) { 244 if (gProcInfo[i].fIsClampRestricted && mode != SkShader::kClamp_TileMode) { 245 continue; 246 } 247 248 for (size_t t = 0; t < SK_ARRAY_COUNT(gTests); ++t) { 249 GradRec rec; 250 rec.fColorCount = gTests[t].fCount; 251 rec.fColors = gTests[t].fCol; 252 rec.fPos = gTests[t].fPos; 253 rec.fTileMode = static_cast<SkShader::TileMode>(mode); 254 rec.fPoint = gPts; 255 rec.fRadius = gRadii; 256 257 GradRec expected = rec; 258 if (!gTests[t].fRequiresNonClamp || mode != SkShader::kClamp_TileMode) { 259 expected.fColorCount = gTests[t].fExpectedCount; 260 expected.fColors = gTests[t].fExpectedCol; 261 expected.fPos = gTests[t].fExpectedPos; 262 } 263 264 gProcInfo[i].fProc(reporter, rec, expected); 265 } 266 } 267 } 268 } 269 270 static void test_nearly_vertical(skiatest::Reporter* reporter) { 271 auto surface(SkSurface::MakeRasterN32Premul(200, 200)); 272 273 const SkPoint pts[] = {{ 100, 50 }, { 100.0001f, 50000 }}; 274 const SkColor colors[] = { SK_ColorBLACK, SK_ColorWHITE }; 275 const SkScalar pos[] = { 0, 1 }; 276 SkPaint paint; 277 paint.setShader(SkGradientShader::MakeLinear(pts, colors, pos, 2, SkShader::kClamp_TileMode)); 278 279 surface->getCanvas()->drawPaint(paint); 280 } 281 282 static void test_vertical(skiatest::Reporter* reporter) { 283 auto surface(SkSurface::MakeRasterN32Premul(200, 200)); 284 285 const SkPoint pts[] = {{ 100, 50 }, { 100, 50 }}; 286 const SkColor colors[] = { SK_ColorBLACK, SK_ColorWHITE }; 287 const SkScalar pos[] = { 0, 1 }; 288 SkPaint paint; 289 paint.setShader(SkGradientShader::MakeLinear(pts, colors, pos, 2, SkShader::kClamp_TileMode)); 290 291 surface->getCanvas()->drawPaint(paint); 292 } 293 294 // A linear gradient interval can, due to numerical imprecision (likely in the divide) 295 // finish an interval with the final fx not landing outside of [p0...p1]. 296 // The old code had an assert which this test triggered. 297 // We now explicitly clamp the resulting fx value. 298 static void test_linear_fuzz(skiatest::Reporter* reporter) { 299 auto surface(SkSurface::MakeRasterN32Premul(1300, 630)); 300 301 const SkPoint pts[] = {{ 179.5f, -179.5f }, { 1074.5f, 715.5f }}; 302 const SkColor colors[] = { SK_ColorBLACK, SK_ColorWHITE, SK_ColorBLACK, SK_ColorWHITE }; 303 const SkScalar pos[] = {0, 0.200000003f, 0.800000012f, 1 }; 304 305 SkPaint paint; 306 paint.setShader(SkGradientShader::MakeLinear(pts, colors, pos, 4, SkShader::kClamp_TileMode)); 307 308 SkRect r = {0, 83, 1254, 620}; 309 surface->getCanvas()->drawRect(r, paint); 310 } 311 312 // https://bugs.chromium.org/p/skia/issues/detail?id=5023 313 // We should still shade pixels for which the radius is exactly 0. 314 static void test_two_point_conical_zero_radius(skiatest::Reporter* reporter) { 315 auto surface(SkSurface::MakeRasterN32Premul(5, 5)); 316 surface->getCanvas()->clear(SK_ColorRED); 317 318 const SkColor colors[] = { SK_ColorGREEN, SK_ColorBLUE }; 319 SkPaint p; 320 p.setShader(SkGradientShader::MakeTwoPointConical( 321 SkPoint::Make(2.5f, 2.5f), 0, 322 SkPoint::Make(3.0f, 3.0f), 10, 323 colors, nullptr, SK_ARRAY_COUNT(colors), SkShader::kClamp_TileMode)); 324 surface->getCanvas()->drawPaint(p); 325 326 // r == 0 for the center pixel. 327 // verify that we draw it (no red bleed) 328 SkPMColor centerPMColor; 329 surface->readPixels(SkImageInfo::MakeN32Premul(1, 1), ¢erPMColor, sizeof(SkPMColor), 2, 2); 330 REPORTER_ASSERT(reporter, SkGetPackedR32(centerPMColor) == 0); 331 } 332 333 // http://crbug.com/599458 334 static void test_clamping_overflow(skiatest::Reporter*) { 335 SkPaint p; 336 const SkColor colors[] = { SK_ColorRED, SK_ColorGREEN }; 337 const SkPoint pts1[] = { SkPoint::Make(1001, 1000001), SkPoint::Make(1000.99f, 1000000) }; 338 339 p.setShader(SkGradientShader::MakeLinear(pts1, colors, nullptr, 2, SkShader::kClamp_TileMode)); 340 341 sk_sp<SkSurface> surface(SkSurface::MakeRasterN32Premul(50, 50)); 342 surface->getCanvas()->scale(100, 100); 343 surface->getCanvas()->drawPaint(p); 344 345 const SkPoint pts2[] = { SkPoint::Make(10000.99f, 1000000), SkPoint::Make(10001, 1000001) }; 346 p.setShader(SkGradientShader::MakeLinear(pts2, colors, nullptr, 2, SkShader::kClamp_TileMode)); 347 surface->getCanvas()->drawPaint(p); 348 349 // Passes if we don't trigger asserts. 350 } 351 352 // http://crbug.com/636194 353 static void test_degenerate_linear(skiatest::Reporter*) { 354 SkPaint p; 355 const SkColor colors[] = { SK_ColorRED, SK_ColorGREEN }; 356 const SkPoint pts[] = { 357 SkPoint::Make(-46058024627067344430605278824628224.0f, 0), 358 SkPoint::Make(SK_ScalarMax, 0) 359 }; 360 361 p.setShader(SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkShader::kClamp_TileMode)); 362 sk_sp<SkSurface> surface(SkSurface::MakeRasterN32Premul(50, 50)); 363 surface->getCanvas()->drawPaint(p); 364 365 // Passes if we don't trigger asserts. 366 } 367 368 // "Interesting" fuzzer values. 369 static void test_linear_fuzzer(skiatest::Reporter*) { 370 static const SkColor gColors0[] = { 0x30303030, 0x30303030 }; 371 static const SkColor gColors1[] = { 0x30303030, 0x30303030, 0x30303030 }; 372 373 static const SkScalar gPos1[] = { 0, 0, 1 }; 374 375 static const SkScalar gMatrix0[9] = { 376 6.40969056e-10f, 0 , 6.40969056e-10f, 377 0 , 4.42539023e-39f, 6.40969056e-10f, 378 0 , 0 , 1 379 }; 380 static const SkScalar gMatrix1[9] = { 381 -2.75294113f , 6.40969056e-10f, 6.40969056e-10f, 382 6.40969056e-10f, 6.40969056e-10f, -3.32810161e+24f, 383 6.40969056e-10f, 6.40969056e-10f, 0 384 }; 385 static const SkScalar gMatrix2[9] = { 386 7.93481258e+17f, 6.40969056e-10f, 6.40969056e-10f, 387 6.40969056e-10f, 6.40969056e-10f, 6.40969056e-10f, 388 6.40969056e-10f, 6.40969056e-10f, 0.688235283f 389 }; 390 static const SkScalar gMatrix3[9] = { 391 1.89180674e+11f, 6.40969056e-10f, 6.40969056e-10f, 392 6.40969056e-10f, 6.40969056e-10f, 6.40969056e-10f, 393 6.40969056e-10f, 11276.0469f , 8.12524808e+20f 394 }; 395 396 static const struct { 397 SkPoint fPts[2]; 398 const SkColor* fColors; 399 const SkScalar* fPos; 400 int fCount; 401 SkShader::TileMode fTileMode; 402 uint32_t fFlags; 403 const SkScalar* fLocalMatrix; 404 const SkScalar* fGlobalMatrix; 405 } gConfigs[] = { 406 { 407 {{0, -2.752941f}, {0, 0}}, 408 gColors0, 409 nullptr, 410 SK_ARRAY_COUNT(gColors0), 411 SkShader::kClamp_TileMode, 412 0, 413 gMatrix0, 414 nullptr 415 }, 416 { 417 {{4.42539023e-39f, -4.42539023e-39f}, {9.78041162e-15f, 4.42539023e-39f}}, 418 gColors1, 419 gPos1, 420 SK_ARRAY_COUNT(gColors1), 421 SkShader::kClamp_TileMode, 422 0, 423 nullptr, 424 gMatrix1 425 }, 426 { 427 {{4.42539023e-39f, 6.40969056e-10f}, {6.40969056e-10f, 1.49237238e-19f}}, 428 gColors1, 429 gPos1, 430 SK_ARRAY_COUNT(gColors1), 431 SkShader::kClamp_TileMode, 432 0, 433 nullptr, 434 gMatrix2 435 }, 436 { 437 {{6.40969056e-10f, 6.40969056e-10f}, {6.40969056e-10f, -0.688235283f}}, 438 gColors0, 439 nullptr, 440 SK_ARRAY_COUNT(gColors0), 441 SkShader::kClamp_TileMode, 442 0, 443 gMatrix3, 444 nullptr 445 }, 446 }; 447 448 sk_sp<SkColorSpace> srgb = SkColorSpace::MakeSRGB(); 449 SkColorSpace* colorSpaces[] = { 450 nullptr, // hits the legacy gradient impl 451 srgb.get(), // triggers 4f/raster-pipeline 452 }; 453 454 SkPaint paint; 455 456 for (auto colorSpace : colorSpaces) { 457 458 sk_sp<SkSurface> surface = SkSurface::MakeRaster(SkImageInfo::Make(100, 100, 459 kN32_SkColorType, 460 kPremul_SkAlphaType, 461 sk_ref_sp(colorSpace))); 462 SkCanvas* canvas = surface->getCanvas(); 463 464 for (const auto& config : gConfigs) { 465 SkAutoCanvasRestore acr(canvas, false); 466 SkTLazy<SkMatrix> localMatrix; 467 if (config.fLocalMatrix) { 468 localMatrix.init(); 469 localMatrix.get()->set9(config.fLocalMatrix); 470 } 471 472 paint.setShader(SkGradientShader::MakeLinear(config.fPts, 473 config.fColors, 474 config.fPos, 475 config.fCount, 476 config.fTileMode, 477 config.fFlags, 478 localMatrix.getMaybeNull())); 479 if (config.fGlobalMatrix) { 480 SkMatrix m; 481 m.set9(config.fGlobalMatrix); 482 canvas->save(); 483 canvas->concat(m); 484 } 485 486 canvas->drawPaint(paint); 487 } 488 } 489 } 490 491 static void test_sweep_fuzzer(skiatest::Reporter*) { 492 static const SkColor gColors0[] = { 0x30303030, 0x30303030, 0x30303030 }; 493 static const SkScalar gPos0[] = { -47919293023455565225163489280.0f, 0, 1 }; 494 static const SkScalar gMatrix0[9] = { 495 1.12116716e-13f, 0 , 8.50489682e+16f, 496 4.1917041e-41f , 3.51369881e-23f, -2.54344271e-26f, 497 9.61111907e+17f, -3.35263808e-29f, -1.35659403e+14f 498 }; 499 static const struct { 500 SkPoint fCenter; 501 const SkColor* fColors; 502 const SkScalar* fPos; 503 int fCount; 504 const SkScalar* fGlobalMatrix; 505 } gConfigs[] = { 506 { 507 { 0, 0 }, 508 gColors0, 509 gPos0, 510 SK_ARRAY_COUNT(gColors0), 511 gMatrix0 512 }, 513 }; 514 515 sk_sp<SkSurface> surface = SkSurface::MakeRasterN32Premul(100, 100); 516 SkCanvas* canvas = surface->getCanvas(); 517 SkPaint paint; 518 519 for (const auto& config : gConfigs) { 520 paint.setShader(SkGradientShader::MakeSweep(config.fCenter.x(), 521 config.fCenter.y(), 522 config.fColors, 523 config.fPos, 524 config.fCount)); 525 526 SkAutoCanvasRestore acr(canvas, false); 527 if (config.fGlobalMatrix) { 528 SkMatrix m; 529 m.set9(config.fGlobalMatrix); 530 canvas->save(); 531 canvas->concat(m); 532 } 533 canvas->drawPaint(paint); 534 } 535 } 536 537 DEF_TEST(Gradient, reporter) { 538 TestGradientShaders(reporter); 539 TestGradientOptimization(reporter); 540 TestConstantGradient(reporter); 541 test_big_grad(reporter); 542 test_nearly_vertical(reporter); 543 test_vertical(reporter); 544 test_linear_fuzz(reporter); 545 test_two_point_conical_zero_radius(reporter); 546 test_clamping_overflow(reporter); 547 test_degenerate_linear(reporter); 548 test_linear_fuzzer(reporter); 549 test_sweep_fuzzer(reporter); 550 } 551
