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