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