blob: 364cf1ae2d72f9ddb06e05fa40d441687b91173c [file] [log] [blame]
bsalomon@google.comd58a1cd2011-11-10 20:57:43 +00001/*
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
bsalomon@google.comd58a1cd2011-11-10 20:57:43 +00008#include "SkCanvas.h"
Cary Clarka4083c92017-09-15 11:59:23 -04009#include "SkColorData.h"
reed@google.com4b163ed2012-08-07 21:35:13 +000010#include "SkMathPriv.h"
reed4af35f32014-06-27 17:47:49 -070011#include "SkSurface.h"
tfarina@chromium.org4ee16bf2014-01-10 22:08:27 +000012#include "Test.h"
commit-bot@chromium.org4cd9e212014-03-07 03:25:16 +000013#include "sk_tool_utils.h"
tfarina@chromium.org4ee16bf2014-01-10 22:08:27 +000014
bsalomon@google.comcf8fb1f2012-08-02 14:03:32 +000015#if SK_SUPPORT_GPU
Brian Salomond17f6582017-07-19 18:28:58 -040016#include "GrBackendSurface.h"
kkinnunen15302832015-12-01 04:35:26 -080017#include "GrContext.h"
Brian Osman33910292017-04-18 14:38:53 -040018#include "GrGpu.h"
Brian Salomond17f6582017-07-19 18:28:58 -040019#include "GrTest.h"
bsalomon@google.comcf8fb1f2012-08-02 14:03:32 +000020#endif
bsalomon@google.comd58a1cd2011-11-10 20:57:43 +000021
kkinnunen15302832015-12-01 04:35:26 -080022#include <initializer_list>
23
bsalomon@google.comd58a1cd2011-11-10 20:57:43 +000024static const int DEV_W = 100, DEV_H = 100;
25static const SkIRect DEV_RECT = SkIRect::MakeWH(DEV_W, DEV_H);
rmistry@google.comd6176b02012-08-23 18:14:13 +000026static const SkRect DEV_RECT_S = SkRect::MakeWH(DEV_W * SK_Scalar1,
bsalomon@google.comd58a1cd2011-11-10 20:57:43 +000027 DEV_H * SK_Scalar1);
28static const U8CPU DEV_PAD = 0xee;
29
bsalomonf0674512015-07-28 13:26:15 -070030static SkPMColor get_canvas_color(int x, int y) {
bsalomon@google.comd58a1cd2011-11-10 20:57:43 +000031 SkASSERT(x >= 0 && x < DEV_W);
32 SkASSERT(y >= 0 && y < DEV_H);
33
34 U8CPU r = x;
35 U8CPU g = y;
36 U8CPU b = 0xc;
37
bsalomon@google.com31648eb2011-11-23 15:01:08 +000038 U8CPU a = 0x0;
bsalomon@google.comd58a1cd2011-11-10 20:57:43 +000039 switch ((x+y) % 5) {
40 case 0:
41 a = 0xff;
42 break;
43 case 1:
44 a = 0x80;
45 break;
46 case 2:
47 a = 0xCC;
48 break;
bsalomon@google.comd58a1cd2011-11-10 20:57:43 +000049 case 3:
50 a = 0x00;
51 break;
bsalomon@google.com31648eb2011-11-23 15:01:08 +000052 case 4:
53 a = 0x01;
54 break;
bsalomon@google.comd58a1cd2011-11-10 20:57:43 +000055 }
56 return SkPremultiplyARGBInline(a, r, g, b);
57}
58
bsalomon@google.comd58a1cd2011-11-10 20:57:43 +000059// assumes any premu/.unpremul has been applied
bsalomonf0674512015-07-28 13:26:15 -070060static uint32_t pack_color_type(SkColorType ct, U8CPU a, U8CPU r, U8CPU g, U8CPU b) {
bsalomon@google.comd58a1cd2011-11-10 20:57:43 +000061 uint32_t r32;
62 uint8_t* result = reinterpret_cast<uint8_t*>(&r32);
reed@google.com7111d462014-03-25 16:20:24 +000063 switch (ct) {
64 case kBGRA_8888_SkColorType:
bsalomon@google.comd58a1cd2011-11-10 20:57:43 +000065 result[0] = b;
66 result[1] = g;
67 result[2] = r;
68 result[3] = a;
69 break;
reed@google.com7111d462014-03-25 16:20:24 +000070 case kRGBA_8888_SkColorType:
bsalomon@google.comd58a1cd2011-11-10 20:57:43 +000071 result[0] = r;
72 result[1] = g;
73 result[2] = b;
74 result[3] = a;
75 break;
76 default:
77 SkASSERT(0);
78 return 0;
79 }
80 return r32;
81}
82
bsalomonf0674512015-07-28 13:26:15 -070083static uint32_t get_bitmap_color(int x, int y, int w, SkColorType ct, SkAlphaType at) {
bsalomon@google.comd58a1cd2011-11-10 20:57:43 +000084 int n = y * w + x;
85 U8CPU b = n & 0xff;
86 U8CPU g = (n >> 8) & 0xff;
87 U8CPU r = (n >> 16) & 0xff;
bsalomon@google.com31648eb2011-11-23 15:01:08 +000088 U8CPU a = 0;
bsalomon@google.comd58a1cd2011-11-10 20:57:43 +000089 switch ((x+y) % 5) {
90 case 4:
91 a = 0xff;
92 break;
93 case 3:
94 a = 0x80;
95 break;
96 case 2:
97 a = 0xCC;
98 break;
99 case 1:
100 a = 0x01;
101 break;
102 case 0:
103 a = 0x00;
104 break;
105 }
reed@google.com7111d462014-03-25 16:20:24 +0000106 if (kPremul_SkAlphaType == at) {
bsalomon@google.comd58a1cd2011-11-10 20:57:43 +0000107 r = SkMulDiv255Ceiling(r, a);
108 g = SkMulDiv255Ceiling(g, a);
109 b = SkMulDiv255Ceiling(b, a);
110 }
bsalomonf0674512015-07-28 13:26:15 -0700111 return pack_color_type(ct, a, r, g , b);
bsalomon@google.comd58a1cd2011-11-10 20:57:43 +0000112}
113
bsalomonf0674512015-07-28 13:26:15 -0700114static void fill_canvas(SkCanvas* canvas) {
commit-bot@chromium.org4cd9e212014-03-07 03:25:16 +0000115 SkBitmap bmp;
bsalomon@google.comd58a1cd2011-11-10 20:57:43 +0000116 if (bmp.isNull()) {
reed84825042014-09-02 12:50:45 -0700117 bmp.allocN32Pixels(DEV_W, DEV_H);
bsalomon@google.comd58a1cd2011-11-10 20:57:43 +0000118 for (int y = 0; y < DEV_H; ++y) {
119 for (int x = 0; x < DEV_W; ++x) {
bsalomonf0674512015-07-28 13:26:15 -0700120 *bmp.getAddr32(x, y) = get_canvas_color(x, y);
bsalomon@google.comd58a1cd2011-11-10 20:57:43 +0000121 }
122 }
123 }
124 canvas->save();
125 canvas->setMatrix(SkMatrix::I());
Mike Reedc1f77742016-12-09 09:00:50 -0500126 canvas->clipRect(DEV_RECT_S, kReplace_SkClipOp);
bsalomon@google.comd58a1cd2011-11-10 20:57:43 +0000127 SkPaint paint;
reed374772b2016-10-05 17:33:02 -0700128 paint.setBlendMode(SkBlendMode::kSrc);
bsalomon@google.comd58a1cd2011-11-10 20:57:43 +0000129 canvas->drawBitmap(bmp, 0, 0, &paint);
130 canvas->restore();
131}
132
reed@google.com7111d462014-03-25 16:20:24 +0000133/**
134 * Lucky for us, alpha is always in the same spot (SK_A32_SHIFT), for both RGBA and BGRA.
135 * Thus this routine doesn't need to know the exact colortype
136 */
137static uint32_t premul(uint32_t color) {
138 unsigned a = SkGetPackedA32(color);
139 // these next three are not necessarily r,g,b in that order, but they are r,g,b in some order.
140 unsigned c0 = SkGetPackedR32(color);
141 unsigned c1 = SkGetPackedG32(color);
142 unsigned c2 = SkGetPackedB32(color);
143 c0 = SkMulDiv255Ceiling(c0, a);
144 c1 = SkMulDiv255Ceiling(c1, a);
145 c2 = SkMulDiv255Ceiling(c2, a);
146 return SkPackARGB32NoCheck(a, c0, c1, c2);
147}
148
149static SkPMColor convert_to_PMColor(SkColorType ct, SkAlphaType at, uint32_t color) {
150 if (kUnpremul_SkAlphaType == at) {
151 color = premul(color);
152 }
153 switch (ct) {
154 case kRGBA_8888_SkColorType:
155 color = SkSwizzle_RGBA_to_PMColor(color);
bsalomon@google.comd58a1cd2011-11-10 20:57:43 +0000156 break;
reed@google.com7111d462014-03-25 16:20:24 +0000157 case kBGRA_8888_SkColorType:
158 color = SkSwizzle_BGRA_to_PMColor(color);
bsalomon@google.comd58a1cd2011-11-10 20:57:43 +0000159 break;
160 default:
reed@google.com7111d462014-03-25 16:20:24 +0000161 SkASSERT(0);
162 break;
bsalomon@google.comd58a1cd2011-11-10 20:57:43 +0000163 }
reed@google.com7111d462014-03-25 16:20:24 +0000164 return color;
bsalomon@google.comd58a1cd2011-11-10 20:57:43 +0000165}
166
bsalomonf0674512015-07-28 13:26:15 -0700167static bool check_pixel(SkPMColor a, SkPMColor b, bool didPremulConversion) {
bsalomon@google.comd58a1cd2011-11-10 20:57:43 +0000168 if (!didPremulConversion) {
169 return a == b;
170 }
171 int32_t aA = static_cast<int32_t>(SkGetPackedA32(a));
172 int32_t aR = static_cast<int32_t>(SkGetPackedR32(a));
173 int32_t aG = static_cast<int32_t>(SkGetPackedG32(a));
174 int32_t aB = SkGetPackedB32(a);
175
176 int32_t bA = static_cast<int32_t>(SkGetPackedA32(b));
177 int32_t bR = static_cast<int32_t>(SkGetPackedR32(b));
178 int32_t bG = static_cast<int32_t>(SkGetPackedG32(b));
179 int32_t bB = static_cast<int32_t>(SkGetPackedB32(b));
180
181 return aA == bA &&
182 SkAbs32(aR - bR) <= 1 &&
183 SkAbs32(aG - bG) <= 1 &&
184 SkAbs32(aB - bB) <= 1;
185}
186
Mike Reedf1942192017-07-21 14:24:29 -0400187static bool check_write(skiatest::Reporter* reporter, SkSurface* surf, const SkBitmap& bitmap,
reed@google.com7111d462014-03-25 16:20:24 +0000188 int writeX, int writeY) {
reed@google.com7111d462014-03-25 16:20:24 +0000189 size_t canvasRowBytes;
190 const uint32_t* canvasPixels;
reed@google.com11211702014-03-25 12:00:30 +0000191
reed@google.com7111d462014-03-25 16:20:24 +0000192 // Can't use canvas->peekPixels(), as we are trying to look at GPU pixels sometimes as well.
193 // At some point this will be unsupported, as we won't allow accessBitmap() to magically call
194 // readPixels for the client.
195 SkBitmap secretDevBitmap;
Mike Reedf1942192017-07-21 14:24:29 -0400196 secretDevBitmap.allocN32Pixels(surf->width(), surf->height());
197 if (!surf->readPixels(secretDevBitmap, 0, 0)) {
Brian Salomon71d9d842016-11-03 13:42:00 -0400198 return false;
199 }
reed52d9ac62014-06-30 09:05:34 -0700200
reed@google.com7111d462014-03-25 16:20:24 +0000201 canvasRowBytes = secretDevBitmap.rowBytes();
202 canvasPixels = static_cast<const uint32_t*>(secretDevBitmap.getPixels());
203
halcanary96fcdcc2015-08-27 07:41:13 -0700204 if (nullptr == canvasPixels) {
reed@google.com7111d462014-03-25 16:20:24 +0000205 return false;
206 }
207
Mike Reedf1942192017-07-21 14:24:29 -0400208 if (surf->width() != DEV_W || surf->height() != DEV_H) {
reed@google.com7111d462014-03-25 16:20:24 +0000209 return false;
210 }
211
212 const SkImageInfo bmInfo = bitmap.info();
213
bsalomon@google.comd58a1cd2011-11-10 20:57:43 +0000214 SkIRect writeRect = SkIRect::MakeXYWH(writeX, writeY, bitmap.width(), bitmap.height());
bsalomon@google.comd58a1cd2011-11-10 20:57:43 +0000215 for (int cy = 0; cy < DEV_H; ++cy) {
bsalomon@google.comd58a1cd2011-11-10 20:57:43 +0000216 for (int cx = 0; cx < DEV_W; ++cx) {
reed@google.com7111d462014-03-25 16:20:24 +0000217 SkPMColor canvasPixel = canvasPixels[cx];
bsalomon@google.comd58a1cd2011-11-10 20:57:43 +0000218 if (writeRect.contains(cx, cy)) {
219 int bx = cx - writeX;
220 int by = cy - writeY;
bsalomonf0674512015-07-28 13:26:15 -0700221 uint32_t bmpColor8888 = get_bitmap_color(bx, by, bitmap.width(),
reed@google.com7111d462014-03-25 16:20:24 +0000222 bmInfo.colorType(), bmInfo.alphaType());
223 bool mul = (kUnpremul_SkAlphaType == bmInfo.alphaType());
224 SkPMColor bmpPMColor = convert_to_PMColor(bmInfo.colorType(), bmInfo.alphaType(),
225 bmpColor8888);
bsalomonf0674512015-07-28 13:26:15 -0700226 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);
bsalomon@google.com72f3dca2012-08-17 13:32:06 +0000229 return false;
bsalomon@google.comd58a1cd2011-11-10 20:57:43 +0000230 }
231 } else {
bsalomonf0674512015-07-28 13:26:15 -0700232 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);
bsalomon@google.com72f3dca2012-08-17 13:32:06 +0000236 return false;
bsalomon@google.comd58a1cd2011-11-10 20:57:43 +0000237 }
238 }
239 }
240 if (cy != DEV_H -1) {
reed@google.com7111d462014-03-25 16:20:24 +0000241 const char* pad = reinterpret_cast<const char*>(canvasPixels + DEV_W);
bsalomon@google.comd58a1cd2011-11-10 20:57:43 +0000242 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) {
bsalomon@google.com72f3dca2012-08-17 13:32:06 +0000246 return false;
bsalomon@google.comd58a1cd2011-11-10 20:57:43 +0000247 }
248 }
249 }
reed@google.com7111d462014-03-25 16:20:24 +0000250 canvasPixels += canvasRowBytes/4;
bsalomon@google.comd58a1cd2011-11-10 20:57:43 +0000251 }
252
bsalomon@google.com72f3dca2012-08-17 13:32:06 +0000253 return true;
bsalomon@google.comd58a1cd2011-11-10 20:57:43 +0000254}
255
commit-bot@chromium.orgfa9e5fa2014-02-13 22:00:04 +0000256#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//
bsalomonf0674512015-07-28 13:26:15 -0700262static bool alloc_row_bytes(SkBitmap* bm, const SkImageInfo& info, size_t rowBytes) {
commit-bot@chromium.orga3264e52014-05-30 13:26:10 +0000263 if (!bm->setInfo(info, rowBytes)) {
commit-bot@chromium.orgfa9e5fa2014-02-13 22:00:04 +0000264 return false;
265 }
Mike Reed086a4272017-07-18 10:53:11 -0400266 sk_sp<SkPixelRef> pr = SkMallocPixelRef::MakeAllocate(info, rowBytes);
Hal Canary1b3387b2016-12-12 13:48:12 -0500267 bm->setPixelRef(std::move(pr), 0, 0);
commit-bot@chromium.orgfa9e5fa2014-02-13 22:00:04 +0000268 return true;
269}
270
reed52d9ac62014-06-30 09:05:34 -0700271static void free_pixels(void* pixels, void* ctx) {
272 sk_free(pixels);
273}
274
reed52d9ac62014-06-30 09:05:34 -0700275static bool setup_bitmap(SkBitmap* bm, SkColorType ct, SkAlphaType at, int w, int h, int tightRB) {
reed@google.com7111d462014-03-25 16:20:24 +0000276 size_t rowBytes = tightRB ? 0 : 4 * w + 60;
277 SkImageInfo info = SkImageInfo::Make(w, h, ct, at);
bsalomonf0674512015-07-28 13:26:15 -0700278 if (!alloc_row_bytes(bm, info, rowBytes)) {
bsalomon@google.comd58a1cd2011-11-10 20:57:43 +0000279 return false;
280 }
bsalomon@google.comd58a1cd2011-11-10 20:57:43 +0000281 for (int y = 0; y < h; ++y) {
282 for (int x = 0; x < w; ++x) {
bsalomonf0674512015-07-28 13:26:15 -0700283 *bm->getAddr32(x, y) = get_bitmap_color(x, y, w, ct, at);
bsalomon@google.comd58a1cd2011-11-10 20:57:43 +0000284 }
285 }
286 return true;
287}
288
reed4af35f32014-06-27 17:47:49 -0700289static 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
kkinnunen15302832015-12-01 04:35:26 -0800295DEF_TEST(WritePixelsSurfaceGenID, reporter) {
reed4af35f32014-06-27 17:47:49 -0700296 const SkImageInfo info = SkImageInfo::MakeN32Premul(100, 100);
reede8f30622016-03-23 18:59:25 -0700297 auto surface(SkSurface::MakeRaster(info));
reed4af35f32014-06-27 17:47:49 -0700298 uint32_t genID1 = surface->generationID();
299 call_writepixels(surface->getCanvas());
300 uint32_t genID2 = surface->generationID();
301 REPORTER_ASSERT(reporter, genID1 != genID2);
302}
303
kkinnunen15302832015-12-01 04:35:26 -0800304static void test_write_pixels(skiatest::Reporter* reporter, SkSurface* surface) {
bsalomon@google.comd58a1cd2011-11-10 20:57:43 +0000305 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
Mike Reedf1942192017-07-21 14:24:29 -0400352 SkCanvas* canvas = surface->getCanvas();
bsalomon@google.comd58a1cd2011-11-10 20:57:43 +0000353
kkinnunen15302832015-12-01 04:35:26 -0800354 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;
bsalomon@google.com405d0f42012-08-29 21:26:13 +0000369
Mike Reedf1942192017-07-21 14:24:29 -0400370 fill_canvas(canvas);
kkinnunen15302832015-12-01 04:35:26 -0800371 SkBitmap bmp;
372 REPORTER_ASSERT(reporter, setup_bitmap(&bmp, ct, at, rect.width(),
373 rect.height(), SkToBool(tightBmp)));
374 uint32_t idBefore = surface->generationID();
reed@google.com7111d462014-03-25 16:20:24 +0000375
kkinnunen15302832015-12-01 04:35:26 -0800376 // sk_tool_utils::write_pixels(&canvas, bmp, rect.fLeft, rect.fTop, ct, at);
Mike Reedf1942192017-07-21 14:24:29 -0400377 canvas->writePixels(bmp, rect.fLeft, rect.fTop);
commit-bot@chromium.org4cd9e212014-03-07 03:25:16 +0000378
kkinnunen15302832015-12-01 04:35:26 -0800379 uint32_t idAfter = surface->generationID();
Mike Reedf1942192017-07-21 14:24:29 -0400380 REPORTER_ASSERT(reporter, check_write(reporter, surface, bmp,
kkinnunen15302832015-12-01 04:35:26 -0800381 rect.fLeft, rect.fTop));
commit-bot@chromium.org4cd9e212014-03-07 03:25:16 +0000382
kkinnunen15302832015-12-01 04:35:26 -0800383 // we should change the genID iff pixels were actually written.
Mike Reedf1942192017-07-21 14:24:29 -0400384 SkIRect canvasRect = SkIRect::MakeSize(canvas->getBaseLayerSize());
kkinnunen15302832015-12-01 04:35:26 -0800385 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));
bsalomon@google.comd58a1cd2011-11-10 20:57:43 +0000389 }
390 }
391 }
392}
kkinnunen15302832015-12-01 04:35:26 -0800393DEF_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;
Mike Reedf0ffb892017-10-03 14:47:21 -0400397 const size_t size = info.computeByteSize(rowBytes);
kkinnunen15302832015-12-01 04:35:26 -0800398 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 }
reede8f30622016-03-23 18:59:25 -0700403 auto surface(SkSurface::MakeRasterDirectReleaseProc(info, pixels, rowBytes,
404 free_pixels, nullptr));
405 test_write_pixels(reporter, surface.get());
kkinnunen15302832015-12-01 04:35:26 -0800406 }
407}
408#if SK_SUPPORT_GPU
egdaniel4583ec52016-06-27 12:57:00 -0700409DEF_GPUTEST_FOR_RENDERING_CONTEXTS(WritePixels_Gpu, reporter, ctxInfo) {
robertphillips7e922762016-07-26 11:38:17 -0700410 const SkImageInfo ii = SkImageInfo::MakeN32Premul(DEV_W, DEV_H);
411
kkinnunen15302832015-12-01 04:35:26 -0800412 for (auto& origin : { kTopLeft_GrSurfaceOrigin, kBottomLeft_GrSurfaceOrigin }) {
Brian Osman33910292017-04-18 14:38:53 -0400413 for (int sampleCnt : {0, 4}) {
414 sk_sp<SkSurface> surface(SkSurface::MakeRenderTarget(ctxInfo.grContext(),
415 SkBudgeted::kNo, ii, sampleCnt,
416 origin, nullptr));
417 if (!surface && sampleCnt > 0) {
418 // Some platforms don't support MSAA
419 continue;
420 }
421 test_write_pixels(reporter, surface.get());
422 }
423 }
424}
425
426DEF_GPUTEST_FOR_RENDERING_CONTEXTS(WritePixelsNonTexture_Gpu, reporter, ctxInfo) {
427 GrContext* context = ctxInfo.grContext();
428
429 for (auto& origin : { kTopLeft_GrSurfaceOrigin, kBottomLeft_GrSurfaceOrigin }) {
430 for (int sampleCnt : {0, 4}) {
Brian Salomond17f6582017-07-19 18:28:58 -0400431 auto handle = context->getGpu()->createTestingOnlyBackendTexture(
432 nullptr, DEV_W, DEV_H, kSkia8888_GrPixelConfig, true);
433 GrBackendTexture backendTexture = GrTest::CreateBackendTexture(
Greg Daniel177e6952017-10-12 12:27:11 -0400434 ctxInfo.backend(), DEV_W, DEV_H, kSkia8888_GrPixelConfig, GrMipMapped::kNo,
435 handle);
Brian Salomond17f6582017-07-19 18:28:58 -0400436 sk_sp<SkSurface> surface(SkSurface::MakeFromBackendTextureAsRenderTarget(
437 context, backendTexture, origin, sampleCnt, nullptr, nullptr));
Brian Osman33910292017-04-18 14:38:53 -0400438 if (!surface) {
Brian Salomond17f6582017-07-19 18:28:58 -0400439 context->getGpu()->deleteTestingOnlyBackendTexture(handle);
Brian Osman33910292017-04-18 14:38:53 -0400440 continue;
441 }
442
443 test_write_pixels(reporter, surface.get());
444
445 surface.reset();
Brian Salomond17f6582017-07-19 18:28:58 -0400446 context->getGpu()->deleteTestingOnlyBackendTexture(handle);
Brian Osman33910292017-04-18 14:38:53 -0400447 }
kkinnunen15302832015-12-01 04:35:26 -0800448 }
449}
Robert Phillips7bbbf622017-10-17 07:36:59 -0400450
451static sk_sp<SkSurface> create_surf(GrContext* context, int width, int height) {
452 const SkImageInfo ii = SkImageInfo::Make(width, height,
453 kRGBA_8888_SkColorType, kPremul_SkAlphaType);
454
455 sk_sp<SkSurface> surf = SkSurface::MakeRenderTarget(context, SkBudgeted::kYes, ii);
456 surf->flush();
457 return surf;
458}
459
460static sk_sp<SkImage> upload(const sk_sp<SkSurface>& surf, SkColor color) {
461 const SkImageInfo smII = SkImageInfo::Make(16, 16, kRGBA_8888_SkColorType, kPremul_SkAlphaType);
462 SkBitmap bm;
463 bm.allocPixels(smII);
464 bm.eraseColor(color);
465
466 surf->getCanvas()->writePixels(bm, 0, 0);
467
468 return surf->makeImageSnapshot();
469}
470
471// This is tests whether the first writePixels is completed before the
472// second writePixels takes effect (i.e., that writePixels correctly flushes
473// in between uses of the shared backing resource).
474DEF_GPUTEST_FOR_RENDERING_CONTEXTS(WritePixelsPendingIO, reporter, ctxInfo) {
475 GrContext* context = ctxInfo.grContext();
476
477 static const int kFullSize = 62;
478 static const int kHalfSize = 31;
479
480 static const uint32_t kLeftColor = 0xFF222222;
481 static const uint32_t kRightColor = 0xFFAAAAAA;
482
483 const SkImageInfo fullII = SkImageInfo::Make(kFullSize, kFullSize,
484 kRGBA_8888_SkColorType, kPremul_SkAlphaType);
485 const SkImageInfo halfII = SkImageInfo::Make(kHalfSize, kFullSize,
486 kRGBA_8888_SkColorType, kPremul_SkAlphaType);
487
488 sk_sp<SkSurface> dest = SkSurface::MakeRenderTarget(context, SkBudgeted::kYes, fullII);
489
490 {
491 // Seed the resource cached with a scratch texture that will be
492 // reused by writeSurfacePixels
493 GrSurfaceDesc desc;
494 desc.fFlags = kNone_GrSurfaceFlags;
495 desc.fWidth = 32;
496 desc.fHeight = 64;
497 desc.fConfig = kRGBA_8888_GrPixelConfig;
498
499 sk_sp<GrTextureProxy> temp = GrSurfaceProxy::MakeDeferred(context->resourceProvider(), desc,
500 SkBackingFit::kApprox,
501 SkBudgeted::kYes);
502 temp->instantiate(context->resourceProvider());
503 }
504
505 // Create the surfaces and flush them to ensure there is no lingering pendingIO
506 sk_sp<SkSurface> leftSurf = create_surf(context, kHalfSize, kFullSize);
507 sk_sp<SkSurface> rightSurf = create_surf(context, kHalfSize, kFullSize);
508
509 sk_sp<SkImage> leftImg = upload(std::move(leftSurf), kLeftColor);
510 dest->getCanvas()->drawImage(std::move(leftImg), 0, 0);
511
512 sk_sp<SkImage> rightImg = upload(std::move(rightSurf), kRightColor);
513 dest->getCanvas()->drawImage(std::move(rightImg), kHalfSize, 0);
514
515 SkBitmap bm;
516 bm.allocPixels(fullII);
517 SkAssertResult(dest->readPixels(bm, 0, 0));
518
519 bool isCorrect = true;
520 for (int y = 0; isCorrect && y < 16; ++y) {
521 const uint32_t* sl = bm.getAddr32(0, y);
522
523 for (int x = 0; x < 16; ++x) {
524 if (kLeftColor != sl[x]) {
525 isCorrect = false;
526 break;
527 }
528 }
529 for (int x = kHalfSize; x < kHalfSize+16; ++x) {
530 if (kRightColor != sl[x]) {
531 isCorrect = false;
532 break;
533 }
534 }
535 }
536
537 REPORTER_ASSERT(reporter, isCorrect);
538}
539
540
kkinnunen15302832015-12-01 04:35:26 -0800541#endif