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 "SkSurface.h" 10 #include "Test.h" 11 #include "sk_tool_utils.h" 12 13 #if SK_SUPPORT_GPU 14 #include "GrContext.h" 15 #endif 16 17 static uint32_t pack_unpremul_rgba(SkColor c) { 18 uint32_t packed; 19 uint8_t* byte = reinterpret_cast<uint8_t*>(&packed); 20 byte[0] = SkColorGetR(c); 21 byte[1] = SkColorGetG(c); 22 byte[2] = SkColorGetB(c); 23 byte[3] = SkColorGetA(c); 24 return packed; 25 } 26 27 static uint32_t pack_unpremul_bgra(SkColor c) { 28 uint32_t packed; 29 uint8_t* byte = reinterpret_cast<uint8_t*>(&packed); 30 byte[0] = SkColorGetB(c); 31 byte[1] = SkColorGetG(c); 32 byte[2] = SkColorGetR(c); 33 byte[3] = SkColorGetA(c); 34 return packed; 35 } 36 37 typedef uint32_t (*PackUnpremulProc)(SkColor); 38 39 const struct { 40 SkColorType fColorType; 41 PackUnpremulProc fPackProc; 42 } gUnpremul[] = { 43 { kRGBA_8888_SkColorType, pack_unpremul_rgba }, 44 { kBGRA_8888_SkColorType, pack_unpremul_bgra }, 45 }; 46 47 static void fill_canvas(SkCanvas* canvas, SkColorType colorType, PackUnpremulProc proc) { 48 // Don't strictly need a bitmap, but its a handy way to allocate the pixels 49 SkBitmap bmp; 50 bmp.allocN32Pixels(256, 256); 51 52 for (int a = 0; a < 256; ++a) { 53 uint32_t* pixels = bmp.getAddr32(0, a); 54 for (int r = 0; r < 256; ++r) { 55 pixels[r] = proc(SkColorSetARGB(a, r, 0, 0)); 56 } 57 } 58 59 const SkImageInfo info = SkImageInfo::Make(bmp.width(), bmp.height(), 60 colorType, kUnpremul_SkAlphaType); 61 canvas->writePixels(info, bmp.getPixels(), bmp.rowBytes(), 0, 0); 62 } 63 64 static void test_premul_alpha_roundtrip(skiatest::Reporter* reporter, SkSurface* surf) { 65 SkCanvas* canvas = surf->getCanvas(); 66 for (size_t upmaIdx = 0; upmaIdx < SK_ARRAY_COUNT(gUnpremul); ++upmaIdx) { 67 fill_canvas(canvas, gUnpremul[upmaIdx].fColorType, gUnpremul[upmaIdx].fPackProc); 68 69 const SkImageInfo info = SkImageInfo::Make(256, 256, gUnpremul[upmaIdx].fColorType, 70 kUnpremul_SkAlphaType); 71 SkBitmap readBmp1; 72 readBmp1.allocPixels(info); 73 SkBitmap readBmp2; 74 readBmp2.allocPixels(info); 75 76 readBmp1.eraseColor(0); 77 readBmp2.eraseColor(0); 78 79 canvas->readPixels(readBmp1, 0, 0); 80 sk_tool_utils::write_pixels(canvas, readBmp1, 0, 0, gUnpremul[upmaIdx].fColorType, 81 kUnpremul_SkAlphaType); 82 canvas->readPixels(readBmp2, 0, 0); 83 84 bool success = true; 85 for (int y = 0; y < 256 && success; ++y) { 86 const uint32_t* pixels1 = readBmp1.getAddr32(0, y); 87 const uint32_t* pixels2 = readBmp2.getAddr32(0, y); 88 for (int x = 0; x < 256 && success; ++x) { 89 // We see sporadic failures here. May help to see where it goes wrong. 90 if (pixels1[x] != pixels2[x]) { 91 SkDebugf("%x != %x, x = %d, y = %d\n", pixels1[x], pixels2[x], x, y); 92 } 93 REPORTER_ASSERT(reporter, success = pixels1[x] == pixels2[x]); 94 } 95 } 96 } 97 } 98 99 DEF_TEST(PremulAlphaRoundTrip, reporter) { 100 const SkImageInfo info = SkImageInfo::MakeN32Premul(256, 256); 101 102 sk_sp<SkSurface> surf(SkSurface::MakeRaster(info)); 103 104 test_premul_alpha_roundtrip(reporter, surf.get()); 105 } 106 #if SK_SUPPORT_GPU 107 DEF_GPUTEST_FOR_RENDERING_CONTEXTS(PremulAlphaRoundTrip_Gpu, reporter, ctxInfo) { 108 const SkImageInfo info = SkImageInfo::MakeN32Premul(256, 256); 109 110 sk_sp<SkSurface> surf(SkSurface::MakeRenderTarget(ctxInfo.grContext(), 111 SkBudgeted::kNo, 112 info)); 113 test_premul_alpha_roundtrip(reporter, surf.get()); 114 } 115 #endif 116