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 "SkBitmapDevice.h"
9 #include "SkCanvas.h"
10 #include "SkConfig8888.h"
11 #include "Test.h"
12 #include "sk_tool_utils.h"
13
14 #if SK_SUPPORT_GPU
15 #include "GrContextFactory.h"
16 #include "SkGpuDevice.h"
17 #endif
18
pack_unpremul_rgba(SkColor c)19 static uint32_t pack_unpremul_rgba(SkColor c) {
20 uint32_t packed;
21 uint8_t* byte = reinterpret_cast<uint8_t*>(&packed);
22 byte[0] = SkColorGetR(c);
23 byte[1] = SkColorGetG(c);
24 byte[2] = SkColorGetB(c);
25 byte[3] = SkColorGetA(c);
26 return packed;
27 }
28
pack_unpremul_bgra(SkColor c)29 static uint32_t pack_unpremul_bgra(SkColor c) {
30 uint32_t packed;
31 uint8_t* byte = reinterpret_cast<uint8_t*>(&packed);
32 byte[0] = SkColorGetB(c);
33 byte[1] = SkColorGetG(c);
34 byte[2] = SkColorGetR(c);
35 byte[3] = SkColorGetA(c);
36 return packed;
37 }
38
39 typedef uint32_t (*PackUnpremulProc)(SkColor);
40
41 const struct {
42 SkColorType fColorType;
43 PackUnpremulProc fPackProc;
44 } gUnpremul[] = {
45 { kRGBA_8888_SkColorType, pack_unpremul_rgba },
46 { kBGRA_8888_SkColorType, pack_unpremul_bgra },
47 };
48
fillCanvas(SkCanvas * canvas,SkColorType colorType,PackUnpremulProc proc)49 static void fillCanvas(SkCanvas* canvas, SkColorType colorType, PackUnpremulProc proc) {
50 // Don't strictly need a bitmap, but its a handy way to allocate the pixels
51 SkBitmap bmp;
52 bmp.allocN32Pixels(256, 256);
53
54 for (int a = 0; a < 256; ++a) {
55 uint32_t* pixels = bmp.getAddr32(0, a);
56 for (int r = 0; r < 256; ++r) {
57 pixels[r] = proc(SkColorSetARGB(a, r, 0, 0));
58 }
59 }
60
61 SkImageInfo info = bmp.info();
62 info.fColorType = colorType;
63 info.fAlphaType = kUnpremul_SkAlphaType;
64 canvas->writePixels(info, bmp.getPixels(), bmp.rowBytes(), 0, 0);
65 }
66
DEF_GPUTEST(PremulAlphaRoundTrip,reporter,factory)67 DEF_GPUTEST(PremulAlphaRoundTrip, reporter, factory) {
68 const SkImageInfo info = SkImageInfo::MakeN32Premul(256, 256);
69
70 SkAutoTUnref<SkBaseDevice> device;
71 for (int dtype = 0; dtype < 2; ++dtype) {
72
73 int glCtxTypeCnt = 1;
74 #if SK_SUPPORT_GPU
75 if (0 != dtype) {
76 glCtxTypeCnt = GrContextFactory::kGLContextTypeCnt;
77 }
78 #endif
79 for (int glCtxType = 0; glCtxType < glCtxTypeCnt; ++glCtxType) {
80 if (0 == dtype) {
81 device.reset(SkBitmapDevice::Create(info));
82 } else {
83 #if SK_SUPPORT_GPU
84 GrContextFactory::GLContextType type =
85 static_cast<GrContextFactory::GLContextType>(glCtxType);
86 if (!GrContextFactory::IsRenderingGLContext(type)) {
87 continue;
88 }
89 GrContext* context = factory->get(type);
90 if (NULL == context) {
91 continue;
92 }
93
94 device.reset(SkGpuDevice::Create(context, info, 0));
95 #else
96 continue;
97 #endif
98 }
99 SkCanvas canvas(device);
100
101 for (size_t upmaIdx = 0; upmaIdx < SK_ARRAY_COUNT(gUnpremul); ++upmaIdx) {
102 fillCanvas(&canvas, gUnpremul[upmaIdx].fColorType, gUnpremul[upmaIdx].fPackProc);
103
104 const SkImageInfo info = SkImageInfo::Make(256, 256, gUnpremul[upmaIdx].fColorType,
105 kUnpremul_SkAlphaType);
106 SkBitmap readBmp1;
107 readBmp1.allocPixels(info);
108 SkBitmap readBmp2;
109 readBmp2.allocPixels(info);
110
111 readBmp1.eraseColor(0);
112 readBmp2.eraseColor(0);
113
114 canvas.readPixels(&readBmp1, 0, 0);
115 sk_tool_utils::write_pixels(&canvas, readBmp1, 0, 0, gUnpremul[upmaIdx].fColorType,
116 kUnpremul_SkAlphaType);
117 canvas.readPixels(&readBmp2, 0, 0);
118
119 bool success = true;
120 for (int y = 0; y < 256 && success; ++y) {
121 const uint32_t* pixels1 = readBmp1.getAddr32(0, y);
122 const uint32_t* pixels2 = readBmp2.getAddr32(0, y);
123 for (int x = 0; x < 256 && success; ++x) {
124 REPORTER_ASSERT(reporter, success = pixels1[x] == pixels2[x]);
125 }
126 }
127 }
128 }
129 }
130 }
131