1 /*
2 * Copyright 2018 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 "gm.h"
9
10 #include "SkColorSpace.h"
11 #include "SkColorSpaceXformSteps.h"
12 #include "SkDashPathEffect.h"
13 #include "SkFont.h"
14 #include "SkGradientShader.h"
15 #include "SkString.h"
16
nearly_equal(SkColor4f x,SkColor4f y)17 static bool nearly_equal(SkColor4f x, SkColor4f y) {
18 const float K = 0.01f;
19 return fabsf(x.fR - y.fR) < K
20 && fabsf(x.fG - y.fG) < K
21 && fabsf(x.fB - y.fB) < K
22 && fabsf(x.fA - y.fA) < K;
23 }
24
fmt(SkColor4f c)25 static SkString fmt(SkColor4f c) {
26 return SkStringPrintf("%.2g %.2g %.2g %.2g", c.fR, c.fG, c.fB, c.fA);
27 }
28
transform(SkColor4f c,SkColorSpace * src,SkColorSpace * dst)29 static SkColor4f transform(SkColor4f c, SkColorSpace* src, SkColorSpace* dst) {
30 SkColorSpaceXformSteps(src, kUnpremul_SkAlphaType,
31 dst, kUnpremul_SkAlphaType).apply(c.vec());
32 return c;
33 }
34
compare_pixel(const char * label,SkCanvas * canvas,int x,int y,SkColor4f color,SkColorSpace * cs)35 static void compare_pixel(const char* label,
36 SkCanvas* canvas, int x, int y,
37 SkColor4f color, SkColorSpace* cs) {
38 SkPaint paint;
39 SkFont font;
40 auto canvas_cs = canvas->imageInfo().refColorSpace();
41
42 // I'm not really sure if this makes things easier or harder to follow,
43 // but we sniff the canvas to grab its current y-translate, so that (x,y)
44 // can be written in sort of chunk-relative terms.
45 const SkMatrix& m = canvas->getTotalMatrix();
46 SkASSERT(m.isTranslate());
47 SkScalar dy = m.getTranslateY();
48 SkASSERT(dy == (int)dy);
49 y += (int)dy;
50
51 SkBitmap bm;
52 bm.allocPixels(SkImageInfo::Make(1,1, kRGBA_F32_SkColorType, kUnpremul_SkAlphaType, canvas_cs));
53 if (!canvas->readPixels(bm, x,y)) {
54 MarkGMGood(canvas, 140,40);
55 canvas->drawString("can't readPixels() on this canvas :(", 100,20, font, paint);
56 return;
57 }
58
59 SkColor4f pixel;
60 memcpy(&pixel, bm.getAddr(0,0), sizeof(pixel));
61
62 SkColor4f expected = transform(color,cs, canvas_cs.get());
63 if (canvas->imageInfo().colorType() < kRGBA_F16_SkColorType) {
64 // We can't expect normalized formats to hold values outside [0,1].
65 for (int i = 0; i < 4; ++i) {
66 expected[i] = SkTPin(expected[i], 0.0f, 1.0f);
67 }
68 }
69 if (canvas->imageInfo().colorType() == kGray_8_SkColorType) {
70 // Drawing into Gray8 is known to be maybe-totally broken.
71 // TODO: update expectation here to be {lum,lum,lum,1} if we fix Gray8.
72 expected = SkColor4f{NAN, NAN, NAN, 1};
73 }
74
75 if (nearly_equal(pixel, expected)) {
76 MarkGMGood(canvas, 140,40);
77 } else {
78 MarkGMBad(canvas, 140,40);
79 }
80
81 struct {
82 const char* label;
83 SkColor4f color;
84 } lines[] = {
85 {"Pixel:" , pixel },
86 {"Expected:", expected},
87 };
88
89 SkAutoCanvasRestore saveRestore(canvas, true);
90 canvas->drawString(label, 80,20, font, paint);
91 for (auto l : lines) {
92 canvas->translate(0,20);
93 canvas->drawString(l.label, 80,20, font, paint);
94 canvas->drawString(fmt(l.color).c_str(), 140,20, font, paint);
95 }
96 }
97
98 DEF_SIMPLE_GM(p3, canvas, 450, 1300) {
99 auto p3 = SkColorSpace::MakeRGB(SkNamedTransferFn::kSRGB, SkNamedGamut::kDCIP3);
100 auto srgb = SkColorSpace::MakeSRGB();
101
__anon0255b67f0202(SkColor4f c) 102 auto p3_to_srgb = [&](SkColor4f c) {
103 SkPaint p;
104 p.setColor4f(c, p3.get());
105 return p.getColor4f();
106 };
107
108 // Draw a P3 red rectangle and check the corner.
109 {
110 SkPaint paint;
111 paint.setColor4f({1,0,0,1}, p3.get());
112
113 canvas->drawRect({10,10,70,70}, paint);
114 compare_pixel("drawRect P3 red ",
115 canvas, 10,10,
116 {1,0,0,1}, p3.get());
117 }
118
119 canvas->translate(0,80);
120
121 // Draw a P3 red bitmap, using a draw.
122 {
123 SkBitmap bm;
124 bm.allocPixels(SkImageInfo::Make(60,60, kRGBA_F16_SkColorType, kPremul_SkAlphaType, p3));
125
126 SkPaint paint;
127 paint.setColor4f({1,0,0,1}, p3.get());
128 SkCanvas{bm}.drawPaint(paint);
129
130 canvas->drawBitmap(bm, 10,10);
131 compare_pixel("drawBitmap P3 red, from drawPaint",
132 canvas, 10,10,
133 {1,0,0,1}, p3.get());
134 }
135
136 canvas->translate(0,80);
137
138 // Draw a P3 red bitmap, using SkBitmap::eraseColor().
139 {
140 SkBitmap bm;
141 bm.allocPixels(SkImageInfo::Make(60,60, kRGBA_F16_SkColorType, kPremul_SkAlphaType, p3));
142
143 bm.eraseColor(0xffff0000/*in P3*/);
144
145 canvas->drawBitmap(bm, 10,10);
146 compare_pixel("drawBitmap P3 red, from SkBitmap::eraseColor()",
147 canvas, 10,10,
148 {1,0,0,1}, p3.get());
149 }
150
151 canvas->translate(0,80);
152
153 // Draw a P3 red bitmap, using SkPixmap::erase().
154 {
155 SkBitmap bm;
156 bm.allocPixels(SkImageInfo::Make(60,60, kRGBA_F16_SkColorType, kPremul_SkAlphaType, p3));
157
158 // At the moment only SkPixmap has an erase() that takes an SkColor4f.
159 SkPixmap pm;
160 SkAssertResult(bm.peekPixels(&pm));
161 SkAssertResult(pm.erase({1,0,0,1} /*in p3*/));
162
163 canvas->drawBitmap(bm, 10,10);
164 compare_pixel("drawBitmap P3 red, from SkPixmap::erase",
165 canvas, 10,10,
166 {1,0,0,1}, p3.get());
167 }
168
169 canvas->translate(0,80);
170
171 // Draw a P3 red bitmap wrapped in a shader, using SkPixmap::erase().
172 {
173 SkBitmap bm;
174 bm.allocPixels(SkImageInfo::Make(60,60, kRGBA_F16_SkColorType, kPremul_SkAlphaType, p3));
175
176 // At the moment only SkPixmap has an erase() that takes an SkColor4f.
177 SkPixmap pm;
178 SkAssertResult(bm.peekPixels(&pm));
179 SkAssertResult(pm.erase({1,0,0,1} /*in p3*/));
180
181 SkPaint paint;
182 paint.setShader(SkShader::MakeBitmapShader(bm, SkShader::kRepeat_TileMode,
183 SkShader::kRepeat_TileMode));
184
185 canvas->drawRect({10,10,70,70}, paint);
186 compare_pixel("drawBitmapAsShader P3 red, from SkPixmap::erase",
187 canvas, 10,10,
188 {1,0,0,1}, p3.get());
189 }
190
191 canvas->translate(0,80);
192
193 // TODO(mtklein): sample and check the middle points of these gradients too.
194
195 // Draw a gradient from P3 red to P3 green interpolating in unpremul P3, checking the corners.
196 {
197
198 SkPoint points[] = {{10.5,10.5}, {69.5,69.5}};
199 SkColor4f colors[] = {{1,0,0,1}, {0,1,0,1}};
200
201 SkPaint paint;
202 paint.setShader(SkGradientShader::MakeLinear(points, colors, p3,
203 nullptr, SK_ARRAY_COUNT(colors),
204 SkShader::kClamp_TileMode));
205 canvas->drawRect({10,10,70,70}, paint);
206 canvas->save();
207 compare_pixel("UPM P3 gradient, P3 red",
208 canvas, 10,10,
209 {1,0,0,1}, p3.get());
210
211 canvas->translate(180, 0);
212
213 compare_pixel("UPM P3 gradient, P3 green",
214 canvas, 69,69,
215 {0,1,0,1}, p3.get());
216 canvas->restore();
217 }
218
219 canvas->translate(0,80);
220
221 // Draw a gradient from P3 red to P3 green interpolating in premul P3, checking the corners.
222 {
223
224 SkPoint points[] = {{10.5,10.5}, {69.5,69.5}};
225 SkColor4f colors[] = {{1,0,0,1}, {0,1,0,1}};
226
227 SkPaint paint;
228 paint.setShader(
229 SkGradientShader::MakeLinear(points, colors, p3,
230 nullptr, SK_ARRAY_COUNT(colors),
231 SkShader::kClamp_TileMode,
232 SkGradientShader::kInterpolateColorsInPremul_Flag,
233 nullptr/*local matrix*/));
234 canvas->drawRect({10,10,70,70}, paint);
235 canvas->save();
236 compare_pixel("PM P3 gradient, P3 red",
237 canvas, 10,10,
238 {1,0,0,1}, p3.get());
239
240 canvas->translate(180, 0);
241
242 compare_pixel("PM P3 gradient, P3 green",
243 canvas, 69,69,
244 {0,1,0,1}, p3.get());
245 canvas->restore();
246 }
247
248 canvas->translate(0,80);
249
250 // Draw a gradient from P3 red to P3 green interpolating in unpremul sRGB, checking the corners.
251 {
252
253 SkPoint points[] = {{10.5,10.5}, {69.5,69.5}};
254 SkColor4f colors[] = {p3_to_srgb({1,0,0,1}), p3_to_srgb({0,1,0,1})};
255
256 SkPaint paint;
257 paint.setShader(SkGradientShader::MakeLinear(points, colors, srgb,
258 nullptr, SK_ARRAY_COUNT(colors),
259 SkShader::kClamp_TileMode));
260 canvas->drawRect({10,10,70,70}, paint);
261 canvas->save();
262 compare_pixel("UPM sRGB gradient, P3 red",
263 canvas, 10,10,
264 {1,0,0,1}, p3.get());
265
266 canvas->translate(180, 0);
267
268 compare_pixel("UPM sRGB gradient, P3 green",
269 canvas, 69,69,
270 {0,1,0,1}, p3.get());
271 canvas->restore();
272 }
273
274 canvas->translate(0,80);
275
276 // Draw a gradient from P3 red to P3 green interpolating in premul sRGB, checking the corners.
277 {
278
279 SkPoint points[] = {{10.5,10.5}, {69.5,69.5}};
280 SkColor4f colors[] = {p3_to_srgb({1,0,0,1}), p3_to_srgb({0,1,0,1})};
281
282 SkPaint paint;
283 paint.setShader(
284 SkGradientShader::MakeLinear(points, colors, srgb,
285 nullptr, SK_ARRAY_COUNT(colors),
286 SkShader::kClamp_TileMode,
287 SkGradientShader::kInterpolateColorsInPremul_Flag,
288 nullptr/*local matrix*/));
289 canvas->drawRect({10,10,70,70}, paint);
290 canvas->save();
291 compare_pixel("PM sRGB gradient, P3 red",
292 canvas, 10,10,
293 {1,0,0,1}, p3.get());
294
295 canvas->translate(180, 0);
296
297 compare_pixel("PM sRGB gradient, P3 green",
298 canvas, 69,69,
299 {0,1,0,1}, p3.get());
300 canvas->restore();
301 }
302
303 canvas->translate(0,80);
304
305 // Leon's blue -> green -> red gradient, interpolating in premul.
306 {
307 SkPoint points[] = {{10.5,10.5}, {10.5,69.5}};
308 SkColor4f colors[] = { {0,0,1,1}, {0,1,0,1}, {1,0,0,1} };
309
310 SkPaint paint;
311 paint.setShader(
312 SkGradientShader::MakeLinear(points, colors, p3,
313 nullptr, SK_ARRAY_COUNT(colors),
314 SkShader::kClamp_TileMode,
315 SkGradientShader::kInterpolateColorsInPremul_Flag,
316 nullptr/*local matrix*/));
317 canvas->drawRect({10,10,70,70}, paint);
318 canvas->save();
319 compare_pixel("Leon's gradient, P3 blue",
320 canvas, 10,10,
321 {0,0,1,1}, p3.get());
322
323 canvas->translate(180, 0);
324
325 compare_pixel("Leon's gradient, P3 red",
326 canvas, 10,69,
327 {1,0,0,1}, p3.get());
328 canvas->restore();
329 }
330
331 canvas->translate(0,80);
332
333 // Draw an A8 image with a P3 red, scaled and not, as a shader or bitmap.
334 {
335 uint8_t mask[256];
336 for (int i = 0; i < 256; i++) {
337 mask[i] = 255-i;
338 }
339 SkBitmap bm;
340 bm.installPixels(SkImageInfo::MakeA8(16,16), mask, 16);
341
342 SkPaint as_bitmap;
343 as_bitmap.setColor4f({1,0,0,1}, p3.get());
344 as_bitmap.setFilterQuality(kLow_SkFilterQuality);
345
346 SkPaint as_shader;
347 as_shader.setColor4f({1,0,0,1}, p3.get());
348 as_shader.setFilterQuality(kLow_SkFilterQuality);
349 as_shader.setShader(SkShader::MakeBitmapShader(bm, SkShader::kClamp_TileMode
350 , SkShader::kClamp_TileMode));
351
352 canvas->drawBitmap(bm, 10,10, &as_bitmap);
353 compare_pixel("A8 sprite bitmap P3 red",
354 canvas, 10,10,
355 {1,0,0,1}, p3.get());
356
357 canvas->translate(0, 80);
358
359 canvas->save();
360 canvas->translate(10,10);
361 canvas->drawRect({0,0,16,16}, as_shader);
362 canvas->restore();
363 compare_pixel("A8 sprite shader P3 red",
364 canvas, 10,10,
365 {1,0,0,1}, p3.get());
366
367 canvas->translate(0,80);
368
369 canvas->drawBitmapRect(bm, {10,10,70,70}, &as_bitmap);
370 compare_pixel("A8 scaled bitmap P3 red",
371 canvas, 10,10,
372 {1,0,0,1}, p3.get());
373
374 canvas->translate(0,80);
375
376 canvas->save();
377 canvas->translate(10,10);
378 canvas->scale(3.75,3.75);
379 canvas->drawRect({0,0,16,16}, as_shader);
380 canvas->restore();
381 compare_pixel("A8 scaled shader P3 red",
382 canvas, 10,10,
383 {1,0,0,1}, p3.get());
384 }
385
386 // TODO: draw P3 colors more ways
387 }
388
389 DEF_SIMPLE_GM(p3_ovals, canvas, 450, 320) {
390 auto p3 = SkColorSpace::MakeRGB(SkNamedTransferFn::kSRGB, SkNamedGamut::kDCIP3);
391
392 // Test cases that exercise each Op in GrOvalOpFactory.cpp
393
394 // Draw a circle and check the center (CircleOp)
395 {
396 SkPaint paint;
397 paint.setAntiAlias(true);
398 paint.setColor4f({ 1,0,0,1 }, p3.get());
399
400 canvas->drawCircle(40, 40, 30, paint);
401 compare_pixel("drawCircle P3 red ",
402 canvas, 40, 40,
403 { 1,0,0,1 }, p3.get());
404 }
405
406 canvas->translate(0, 80);
407
408 // Draw an oval and check the center (EllipseOp)
409 {
410 SkPaint paint;
411 paint.setAntiAlias(true);
412 paint.setColor4f({ 1,0,0,1 }, p3.get());
413
414 canvas->drawOval({ 20,10,60,70 }, paint);
415 compare_pixel("drawOval P3 red ",
416 canvas, 40, 40,
417 { 1,0,0,1 }, p3.get());
418 }
419
420 canvas->translate(0, 80);
421
422 // Draw a butt-capped dashed circle and check the top of the stroke (ButtCappedDashedCircleOp)
423 {
424 SkPaint paint;
425 paint.setAntiAlias(true);
426 paint.setColor4f({ 1,0,0,1 }, p3.get());
427 paint.setStyle(SkPaint::kStroke_Style);
428 float intervals[] = { 70, 10 };
429 paint.setPathEffect(SkDashPathEffect::Make(intervals, 2, 0));
430 paint.setStrokeWidth(10);
431
432 canvas->drawCircle(40, 40, 30, paint);
433 compare_pixel("drawDashedCircle P3 red ",
434 canvas, 40, 10,
435 { 1,0,0,1 }, p3.get());
436 }
437
438 canvas->translate(0, 80);
439
440 // Draw an oval with rotation and check the center (DIEllipseOp)
441 {
442 SkPaint paint;
443 paint.setAntiAlias(true);
444 paint.setColor4f({ 1,0,0,1 }, p3.get());
445
446 canvas->save();
447 canvas->translate(40, 40);
448 canvas->rotate(45);
449 canvas->drawOval({ -20,-30,20,30 }, paint);
450 canvas->restore();
451 compare_pixel("drawRotatedOval P3 red ",
452 canvas, 40, 40,
453 { 1,0,0,1 }, p3.get());
454 }
455
456 canvas->translate(0, 80);
457 }
458