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 <initializer_list>
9 #include "SkCanvas.h"
10 #include "SkColorData.h"
11 #include "SkHalf.h"
12 #include "SkImageInfoPriv.h"
13 #include "SkMathPriv.h"
14 #include "SkSurface.h"
15 #include "Test.h"
16
17 #include "GrContext.h"
18 #include "GrContextFactory.h"
19 #include "GrContextPriv.h"
20 #include "GrProxyProvider.h"
21 #include "ProxyUtils.h"
22 #include "SkGr.h"
23
24
25 static const int DEV_W = 100, DEV_H = 100;
26 static const SkIRect DEV_RECT = SkIRect::MakeWH(DEV_W, DEV_H);
27 static const SkRect DEV_RECT_S = SkRect::MakeWH(DEV_W * SK_Scalar1,
28 DEV_H * SK_Scalar1);
29
get_src_color(int x,int y)30 static SkPMColor get_src_color(int x, int y) {
31 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
38 U8CPU a = 0xff;
39 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;
49 case 4:
50 a = 0x01;
51 break;
52 case 3:
53 a = 0x00;
54 break;
55 }
56 return SkPremultiplyARGBInline(a, r, g, b);
57 }
58
get_dst_bmp_init_color(int x,int y,int w)59 static SkPMColor get_dst_bmp_init_color(int x, int y, int w) {
60 int n = y * w + x;
61
62 U8CPU b = n & 0xff;
63 U8CPU g = (n >> 8) & 0xff;
64 U8CPU r = (n >> 16) & 0xff;
65 return SkPackARGB32(0xff, r, g , b);
66 }
67
68 // TODO: Make this consider both ATs
convert_to_pmcolor(SkColorType ct,SkAlphaType at,const uint32_t * addr,bool * doUnpremul)69 static SkPMColor convert_to_pmcolor(SkColorType ct, SkAlphaType at, const uint32_t* addr,
70 bool* doUnpremul) {
71 *doUnpremul = (kUnpremul_SkAlphaType == at);
72
73 const uint8_t* c = reinterpret_cast<const uint8_t*>(addr);
74 U8CPU a,r,g,b;
75 switch (ct) {
76 case kBGRA_8888_SkColorType:
77 b = static_cast<U8CPU>(c[0]);
78 g = static_cast<U8CPU>(c[1]);
79 r = static_cast<U8CPU>(c[2]);
80 a = static_cast<U8CPU>(c[3]);
81 break;
82 case kRGB_888x_SkColorType: // fallthrough
83 case kRGBA_8888_SkColorType:
84 r = static_cast<U8CPU>(c[0]);
85 g = static_cast<U8CPU>(c[1]);
86 b = static_cast<U8CPU>(c[2]);
87 // We set this even when for kRGB_888x because our caller will validate that it is 0xff.
88 a = static_cast<U8CPU>(c[3]);
89 break;
90 default:
91 SkDEBUGFAIL("Unexpected colortype");
92 return 0;
93 }
94
95 if (*doUnpremul) {
96 r = SkMulDiv255Ceiling(r, a);
97 g = SkMulDiv255Ceiling(g, a);
98 b = SkMulDiv255Ceiling(b, a);
99 }
100 return SkPackARGB32(a, r, g, b);
101 }
102
make_src_bitmap()103 static SkBitmap make_src_bitmap() {
104 static SkBitmap bmp;
105 if (bmp.isNull()) {
106 bmp.allocN32Pixels(DEV_W, DEV_H);
107 intptr_t pixels = reinterpret_cast<intptr_t>(bmp.getPixels());
108 for (int y = 0; y < DEV_H; ++y) {
109 for (int x = 0; x < DEV_W; ++x) {
110 SkPMColor* pixel = reinterpret_cast<SkPMColor*>(pixels + y * bmp.rowBytes() + x * bmp.bytesPerPixel());
111 *pixel = get_src_color(x, y);
112 }
113 }
114 }
115 return bmp;
116 }
117
fill_src_canvas(SkCanvas * canvas)118 static void fill_src_canvas(SkCanvas* canvas) {
119 canvas->save();
120 canvas->setMatrix(SkMatrix::I());
121 canvas->clipRect(DEV_RECT_S, kReplace_SkClipOp);
122 SkPaint paint;
123 paint.setBlendMode(SkBlendMode::kSrc);
124 canvas->drawBitmap(make_src_bitmap(), 0, 0, &paint);
125 canvas->restore();
126 }
127
fill_dst_bmp_with_init_data(SkBitmap * bitmap)128 static void fill_dst_bmp_with_init_data(SkBitmap* bitmap) {
129 int w = bitmap->width();
130 int h = bitmap->height();
131 intptr_t pixels = reinterpret_cast<intptr_t>(bitmap->getPixels());
132 for (int y = 0; y < h; ++y) {
133 for (int x = 0; x < w; ++x) {
134 SkPMColor initColor = get_dst_bmp_init_color(x, y, w);
135 if (kAlpha_8_SkColorType == bitmap->colorType()) {
136 uint8_t* alpha = reinterpret_cast<uint8_t*>(pixels + y * bitmap->rowBytes() + x);
137 *alpha = SkGetPackedA32(initColor);
138 } else {
139 SkPMColor* pixel = reinterpret_cast<SkPMColor*>(pixels + y * bitmap->rowBytes() + x * bitmap->bytesPerPixel());
140 *pixel = initColor;
141 }
142 }
143 }
144 }
145
check_read_pixel(SkPMColor a,SkPMColor b,bool didPremulConversion)146 static bool check_read_pixel(SkPMColor a, SkPMColor b, bool didPremulConversion) {
147 if (!didPremulConversion) {
148 return a == b;
149 }
150 int32_t aA = static_cast<int32_t>(SkGetPackedA32(a));
151 int32_t aR = static_cast<int32_t>(SkGetPackedR32(a));
152 int32_t aG = static_cast<int32_t>(SkGetPackedG32(a));
153 int32_t aB = SkGetPackedB32(a);
154
155 int32_t bA = static_cast<int32_t>(SkGetPackedA32(b));
156 int32_t bR = static_cast<int32_t>(SkGetPackedR32(b));
157 int32_t bG = static_cast<int32_t>(SkGetPackedG32(b));
158 int32_t bB = static_cast<int32_t>(SkGetPackedB32(b));
159
160 return aA == bA &&
161 SkAbs32(aR - bR) <= 1 &&
162 SkAbs32(aG - bG) <= 1 &&
163 SkAbs32(aB - bB) <= 1;
164 }
165
166 // checks the bitmap contains correct pixels after the readPixels
167 // if the bitmap was prefilled with pixels it checks that these weren't
168 // overwritten in the area outside the readPixels.
check_read(skiatest::Reporter * reporter,const SkBitmap & bitmap,int x,int y,bool checkSurfacePixels,bool checkBitmapPixels,SkImageInfo surfaceInfo)169 static bool check_read(skiatest::Reporter* reporter, const SkBitmap& bitmap, int x, int y,
170 bool checkSurfacePixels, bool checkBitmapPixels,
171 SkImageInfo surfaceInfo) {
172 SkAlphaType bmpAT = bitmap.alphaType();
173 SkColorType bmpCT = bitmap.colorType();
174 SkASSERT(!bitmap.isNull());
175 SkASSERT(checkSurfacePixels || checkBitmapPixels);
176
177 int bw = bitmap.width();
178 int bh = bitmap.height();
179
180 SkIRect srcRect = SkIRect::MakeXYWH(x, y, bw, bh);
181 SkIRect clippedSrcRect = DEV_RECT;
182 if (!clippedSrcRect.intersect(srcRect)) {
183 clippedSrcRect.setEmpty();
184 }
185 if (kAlpha_8_SkColorType == bmpCT) {
186 for (int by = 0; by < bh; ++by) {
187 for (int bx = 0; bx < bw; ++bx) {
188 int devx = bx + srcRect.fLeft;
189 int devy = by + srcRect.fTop;
190 const uint8_t* alpha = bitmap.getAddr8(bx, by);
191
192 if (clippedSrcRect.contains(devx, devy)) {
193 if (checkSurfacePixels) {
194 uint8_t surfaceAlpha = (surfaceInfo.alphaType() == kOpaque_SkAlphaType)
195 ? 0xFF
196 : SkGetPackedA32(get_src_color(devx, devy));
197 if (surfaceAlpha != *alpha) {
198 ERRORF(reporter,
199 "Expected readback alpha (%d, %d) value 0x%02x, got 0x%02x. ",
200 bx, by, surfaceAlpha, *alpha);
201 return false;
202 }
203 }
204 } else if (checkBitmapPixels) {
205 uint32_t origDstAlpha = SkGetPackedA32(get_dst_bmp_init_color(bx, by, bw));
206 if (origDstAlpha != *alpha) {
207 ERRORF(reporter, "Expected clipped out area of readback to be unchanged. "
208 "Expected 0x%02x, got 0x%02x", origDstAlpha, *alpha);
209 return false;
210 }
211 }
212 }
213 }
214 return true;
215 }
216 for (int by = 0; by < bh; ++by) {
217 for (int bx = 0; bx < bw; ++bx) {
218 int devx = bx + srcRect.fLeft;
219 int devy = by + srcRect.fTop;
220
221 const uint32_t* pixel = bitmap.getAddr32(bx, by);
222
223 if (clippedSrcRect.contains(devx, devy)) {
224 if (checkSurfacePixels) {
225 SkPMColor surfacePMColor = get_src_color(devx, devy);
226 if (SkColorTypeIsAlphaOnly(surfaceInfo.colorType())) {
227 surfacePMColor &= 0xFF000000;
228 }
229 if (kOpaque_SkAlphaType == surfaceInfo.alphaType() || kOpaque_SkAlphaType == bmpAT) {
230 surfacePMColor |= 0xFF000000;
231 }
232 bool didPremul;
233 SkPMColor pmPixel = convert_to_pmcolor(bmpCT, bmpAT, pixel, &didPremul);
234 if (!check_read_pixel(pmPixel, surfacePMColor, didPremul)) {
235 ERRORF(reporter,
236 "Expected readback pixel (%d, %d) value 0x%08x, got 0x%08x. "
237 "Readback was unpremul: %d",
238 bx, by, surfacePMColor, pmPixel, didPremul);
239 return false;
240 }
241 }
242 } else if (checkBitmapPixels) {
243 uint32_t origDstPixel = get_dst_bmp_init_color(bx, by, bw);
244 if (origDstPixel != *pixel) {
245 ERRORF(reporter, "Expected clipped out area of readback to be unchanged. "
246 "Expected 0x%08x, got 0x%08x", origDstPixel, *pixel);
247 return false;
248 }
249 }
250 }
251 }
252 return true;
253 }
254
255 enum BitmapInit {
256 kFirstBitmapInit = 0,
257
258 kTight_BitmapInit = kFirstBitmapInit,
259 kRowBytes_BitmapInit,
260 kRowBytesOdd_BitmapInit,
261
262 kLastAligned_BitmapInit = kRowBytes_BitmapInit,
263
264 #if 0 // THIS CAUSES ERRORS ON WINDOWS AND SOME ANDROID DEVICES
265 kLast_BitmapInit = kRowBytesOdd_BitmapInit
266 #else
267 kLast_BitmapInit = kLastAligned_BitmapInit
268 #endif
269 };
270
nextBMI(BitmapInit bmi)271 static BitmapInit nextBMI(BitmapInit bmi) {
272 int x = bmi;
273 return static_cast<BitmapInit>(++x);
274 }
275
init_bitmap(SkBitmap * bitmap,const SkIRect & rect,BitmapInit init,SkColorType ct,SkAlphaType at)276 static void init_bitmap(SkBitmap* bitmap, const SkIRect& rect, BitmapInit init, SkColorType ct,
277 SkAlphaType at) {
278 SkImageInfo info = SkImageInfo::Make(rect.width(), rect.height(), ct, at);
279 size_t rowBytes = 0;
280 switch (init) {
281 case kTight_BitmapInit:
282 break;
283 case kRowBytes_BitmapInit:
284 rowBytes = SkAlign4((info.width() + 16) * info.bytesPerPixel());
285 break;
286 case kRowBytesOdd_BitmapInit:
287 rowBytes = SkAlign4(info.width() * info.bytesPerPixel()) + 3;
288 break;
289 default:
290 SkASSERT(0);
291 break;
292 }
293 bitmap->allocPixels(info, rowBytes);
294 }
295
296 static const struct {
297 SkColorType fColorType;
298 SkAlphaType fAlphaType;
299 } gReadPixelsConfigs[] = {
300 {kRGBA_8888_SkColorType, kPremul_SkAlphaType},
301 {kRGBA_8888_SkColorType, kUnpremul_SkAlphaType},
302 {kRGB_888x_SkColorType, kOpaque_SkAlphaType},
303 {kBGRA_8888_SkColorType, kPremul_SkAlphaType},
304 {kBGRA_8888_SkColorType, kUnpremul_SkAlphaType},
305 {kAlpha_8_SkColorType, kPremul_SkAlphaType},
306 };
307 const SkIRect gReadPixelsTestRects[] = {
308 // entire thing
309 DEV_RECT,
310 // larger on all sides
311 SkIRect::MakeLTRB(-10, -10, DEV_W + 10, DEV_H + 10),
312 // fully contained
313 SkIRect::MakeLTRB(DEV_W / 4, DEV_H / 4, 3 * DEV_W / 4, 3 * DEV_H / 4),
314 // outside top left
315 SkIRect::MakeLTRB(-10, -10, -1, -1),
316 // touching top left corner
317 SkIRect::MakeLTRB(-10, -10, 0, 0),
318 // overlapping top left corner
319 SkIRect::MakeLTRB(-10, -10, DEV_W / 4, DEV_H / 4),
320 // overlapping top left and top right corners
321 SkIRect::MakeLTRB(-10, -10, DEV_W + 10, DEV_H / 4),
322 // touching entire top edge
323 SkIRect::MakeLTRB(-10, -10, DEV_W + 10, 0),
324 // overlapping top right corner
325 SkIRect::MakeLTRB(3 * DEV_W / 4, -10, DEV_W + 10, DEV_H / 4),
326 // contained in x, overlapping top edge
327 SkIRect::MakeLTRB(DEV_W / 4, -10, 3 * DEV_W / 4, DEV_H / 4),
328 // outside top right corner
329 SkIRect::MakeLTRB(DEV_W + 1, -10, DEV_W + 10, -1),
330 // touching top right corner
331 SkIRect::MakeLTRB(DEV_W, -10, DEV_W + 10, 0),
332 // overlapping top left and bottom left corners
333 SkIRect::MakeLTRB(-10, -10, DEV_W / 4, DEV_H + 10),
334 // touching entire left edge
335 SkIRect::MakeLTRB(-10, -10, 0, DEV_H + 10),
336 // overlapping bottom left corner
337 SkIRect::MakeLTRB(-10, 3 * DEV_H / 4, DEV_W / 4, DEV_H + 10),
338 // contained in y, overlapping left edge
339 SkIRect::MakeLTRB(-10, DEV_H / 4, DEV_W / 4, 3 * DEV_H / 4),
340 // outside bottom left corner
341 SkIRect::MakeLTRB(-10, DEV_H + 1, -1, DEV_H + 10),
342 // touching bottom left corner
343 SkIRect::MakeLTRB(-10, DEV_H, 0, DEV_H + 10),
344 // overlapping bottom left and bottom right corners
345 SkIRect::MakeLTRB(-10, 3 * DEV_H / 4, DEV_W + 10, DEV_H + 10),
346 // touching entire left edge
347 SkIRect::MakeLTRB(0, DEV_H, DEV_W, DEV_H + 10),
348 // overlapping bottom right corner
349 SkIRect::MakeLTRB(3 * DEV_W / 4, 3 * DEV_H / 4, DEV_W + 10, DEV_H + 10),
350 // overlapping top right and bottom right corners
351 SkIRect::MakeLTRB(3 * DEV_W / 4, -10, DEV_W + 10, DEV_H + 10),
352 };
353
354 enum class ReadSuccessExpectation {
355 kNo,
356 kMaybe,
357 kYes,
358 };
359
check_success_expectation(ReadSuccessExpectation expectation,bool actualSuccess)360 bool check_success_expectation(ReadSuccessExpectation expectation, bool actualSuccess) {
361 switch (expectation) {
362 case ReadSuccessExpectation::kMaybe:
363 return true;
364 case ReadSuccessExpectation::kNo:
365 return !actualSuccess;
366 case ReadSuccessExpectation::kYes:
367 return actualSuccess;
368 }
369 return false;
370 }
371
read_should_succeed(const SkIRect & srcRect,const SkImageInfo & dstInfo,const SkImageInfo & srcInfo,bool isGPU)372 ReadSuccessExpectation read_should_succeed(const SkIRect& srcRect, const SkImageInfo& dstInfo,
373 const SkImageInfo& srcInfo, bool isGPU) {
374 if (!SkIRect::Intersects(srcRect, DEV_RECT)) {
375 return ReadSuccessExpectation::kNo;
376 }
377 if (!SkImageInfoValidConversion(dstInfo, srcInfo)) {
378 return ReadSuccessExpectation::kNo;
379 }
380 if (!isGPU) {
381 return ReadSuccessExpectation::kYes;
382 }
383 // This serves more as documentation of what currently works on the GPU rather than desired
384 // expectations. Once we make GrSurfaceContext color/alpha type aware and clean up some read
385 // pixels code we will make more scenarios work.
386
387 // The GPU code current only does the premul->unpremul conversion, not the reverse.
388 if (srcInfo.alphaType() == kUnpremul_SkAlphaType &&
389 dstInfo.alphaType() == kPremul_SkAlphaType) {
390 return ReadSuccessExpectation::kNo;
391 }
392 // We don't currently require reading alpha-only surfaces to succeed because of some pessimistic
393 // caps decisions and alpha/red complexity in GL.
394 if (SkColorTypeIsAlphaOnly(srcInfo.colorType())) {
395 return ReadSuccessExpectation::kMaybe;
396 }
397 return ReadSuccessExpectation::kYes;
398 }
399
test_readpixels(skiatest::Reporter * reporter,const sk_sp<SkSurface> & surface,const SkImageInfo & surfaceInfo,BitmapInit lastBitmapInit)400 static void test_readpixels(skiatest::Reporter* reporter, const sk_sp<SkSurface>& surface,
401 const SkImageInfo& surfaceInfo, BitmapInit lastBitmapInit) {
402 SkCanvas* canvas = surface->getCanvas();
403 fill_src_canvas(canvas);
404 for (size_t rect = 0; rect < SK_ARRAY_COUNT(gReadPixelsTestRects); ++rect) {
405 const SkIRect& srcRect = gReadPixelsTestRects[rect];
406 for (BitmapInit bmi = kFirstBitmapInit; bmi <= lastBitmapInit; bmi = nextBMI(bmi)) {
407 for (size_t c = 0; c < SK_ARRAY_COUNT(gReadPixelsConfigs); ++c) {
408 SkBitmap bmp;
409 init_bitmap(&bmp, srcRect, bmi,
410 gReadPixelsConfigs[c].fColorType, gReadPixelsConfigs[c].fAlphaType);
411
412 // if the bitmap has pixels allocated before the readPixels,
413 // note that and fill them with pattern
414 bool startsWithPixels = !bmp.isNull();
415 if (startsWithPixels) {
416 fill_dst_bmp_with_init_data(&bmp);
417 }
418 uint32_t idBefore = surface->generationID();
419 bool success = surface->readPixels(bmp, srcRect.fLeft, srcRect.fTop);
420 uint32_t idAfter = surface->generationID();
421
422 // we expect to succeed when the read isn't fully clipped out and the infos are
423 // compatible.
424 bool isGPU = SkToBool(surface->getCanvas()->getGrContext());
425 auto expectSuccess = read_should_succeed(srcRect, bmp.info(), surfaceInfo, isGPU);
426 // determine whether we expected the read to succeed.
427 REPORTER_ASSERT(reporter, check_success_expectation(expectSuccess, success),
428 "Read succeed=%d unexpectedly, src ct/at: %d/%d, dst ct/at: %d/%d",
429 success, surfaceInfo.colorType(), surfaceInfo.alphaType(),
430 bmp.info().colorType(), bmp.info().alphaType());
431 // read pixels should never change the gen id
432 REPORTER_ASSERT(reporter, idBefore == idAfter);
433
434 if (success || startsWithPixels) {
435 check_read(reporter, bmp, srcRect.fLeft, srcRect.fTop, success,
436 startsWithPixels, surfaceInfo);
437 } else {
438 // if we had no pixels beforehand and the readPixels
439 // failed then our bitmap should still not have pixels
440 REPORTER_ASSERT(reporter, bmp.isNull());
441 }
442 }
443 }
444 }
445 }
446
DEF_TEST(ReadPixels,reporter)447 DEF_TEST(ReadPixels, reporter) {
448 const SkImageInfo info = SkImageInfo::MakeN32Premul(DEV_W, DEV_H);
449 auto surface(SkSurface::MakeRaster(info));
450 // SW readback fails a premul check when reading back to an unaligned rowbytes.
451 test_readpixels(reporter, surface, info, kLastAligned_BitmapInit);
452 }
DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ReadPixels_Gpu,reporter,ctxInfo)453 DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ReadPixels_Gpu, reporter, ctxInfo) {
454 if (ctxInfo.type() == sk_gpu_test::GrContextFactory::kANGLE_D3D9_ES2_ContextType ||
455 ctxInfo.type() == sk_gpu_test::GrContextFactory::kANGLE_GL_ES2_ContextType ||
456 ctxInfo.type() == sk_gpu_test::GrContextFactory::kANGLE_D3D11_ES2_ContextType) {
457 // skbug.com/6742 ReadPixels_Texture & _Gpu don't work with ANGLE ES2 configs
458 return;
459 }
460
461 static const SkImageInfo kImageInfos[] = {
462 SkImageInfo::Make(DEV_W, DEV_H, kRGBA_8888_SkColorType, kPremul_SkAlphaType),
463 SkImageInfo::Make(DEV_W, DEV_H, kBGRA_8888_SkColorType, kPremul_SkAlphaType),
464 SkImageInfo::Make(DEV_W, DEV_H, kRGB_888x_SkColorType, kOpaque_SkAlphaType),
465 SkImageInfo::Make(DEV_W, DEV_H, kAlpha_8_SkColorType, kPremul_SkAlphaType),
466 };
467 for (const auto& ii : kImageInfos) {
468 for (auto& origin : {kBottomLeft_GrSurfaceOrigin, kTopLeft_GrSurfaceOrigin}) {
469 sk_sp<SkSurface> surface(SkSurface::MakeRenderTarget(
470 ctxInfo.grContext(), SkBudgeted::kNo, ii, 0, origin, nullptr));
471 if (!surface) {
472 continue;
473 }
474 test_readpixels(reporter, surface, ii, kLast_BitmapInit);
475 }
476 }
477 }
478
test_readpixels_texture(skiatest::Reporter * reporter,sk_sp<GrSurfaceContext> sContext,const SkImageInfo & surfaceInfo)479 static void test_readpixels_texture(skiatest::Reporter* reporter,
480 sk_sp<GrSurfaceContext> sContext,
481 const SkImageInfo& surfaceInfo) {
482 for (size_t rect = 0; rect < SK_ARRAY_COUNT(gReadPixelsTestRects); ++rect) {
483 const SkIRect& srcRect = gReadPixelsTestRects[rect];
484 for (BitmapInit bmi = kFirstBitmapInit; bmi <= kLast_BitmapInit; bmi = nextBMI(bmi)) {
485 for (size_t c = 0; c < SK_ARRAY_COUNT(gReadPixelsConfigs); ++c) {
486 SkBitmap bmp;
487 init_bitmap(&bmp, srcRect, bmi,
488 gReadPixelsConfigs[c].fColorType, gReadPixelsConfigs[c].fAlphaType);
489
490 // if the bitmap has pixels allocated before the readPixels,
491 // note that and fill them with pattern
492 bool startsWithPixels = !bmp.isNull();
493 // Try doing the read directly from a non-renderable texture
494 if (startsWithPixels) {
495 fill_dst_bmp_with_init_data(&bmp);
496 uint32_t flags = 0;
497 // TODO: These two hacks can go away when the surface context knows the alpha
498 // type.
499 // Tell the read to perform an unpremul step since it doesn't know alpha type.
500 if (gReadPixelsConfigs[c].fAlphaType == kUnpremul_SkAlphaType) {
501 flags = GrContextPriv::kUnpremul_PixelOpsFlag;
502 }
503 // The surface context doesn't know that the src is opaque. We don't support
504 // converting non-opaque data to opaque during a read.
505 if (bmp.alphaType() == kOpaque_SkAlphaType &&
506 surfaceInfo.alphaType() != kOpaque_SkAlphaType) {
507 continue;
508 }
509 bool success = sContext->readPixels(bmp.info(), bmp.getPixels(),
510 bmp.rowBytes(),
511 srcRect.fLeft, srcRect.fTop, flags);
512 auto expectSuccess =
513 read_should_succeed(srcRect, bmp.info(), surfaceInfo, true);
514 REPORTER_ASSERT(
515 reporter, check_success_expectation(expectSuccess, success),
516 "Read succeed=%d unexpectedly, src ct/at: %d/%d, dst ct/at: %d/%d",
517 success, surfaceInfo.colorType(), surfaceInfo.alphaType(),
518 bmp.info().colorType(), bmp.info().alphaType());
519 if (success) {
520 check_read(reporter, bmp, srcRect.fLeft, srcRect.fTop, success, true,
521 surfaceInfo);
522 }
523 }
524 }
525 }
526 }
527 }
528
DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ReadPixels_Texture,reporter,ctxInfo)529 DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ReadPixels_Texture, reporter, ctxInfo) {
530 if (ctxInfo.type() == sk_gpu_test::GrContextFactory::kANGLE_D3D9_ES2_ContextType ||
531 ctxInfo.type() == sk_gpu_test::GrContextFactory::kANGLE_GL_ES2_ContextType ||
532 ctxInfo.type() == sk_gpu_test::GrContextFactory::kANGLE_D3D11_ES2_ContextType) {
533 // skbug.com/6742 ReadPixels_Texture & _Gpu don't work with ANGLE ES2 configs
534 return;
535 }
536
537 GrContext* context = ctxInfo.grContext();
538 SkBitmap bmp = make_src_bitmap();
539
540 // On the GPU we will also try reading back from a non-renderable texture.
541 for (auto origin : {kBottomLeft_GrSurfaceOrigin, kTopLeft_GrSurfaceOrigin}) {
542 for (auto isRT : {false, true}) {
543 sk_sp<GrTextureProxy> proxy = sk_gpu_test::MakeTextureProxyFromData(
544 context, isRT, DEV_W, DEV_H, bmp.colorType(), origin, bmp.getPixels(),
545 bmp.rowBytes());
546 sk_sp<GrSurfaceContext> sContext = context->contextPriv().makeWrappedSurfaceContext(
547 std::move(proxy));
548 auto info = SkImageInfo::Make(DEV_W, DEV_H, kN32_SkColorType, kPremul_SkAlphaType);
549 test_readpixels_texture(reporter, std::move(sContext), info);
550 }
551 }
552 }
553
554 ///////////////////////////////////////////////////////////////////////////////////////////////////
555
556 static const uint32_t kNumPixels = 5;
557
558 // The five reference pixels are: red, green, blue, white, black.
559 // Five is an interesting number to test because we'll exercise a full 4-wide SIMD vector
560 // plus a tail pixel.
561 static const uint32_t rgba[kNumPixels] = {
562 0xFF0000FF, 0xFF00FF00, 0xFFFF0000, 0xFFFFFFFF, 0xFF000000
563 };
564 static const uint32_t bgra[kNumPixels] = {
565 0xFFFF0000, 0xFF00FF00, 0xFF0000FF, 0xFFFFFFFF, 0xFF000000
566 };
567 static const uint16_t rgb565[kNumPixels] = {
568 SK_R16_MASK_IN_PLACE, SK_G16_MASK_IN_PLACE, SK_B16_MASK_IN_PLACE, 0xFFFF, 0x0
569 };
570
571 static const uint16_t rgba4444[kNumPixels] = { 0xF00F, 0x0F0F, 0x00FF, 0xFFFF, 0x000F };
572
573 static const uint64_t kRed = (uint64_t) SK_Half1 << 0;
574 static const uint64_t kGreen = (uint64_t) SK_Half1 << 16;
575 static const uint64_t kBlue = (uint64_t) SK_Half1 << 32;
576 static const uint64_t kAlpha = (uint64_t) SK_Half1 << 48;
577 static const uint64_t f16[kNumPixels] = {
578 kAlpha | kRed, kAlpha | kGreen, kAlpha | kBlue, kAlpha | kBlue | kGreen | kRed, kAlpha
579 };
580
581 static const uint8_t alpha8[kNumPixels] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
582 static const uint8_t gray8[kNumPixels] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
583
five_reference_pixels(SkColorType colorType)584 static const void* five_reference_pixels(SkColorType colorType) {
585 switch (colorType) {
586 case kUnknown_SkColorType:
587 return nullptr;
588 case kAlpha_8_SkColorType:
589 return alpha8;
590 case kRGB_565_SkColorType:
591 return rgb565;
592 case kARGB_4444_SkColorType:
593 return rgba4444;
594 case kRGBA_8888_SkColorType:
595 return rgba;
596 case kBGRA_8888_SkColorType:
597 return bgra;
598 case kGray_8_SkColorType:
599 return gray8;
600 case kRGBA_F16_SkColorType:
601 return f16;
602 default:
603 return nullptr;
604 }
605
606 SkASSERT(false);
607 return nullptr;
608 }
609
test_conversion(skiatest::Reporter * r,const SkImageInfo & dstInfo,const SkImageInfo & srcInfo)610 static void test_conversion(skiatest::Reporter* r, const SkImageInfo& dstInfo,
611 const SkImageInfo& srcInfo) {
612 if (!SkImageInfoIsValid(srcInfo)) {
613 return;
614 }
615
616 const void* srcPixels = five_reference_pixels(srcInfo.colorType());
617 SkPixmap srcPixmap(srcInfo, srcPixels, srcInfo.minRowBytes());
618 sk_sp<SkImage> src = SkImage::MakeFromRaster(srcPixmap, nullptr, nullptr);
619 REPORTER_ASSERT(r, src);
620
621 // Enough space for 5 pixels when color type is F16, more than enough space in other cases.
622 uint64_t dstPixels[kNumPixels];
623 SkPixmap dstPixmap(dstInfo, dstPixels, dstInfo.minRowBytes());
624 bool success = src->readPixels(dstPixmap, 0, 0);
625 REPORTER_ASSERT(r, success == SkImageInfoValidConversion(dstInfo, srcInfo));
626
627 if (success) {
628 if (kGray_8_SkColorType == srcInfo.colorType() &&
629 kGray_8_SkColorType != dstInfo.colorType()) {
630 // TODO: test (r,g,b) == (gray,gray,gray)?
631 return;
632 }
633
634 if (kGray_8_SkColorType == dstInfo.colorType() &&
635 kGray_8_SkColorType != srcInfo.colorType()) {
636 // TODO: test gray = luminance?
637 return;
638 }
639
640 if (kAlpha_8_SkColorType == srcInfo.colorType() &&
641 kAlpha_8_SkColorType != dstInfo.colorType()) {
642 // TODO: test output = black with this alpha?
643 return;
644 }
645
646 REPORTER_ASSERT(r, 0 == memcmp(dstPixels, five_reference_pixels(dstInfo.colorType()),
647 kNumPixels * SkColorTypeBytesPerPixel(dstInfo.colorType())));
648 }
649 }
650
DEF_TEST(ReadPixels_ValidConversion,reporter)651 DEF_TEST(ReadPixels_ValidConversion, reporter) {
652 const SkColorType kColorTypes[] = {
653 kUnknown_SkColorType,
654 kAlpha_8_SkColorType,
655 kRGB_565_SkColorType,
656 kARGB_4444_SkColorType,
657 kRGBA_8888_SkColorType,
658 kBGRA_8888_SkColorType,
659 kGray_8_SkColorType,
660 kRGBA_F16_SkColorType,
661 };
662
663 const SkAlphaType kAlphaTypes[] = {
664 kUnknown_SkAlphaType,
665 kOpaque_SkAlphaType,
666 kPremul_SkAlphaType,
667 kUnpremul_SkAlphaType,
668 };
669
670 const sk_sp<SkColorSpace> kColorSpaces[] = {
671 nullptr,
672 SkColorSpace::MakeSRGB(),
673 };
674
675 for (SkColorType dstCT : kColorTypes) {
676 for (SkAlphaType dstAT: kAlphaTypes) {
677 for (sk_sp<SkColorSpace> dstCS : kColorSpaces) {
678 for (SkColorType srcCT : kColorTypes) {
679 for (SkAlphaType srcAT: kAlphaTypes) {
680 for (sk_sp<SkColorSpace> srcCS : kColorSpaces) {
681 test_conversion(reporter,
682 SkImageInfo::Make(kNumPixels, 1, dstCT, dstAT, dstCS),
683 SkImageInfo::Make(kNumPixels, 1, srcCT, srcAT, srcCS));
684 }
685 }
686 }
687 }
688 }
689 }
690 }
691