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 "SkMathPriv.h"
11 #include "SkSurface.h"
12 #include "Test.h"
13 #include "sk_tool_utils.h"
14
15 #if SK_SUPPORT_GPU
16 #include "GrContext.h"
17 #endif
18
19 #include <initializer_list>
20
21 static const int DEV_W = 100, DEV_H = 100;
22 static const SkIRect DEV_RECT = SkIRect::MakeWH(DEV_W, DEV_H);
23 static const SkRect DEV_RECT_S = SkRect::MakeWH(DEV_W * SK_Scalar1,
24 DEV_H * SK_Scalar1);
25 static const U8CPU DEV_PAD = 0xee;
26
get_canvas_color(int x,int y)27 static SkPMColor get_canvas_color(int x, int y) {
28 SkASSERT(x >= 0 && x < DEV_W);
29 SkASSERT(y >= 0 && y < DEV_H);
30
31 U8CPU r = x;
32 U8CPU g = y;
33 U8CPU b = 0xc;
34
35 U8CPU a = 0x0;
36 switch ((x+y) % 5) {
37 case 0:
38 a = 0xff;
39 break;
40 case 1:
41 a = 0x80;
42 break;
43 case 2:
44 a = 0xCC;
45 break;
46 case 3:
47 a = 0x00;
48 break;
49 case 4:
50 a = 0x01;
51 break;
52 }
53 return SkPremultiplyARGBInline(a, r, g, b);
54 }
55
56 // assumes any premu/.unpremul has been applied
pack_color_type(SkColorType ct,U8CPU a,U8CPU r,U8CPU g,U8CPU b)57 static uint32_t pack_color_type(SkColorType ct, U8CPU a, U8CPU r, U8CPU g, U8CPU b) {
58 uint32_t r32;
59 uint8_t* result = reinterpret_cast<uint8_t*>(&r32);
60 switch (ct) {
61 case kBGRA_8888_SkColorType:
62 result[0] = b;
63 result[1] = g;
64 result[2] = r;
65 result[3] = a;
66 break;
67 case kRGBA_8888_SkColorType:
68 result[0] = r;
69 result[1] = g;
70 result[2] = b;
71 result[3] = a;
72 break;
73 default:
74 SkASSERT(0);
75 return 0;
76 }
77 return r32;
78 }
79
get_bitmap_color(int x,int y,int w,SkColorType ct,SkAlphaType at)80 static uint32_t get_bitmap_color(int x, int y, int w, SkColorType ct, SkAlphaType at) {
81 int n = y * w + x;
82 U8CPU b = n & 0xff;
83 U8CPU g = (n >> 8) & 0xff;
84 U8CPU r = (n >> 16) & 0xff;
85 U8CPU a = 0;
86 switch ((x+y) % 5) {
87 case 4:
88 a = 0xff;
89 break;
90 case 3:
91 a = 0x80;
92 break;
93 case 2:
94 a = 0xCC;
95 break;
96 case 1:
97 a = 0x01;
98 break;
99 case 0:
100 a = 0x00;
101 break;
102 }
103 if (kPremul_SkAlphaType == at) {
104 r = SkMulDiv255Ceiling(r, a);
105 g = SkMulDiv255Ceiling(g, a);
106 b = SkMulDiv255Ceiling(b, a);
107 }
108 return pack_color_type(ct, a, r, g , b);
109 }
110
fill_canvas(SkCanvas * canvas)111 static void fill_canvas(SkCanvas* canvas) {
112 SkBitmap bmp;
113 if (bmp.isNull()) {
114 bmp.allocN32Pixels(DEV_W, DEV_H);
115 for (int y = 0; y < DEV_H; ++y) {
116 for (int x = 0; x < DEV_W; ++x) {
117 *bmp.getAddr32(x, y) = get_canvas_color(x, y);
118 }
119 }
120 }
121 canvas->save();
122 canvas->setMatrix(SkMatrix::I());
123 canvas->clipRect(DEV_RECT_S, kReplace_SkClipOp);
124 SkPaint paint;
125 paint.setBlendMode(SkBlendMode::kSrc);
126 canvas->drawBitmap(bmp, 0, 0, &paint);
127 canvas->restore();
128 }
129
130 /**
131 * Lucky for us, alpha is always in the same spot (SK_A32_SHIFT), for both RGBA and BGRA.
132 * Thus this routine doesn't need to know the exact colortype
133 */
premul(uint32_t color)134 static uint32_t premul(uint32_t color) {
135 unsigned a = SkGetPackedA32(color);
136 // these next three are not necessarily r,g,b in that order, but they are r,g,b in some order.
137 unsigned c0 = SkGetPackedR32(color);
138 unsigned c1 = SkGetPackedG32(color);
139 unsigned c2 = SkGetPackedB32(color);
140 c0 = SkMulDiv255Ceiling(c0, a);
141 c1 = SkMulDiv255Ceiling(c1, a);
142 c2 = SkMulDiv255Ceiling(c2, a);
143 return SkPackARGB32NoCheck(a, c0, c1, c2);
144 }
145
convert_to_PMColor(SkColorType ct,SkAlphaType at,uint32_t color)146 static SkPMColor convert_to_PMColor(SkColorType ct, SkAlphaType at, uint32_t color) {
147 if (kUnpremul_SkAlphaType == at) {
148 color = premul(color);
149 }
150 switch (ct) {
151 case kRGBA_8888_SkColorType:
152 color = SkSwizzle_RGBA_to_PMColor(color);
153 break;
154 case kBGRA_8888_SkColorType:
155 color = SkSwizzle_BGRA_to_PMColor(color);
156 break;
157 default:
158 SkASSERT(0);
159 break;
160 }
161 return color;
162 }
163
check_pixel(SkPMColor a,SkPMColor b,bool didPremulConversion)164 static bool check_pixel(SkPMColor a, SkPMColor b, bool didPremulConversion) {
165 if (!didPremulConversion) {
166 return a == b;
167 }
168 int32_t aA = static_cast<int32_t>(SkGetPackedA32(a));
169 int32_t aR = static_cast<int32_t>(SkGetPackedR32(a));
170 int32_t aG = static_cast<int32_t>(SkGetPackedG32(a));
171 int32_t aB = SkGetPackedB32(a);
172
173 int32_t bA = static_cast<int32_t>(SkGetPackedA32(b));
174 int32_t bR = static_cast<int32_t>(SkGetPackedR32(b));
175 int32_t bG = static_cast<int32_t>(SkGetPackedG32(b));
176 int32_t bB = static_cast<int32_t>(SkGetPackedB32(b));
177
178 return aA == bA &&
179 SkAbs32(aR - bR) <= 1 &&
180 SkAbs32(aG - bG) <= 1 &&
181 SkAbs32(aB - bB) <= 1;
182 }
183
check_write(skiatest::Reporter * reporter,SkCanvas * canvas,const SkBitmap & bitmap,int writeX,int writeY)184 static bool check_write(skiatest::Reporter* reporter, SkCanvas* canvas, const SkBitmap& bitmap,
185 int writeX, int writeY) {
186 const SkImageInfo canvasInfo = canvas->imageInfo();
187 size_t canvasRowBytes;
188 const uint32_t* canvasPixels;
189
190 // Can't use canvas->peekPixels(), as we are trying to look at GPU pixels sometimes as well.
191 // At some point this will be unsupported, as we won't allow accessBitmap() to magically call
192 // readPixels for the client.
193 SkBitmap secretDevBitmap;
194 if (!canvas->readPixels(canvasInfo.bounds(), &secretDevBitmap)) {
195 return false;
196 }
197
198 SkAutoLockPixels alp(secretDevBitmap);
199 canvasRowBytes = secretDevBitmap.rowBytes();
200 canvasPixels = static_cast<const uint32_t*>(secretDevBitmap.getPixels());
201
202 if (nullptr == canvasPixels) {
203 return false;
204 }
205
206 if (canvasInfo.width() != DEV_W ||
207 canvasInfo.height() != DEV_H ||
208 canvasInfo.colorType() != kN32_SkColorType) {
209 return false;
210 }
211
212 const SkImageInfo bmInfo = bitmap.info();
213
214 SkIRect writeRect = SkIRect::MakeXYWH(writeX, writeY, bitmap.width(), bitmap.height());
215 for (int cy = 0; cy < DEV_H; ++cy) {
216 for (int cx = 0; cx < DEV_W; ++cx) {
217 SkPMColor canvasPixel = canvasPixels[cx];
218 if (writeRect.contains(cx, cy)) {
219 int bx = cx - writeX;
220 int by = cy - writeY;
221 uint32_t bmpColor8888 = get_bitmap_color(bx, by, bitmap.width(),
222 bmInfo.colorType(), bmInfo.alphaType());
223 bool mul = (kUnpremul_SkAlphaType == bmInfo.alphaType());
224 SkPMColor bmpPMColor = convert_to_PMColor(bmInfo.colorType(), bmInfo.alphaType(),
225 bmpColor8888);
226 if (!check_pixel(bmpPMColor, canvasPixel, mul)) {
227 ERRORF(reporter, "Expected canvas pixel at %d, %d to be 0x%08x, got 0x%08x. "
228 "Write performed premul: %d", cx, cy, bmpPMColor, canvasPixel, mul);
229 return false;
230 }
231 } else {
232 SkPMColor testColor = get_canvas_color(cx, cy);
233 if (canvasPixel != testColor) {
234 ERRORF(reporter, "Canvas pixel outside write rect at %d, %d changed."
235 " Should be 0x%08x, got 0x%08x. ", cx, cy, testColor, canvasPixel);
236 return false;
237 }
238 }
239 }
240 if (cy != DEV_H -1) {
241 const char* pad = reinterpret_cast<const char*>(canvasPixels + DEV_W);
242 for (size_t px = 0; px < canvasRowBytes - 4 * DEV_W; ++px) {
243 bool check;
244 REPORTER_ASSERT(reporter, check = (pad[px] == static_cast<char>(DEV_PAD)));
245 if (!check) {
246 return false;
247 }
248 }
249 }
250 canvasPixels += canvasRowBytes/4;
251 }
252
253 return true;
254 }
255
256 #include "SkMallocPixelRef.h"
257
258 // This is a tricky pattern, because we have to setConfig+rowBytes AND specify
259 // a custom pixelRef (which also has to specify its rowBytes), so we have to be
260 // sure that the two rowBytes match (and the infos match).
261 //
alloc_row_bytes(SkBitmap * bm,const SkImageInfo & info,size_t rowBytes)262 static bool alloc_row_bytes(SkBitmap* bm, const SkImageInfo& info, size_t rowBytes) {
263 if (!bm->setInfo(info, rowBytes)) {
264 return false;
265 }
266 sk_sp<SkPixelRef> pr(SkMallocPixelRef::NewAllocate(info, rowBytes, nullptr));
267 bm->setPixelRef(std::move(pr), 0, 0);
268 return true;
269 }
270
free_pixels(void * pixels,void * ctx)271 static void free_pixels(void* pixels, void* ctx) {
272 sk_free(pixels);
273 }
274
setup_bitmap(SkBitmap * bm,SkColorType ct,SkAlphaType at,int w,int h,int tightRB)275 static bool setup_bitmap(SkBitmap* bm, SkColorType ct, SkAlphaType at, int w, int h, int tightRB) {
276 size_t rowBytes = tightRB ? 0 : 4 * w + 60;
277 SkImageInfo info = SkImageInfo::Make(w, h, ct, at);
278 if (!alloc_row_bytes(bm, info, rowBytes)) {
279 return false;
280 }
281 SkAutoLockPixels alp(*bm);
282 for (int y = 0; y < h; ++y) {
283 for (int x = 0; x < w; ++x) {
284 *bm->getAddr32(x, y) = get_bitmap_color(x, y, w, ct, at);
285 }
286 }
287 return true;
288 }
289
call_writepixels(SkCanvas * canvas)290 static void call_writepixels(SkCanvas* canvas) {
291 const SkImageInfo info = SkImageInfo::MakeN32Premul(1, 1);
292 SkPMColor pixel = 0;
293 canvas->writePixels(info, &pixel, sizeof(SkPMColor), 0, 0);
294 }
295
DEF_TEST(WritePixelsSurfaceGenID,reporter)296 DEF_TEST(WritePixelsSurfaceGenID, reporter) {
297 const SkImageInfo info = SkImageInfo::MakeN32Premul(100, 100);
298 auto surface(SkSurface::MakeRaster(info));
299 uint32_t genID1 = surface->generationID();
300 call_writepixels(surface->getCanvas());
301 uint32_t genID2 = surface->generationID();
302 REPORTER_ASSERT(reporter, genID1 != genID2);
303 }
304
test_write_pixels(skiatest::Reporter * reporter,SkSurface * surface)305 static void test_write_pixels(skiatest::Reporter* reporter, SkSurface* surface) {
306 const SkIRect testRects[] = {
307 // entire thing
308 DEV_RECT,
309 // larger on all sides
310 SkIRect::MakeLTRB(-10, -10, DEV_W + 10, DEV_H + 10),
311 // fully contained
312 SkIRect::MakeLTRB(DEV_W / 4, DEV_H / 4, 3 * DEV_W / 4, 3 * DEV_H / 4),
313 // outside top left
314 SkIRect::MakeLTRB(-10, -10, -1, -1),
315 // touching top left corner
316 SkIRect::MakeLTRB(-10, -10, 0, 0),
317 // overlapping top left corner
318 SkIRect::MakeLTRB(-10, -10, DEV_W / 4, DEV_H / 4),
319 // overlapping top left and top right corners
320 SkIRect::MakeLTRB(-10, -10, DEV_W + 10, DEV_H / 4),
321 // touching entire top edge
322 SkIRect::MakeLTRB(-10, -10, DEV_W + 10, 0),
323 // overlapping top right corner
324 SkIRect::MakeLTRB(3 * DEV_W / 4, -10, DEV_W + 10, DEV_H / 4),
325 // contained in x, overlapping top edge
326 SkIRect::MakeLTRB(DEV_W / 4, -10, 3 * DEV_W / 4, DEV_H / 4),
327 // outside top right corner
328 SkIRect::MakeLTRB(DEV_W + 1, -10, DEV_W + 10, -1),
329 // touching top right corner
330 SkIRect::MakeLTRB(DEV_W, -10, DEV_W + 10, 0),
331 // overlapping top left and bottom left corners
332 SkIRect::MakeLTRB(-10, -10, DEV_W / 4, DEV_H + 10),
333 // touching entire left edge
334 SkIRect::MakeLTRB(-10, -10, 0, DEV_H + 10),
335 // overlapping bottom left corner
336 SkIRect::MakeLTRB(-10, 3 * DEV_H / 4, DEV_W / 4, DEV_H + 10),
337 // contained in y, overlapping left edge
338 SkIRect::MakeLTRB(-10, DEV_H / 4, DEV_W / 4, 3 * DEV_H / 4),
339 // outside bottom left corner
340 SkIRect::MakeLTRB(-10, DEV_H + 1, -1, DEV_H + 10),
341 // touching bottom left corner
342 SkIRect::MakeLTRB(-10, DEV_H, 0, DEV_H + 10),
343 // overlapping bottom left and bottom right corners
344 SkIRect::MakeLTRB(-10, 3 * DEV_H / 4, DEV_W + 10, DEV_H + 10),
345 // touching entire left edge
346 SkIRect::MakeLTRB(0, DEV_H, DEV_W, DEV_H + 10),
347 // overlapping bottom right corner
348 SkIRect::MakeLTRB(3 * DEV_W / 4, 3 * DEV_H / 4, DEV_W + 10, DEV_H + 10),
349 // overlapping top right and bottom right corners
350 SkIRect::MakeLTRB(3 * DEV_W / 4, -10, DEV_W + 10, DEV_H + 10),
351 };
352
353 SkCanvas& canvas = *surface->getCanvas();
354
355 static const struct {
356 SkColorType fColorType;
357 SkAlphaType fAlphaType;
358 } gSrcConfigs[] = {
359 { kRGBA_8888_SkColorType, kPremul_SkAlphaType },
360 { kRGBA_8888_SkColorType, kUnpremul_SkAlphaType },
361 { kBGRA_8888_SkColorType, kPremul_SkAlphaType },
362 { kBGRA_8888_SkColorType, kUnpremul_SkAlphaType },
363 };
364 for (size_t r = 0; r < SK_ARRAY_COUNT(testRects); ++r) {
365 const SkIRect& rect = testRects[r];
366 for (int tightBmp = 0; tightBmp < 2; ++tightBmp) {
367 for (size_t c = 0; c < SK_ARRAY_COUNT(gSrcConfigs); ++c) {
368 const SkColorType ct = gSrcConfigs[c].fColorType;
369 const SkAlphaType at = gSrcConfigs[c].fAlphaType;
370
371 fill_canvas(&canvas);
372 SkBitmap bmp;
373 REPORTER_ASSERT(reporter, setup_bitmap(&bmp, ct, at, rect.width(),
374 rect.height(), SkToBool(tightBmp)));
375 uint32_t idBefore = surface->generationID();
376
377 // sk_tool_utils::write_pixels(&canvas, bmp, rect.fLeft, rect.fTop, ct, at);
378 canvas.writePixels(bmp, rect.fLeft, rect.fTop);
379
380 uint32_t idAfter = surface->generationID();
381 REPORTER_ASSERT(reporter, check_write(reporter, &canvas, bmp,
382 rect.fLeft, rect.fTop));
383
384 // we should change the genID iff pixels were actually written.
385 SkIRect canvasRect = SkIRect::MakeSize(canvas.getBaseLayerSize());
386 SkIRect writeRect = SkIRect::MakeXYWH(rect.fLeft, rect.fTop,
387 bmp.width(), bmp.height());
388 bool intersects = SkIRect::Intersects(canvasRect, writeRect) ;
389 REPORTER_ASSERT(reporter, intersects == (idBefore != idAfter));
390 }
391 }
392 }
393 }
DEF_TEST(WritePixels,reporter)394 DEF_TEST(WritePixels, reporter) {
395 const SkImageInfo info = SkImageInfo::MakeN32Premul(DEV_W, DEV_H);
396 for (auto& tightRowBytes : { true, false }) {
397 const size_t rowBytes = tightRowBytes ? info.minRowBytes() : 4 * DEV_W + 100;
398 const size_t size = info.getSafeSize(rowBytes);
399 void* pixels = sk_malloc_throw(size);
400 // if rowBytes isn't tight then set the padding to a known value
401 if (!tightRowBytes) {
402 memset(pixels, DEV_PAD, size);
403 }
404 auto surface(SkSurface::MakeRasterDirectReleaseProc(info, pixels, rowBytes,
405 free_pixels, nullptr));
406 test_write_pixels(reporter, surface.get());
407 }
408 }
409 #if SK_SUPPORT_GPU
DEF_GPUTEST_FOR_RENDERING_CONTEXTS(WritePixels_Gpu,reporter,ctxInfo)410 DEF_GPUTEST_FOR_RENDERING_CONTEXTS(WritePixels_Gpu, reporter, ctxInfo) {
411 const SkImageInfo ii = SkImageInfo::MakeN32Premul(DEV_W, DEV_H);
412
413 for (auto& origin : { kTopLeft_GrSurfaceOrigin, kBottomLeft_GrSurfaceOrigin }) {
414 sk_sp<SkSurface> surface(SkSurface::MakeRenderTarget(ctxInfo.grContext(), SkBudgeted::kNo,
415 ii, 0, origin, nullptr));
416 test_write_pixels(reporter, surface.get());
417 }
418 }
419 #endif
420