1 /*
2  * Copyright 2013 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 "SkBitmap.h"
9 #include "SkColor.h"
10 #include "SkImageInfo.h"
11 #include "SkMallocPixelRef.h"
12 #include "SkPixelRef.h"
13 #include "SkPixmap.h"
14 #include "SkRandom.h"
15 #include "SkRefCnt.h"
16 #include "SkTypes.h"
17 #include "Test.h"
18 #include "sk_tool_utils.h"
19 
test_peekpixels(skiatest::Reporter * reporter)20 static void test_peekpixels(skiatest::Reporter* reporter) {
21     const SkImageInfo info = SkImageInfo::MakeN32Premul(10, 10);
22 
23     SkPixmap pmap;
24     SkBitmap bm;
25 
26     // empty should return false
27     REPORTER_ASSERT(reporter, !bm.peekPixels(nullptr));
28     REPORTER_ASSERT(reporter, !bm.peekPixels(&pmap));
29 
30     // no pixels should return false
31     bm.setInfo(SkImageInfo::MakeN32Premul(10, 10));
32     REPORTER_ASSERT(reporter, !bm.peekPixels(nullptr));
33     REPORTER_ASSERT(reporter, !bm.peekPixels(&pmap));
34 
35     // real pixels should return true
36     bm.allocPixels(info);
37     REPORTER_ASSERT(reporter, bm.peekPixels(nullptr));
38     REPORTER_ASSERT(reporter, bm.peekPixels(&pmap));
39     REPORTER_ASSERT(reporter, pmap.info() == bm.info());
40     REPORTER_ASSERT(reporter, pmap.addr() == bm.getPixels());
41     REPORTER_ASSERT(reporter, pmap.rowBytes() == bm.rowBytes());
42 }
43 
44 // https://code.google.com/p/chromium/issues/detail?id=446164
test_bigalloc(skiatest::Reporter * reporter)45 static void test_bigalloc(skiatest::Reporter* reporter) {
46     const int width = 0x40000001;
47     const int height = 0x00000096;
48     const SkImageInfo info = SkImageInfo::MakeN32Premul(width, height);
49 
50     SkBitmap bm;
51     REPORTER_ASSERT(reporter, !bm.tryAllocPixels(info));
52 
53     sk_sp<SkPixelRef> pr = SkMallocPixelRef::MakeAllocate(info, info.minRowBytes());
54     REPORTER_ASSERT(reporter, !pr);
55 }
56 
test_allocpixels(skiatest::Reporter * reporter)57 static void test_allocpixels(skiatest::Reporter* reporter) {
58     const int width = 10;
59     const int height = 10;
60     const SkImageInfo info = SkImageInfo::MakeN32Premul(width, height);
61     const size_t explicitRowBytes = info.minRowBytes() + 24;
62 
63     SkBitmap bm;
64     bm.setInfo(info);
65     REPORTER_ASSERT(reporter, info.minRowBytes() == bm.rowBytes());
66     bm.allocPixels();
67     REPORTER_ASSERT(reporter, info.minRowBytes() == bm.rowBytes());
68     bm.reset();
69     bm.allocPixels(info);
70     REPORTER_ASSERT(reporter, info.minRowBytes() == bm.rowBytes());
71 
72     bm.setInfo(info, explicitRowBytes);
73     REPORTER_ASSERT(reporter, explicitRowBytes == bm.rowBytes());
74     bm.allocPixels();
75     REPORTER_ASSERT(reporter, explicitRowBytes == bm.rowBytes());
76     bm.reset();
77     bm.allocPixels(info, explicitRowBytes);
78     REPORTER_ASSERT(reporter, explicitRowBytes == bm.rowBytes());
79 
80     bm.reset();
81     bm.setInfo(info, 0);
82     REPORTER_ASSERT(reporter, info.minRowBytes() == bm.rowBytes());
83     bm.reset();
84     bm.allocPixels(info, 0);
85     REPORTER_ASSERT(reporter, info.minRowBytes() == bm.rowBytes());
86 
87     bm.reset();
88     bool success = bm.setInfo(info, info.minRowBytes() - 1);   // invalid for 32bit
89     REPORTER_ASSERT(reporter, !success);
90     REPORTER_ASSERT(reporter, bm.isNull());
91 }
92 
test_bigwidth(skiatest::Reporter * reporter)93 static void test_bigwidth(skiatest::Reporter* reporter) {
94     SkBitmap bm;
95     int width = 1 << 29;    // *4 will be the high-bit of 32bit int
96 
97     SkImageInfo info = SkImageInfo::MakeA8(width, 1);
98     REPORTER_ASSERT(reporter, bm.setInfo(info));
99     REPORTER_ASSERT(reporter, bm.setInfo(info.makeColorType(kRGB_565_SkColorType)));
100 
101     // for a 4-byte config, this width will compute a rowbytes of 0x80000000,
102     // which does not fit in a int32_t. setConfig should detect this, and fail.
103 
104     // TODO: perhaps skia can relax this, and only require that rowBytes fit
105     //       in a uint32_t (or larger), but for now this is the constraint.
106 
107     REPORTER_ASSERT(reporter, !bm.setInfo(info.makeColorType(kN32_SkColorType)));
108 }
109 
110 /**
111  *  This test contains basic sanity checks concerning bitmaps.
112  */
DEF_TEST(Bitmap,reporter)113 DEF_TEST(Bitmap, reporter) {
114     // Zero-sized bitmaps are allowed
115     for (int width = 0; width < 2; ++width) {
116         for (int height = 0; height < 2; ++height) {
117             SkBitmap bm;
118             bool setConf = bm.setInfo(SkImageInfo::MakeN32Premul(width, height));
119             REPORTER_ASSERT(reporter, setConf);
120             if (setConf) {
121                 bm.allocPixels();
122             }
123             REPORTER_ASSERT(reporter, SkToBool(width & height) != bm.empty());
124         }
125     }
126 
127     test_bigwidth(reporter);
128     test_allocpixels(reporter);
129     test_bigalloc(reporter);
130     test_peekpixels(reporter);
131 }
132 
133 /**
134  *  This test checks that getColor works for both swizzles.
135  */
DEF_TEST(Bitmap_getColor_Swizzle,r)136 DEF_TEST(Bitmap_getColor_Swizzle, r) {
137     SkBitmap source;
138     source.allocN32Pixels(1,1);
139     source.eraseColor(SK_ColorRED);
140     SkColorType colorTypes[] = {
141         kRGBA_8888_SkColorType,
142         kBGRA_8888_SkColorType,
143     };
144     for (SkColorType ct : colorTypes) {
145         SkBitmap copy;
146         if (!sk_tool_utils::copy_to(&copy, ct, source)) {
147             ERRORF(r, "SkBitmap::copy failed %d", (int)ct);
148             continue;
149         }
150         REPORTER_ASSERT(r, source.getColor(0, 0) == copy.getColor(0, 0));
151     }
152 }
153 
test_erasecolor_premul(skiatest::Reporter * reporter,SkColorType ct,SkColor input,SkColor expected)154 static void test_erasecolor_premul(skiatest::Reporter* reporter, SkColorType ct, SkColor input,
155                                    SkColor expected) {
156   SkBitmap bm;
157   bm.allocPixels(SkImageInfo::Make(1, 1, ct, kPremul_SkAlphaType));
158   bm.eraseColor(input);
159   INFOF(reporter, "expected: %x actual: %x\n", expected, bm.getColor(0, 0));
160   REPORTER_ASSERT(reporter, bm.getColor(0, 0) == expected);
161 }
162 
163 /**
164  *  This test checks that eraseColor premultiplies the color correctly.
165  */
DEF_TEST(Bitmap_eraseColor_Premul,r)166 DEF_TEST(Bitmap_eraseColor_Premul, r) {
167     SkColor color = 0x80FF0080;
168     test_erasecolor_premul(r, kAlpha_8_SkColorType, color, 0x80000000);
169     test_erasecolor_premul(r, kRGB_565_SkColorType, color, 0xFF840042);
170     test_erasecolor_premul(r, kARGB_4444_SkColorType, color, 0x88FF0080);
171     test_erasecolor_premul(r, kRGBA_8888_SkColorType, color, color);
172     test_erasecolor_premul(r, kBGRA_8888_SkColorType, color, color);
173 }
174 
175 // Test that SkBitmap::ComputeOpaque() is correct for various colortypes.
DEF_TEST(Bitmap_compute_is_opaque,r)176 DEF_TEST(Bitmap_compute_is_opaque, r) {
177     SkColorType colorTypes[] = {
178         kAlpha_8_SkColorType,
179         kRGB_565_SkColorType,
180         kARGB_4444_SkColorType,
181         kRGBA_8888_SkColorType,
182         kRGB_888x_SkColorType,
183         kBGRA_8888_SkColorType,
184         kRGBA_1010102_SkColorType,
185         kRGB_101010x_SkColorType,
186         kGray_8_SkColorType,
187         kRGBA_F16_SkColorType,
188         kRGBA_F32_SkColorType,
189     };
190     for (auto ct : colorTypes) {
191         SkBitmap bm;
192         SkAlphaType at = SkColorTypeIsAlwaysOpaque(ct) ? kOpaque_SkAlphaType : kPremul_SkAlphaType;
193         bm.allocPixels(SkImageInfo::Make(13, 17, ct, at));
194         bm.eraseColor(SkColorSetARGB(255, 10, 20, 30));
195         REPORTER_ASSERT(r, SkBitmap::ComputeIsOpaque(bm));
196 
197         bm.eraseColor(SkColorSetARGB(128, 255, 255, 255));
198         bool isOpaque = SkBitmap::ComputeIsOpaque(bm);
199         bool shouldBeOpaque = (at == kOpaque_SkAlphaType);
200         REPORTER_ASSERT(r, isOpaque == shouldBeOpaque);
201     }
202 }
203 
204 // Test that erase+getColor round trips with RGBA_F16 pixels.
DEF_TEST(Bitmap_erase_f16_erase_getColor,r)205 DEF_TEST(Bitmap_erase_f16_erase_getColor, r) {
206     SkRandom random;
207     SkPixmap pm;
208     SkBitmap bm;
209     bm.allocPixels(SkImageInfo::Make(1, 1, kRGBA_F16_SkColorType, kPremul_SkAlphaType));
210     REPORTER_ASSERT(r, bm.peekPixels(&pm));
211     for (unsigned i = 0; i < 0x100; ++i) {
212         // Test all possible values of blue component.
213         SkColor color1 = (SkColor)((random.nextU() & 0xFFFFFF00) | i);
214         // Test all possible values of alpha component.
215         SkColor color2 = (SkColor)((random.nextU() & 0x00FFFFFF) | (i << 24));
216         for (SkColor color : {color1, color2}) {
217             pm.erase(color);
218             if (SkColorGetA(color) != 0) {
219                 REPORTER_ASSERT(r, color == pm.getColor(0, 0));
220             } else {
221                 REPORTER_ASSERT(r, 0 == SkColorGetA(pm.getColor(0, 0)));
222             }
223         }
224     }
225 }
226 
227 // Make sure that the bitmap remains valid when pixelref is removed.
DEF_TEST(Bitmap_clear_pixelref_keep_info,r)228 DEF_TEST(Bitmap_clear_pixelref_keep_info, r) {
229     SkBitmap bm;
230     bm.allocPixels(SkImageInfo::MakeN32Premul(100,100));
231     bm.setPixelRef(nullptr, 0, 0);
232     SkDEBUGCODE(bm.validate();)
233 }
234 
235 // At the time of writing, SkBitmap::erase() works when the color is zero for all formats,
236 // but some formats failed when the color is non-zero!
DEF_TEST(Bitmap_erase,r)237 DEF_TEST(Bitmap_erase, r) {
238     SkColorType colorTypes[] = {
239         kRGB_565_SkColorType,
240         kARGB_4444_SkColorType,
241         kRGB_888x_SkColorType,
242         kRGBA_8888_SkColorType,
243         kBGRA_8888_SkColorType,
244         kRGB_101010x_SkColorType,
245         kRGBA_1010102_SkColorType,
246     };
247 
248     for (SkColorType ct : colorTypes) {
249         SkImageInfo info = SkImageInfo::Make(1,1, (SkColorType)ct, kPremul_SkAlphaType);
250 
251         SkBitmap bm;
252         bm.allocPixels(info);
253 
254         bm.eraseColor(0x00000000);
255         if (SkColorTypeIsAlwaysOpaque(ct)) {
256             REPORTER_ASSERT(r, bm.getColor(0,0) == 0xff000000);
257         } else {
258             REPORTER_ASSERT(r, bm.getColor(0,0) == 0x00000000);
259         }
260 
261         bm.eraseColor(0xaabbccdd);
262         REPORTER_ASSERT(r, bm.getColor(0,0) != 0xff000000);
263         REPORTER_ASSERT(r, bm.getColor(0,0) != 0x00000000);
264     }
265 }
266 
check_alphas(skiatest::Reporter * reporter,const SkBitmap & bm,bool (* pred)(float expected,float actual))267 static void check_alphas(skiatest::Reporter* reporter, const SkBitmap& bm,
268                          bool (*pred)(float expected, float actual)) {
269     SkASSERT(bm.width() == 16);
270     SkASSERT(bm.height() == 16);
271 
272     int alpha = 0;
273     for (int y = 0; y < 16; ++y) {
274         for (int x = 0; x < 16; ++x) {
275             float expected = alpha / 255.0f;
276             float actual = bm.getAlphaf(x, y);
277             if (!pred(expected, actual)) {
278                 ERRORF(reporter, "got %g, want %g\n", actual, expected);
279             }
280             alpha += 1;
281         }
282     }
283 }
284 
unit_compare(float expected,float actual,float tol=1.0f/(1<<12))285 static bool unit_compare(float expected, float actual, float tol = 1.0f/(1<<12)) {
286     SkASSERT(expected >= 0 && expected <= 1);
287     SkASSERT(  actual >= 0 &&   actual <= 1);
288     if (expected == 0 || expected == 1) {
289         return actual == expected;
290     } else {
291         return SkScalarNearlyEqual(expected, actual, tol);
292     }
293 }
294 
unit_discretize(float value,float scale)295 static float unit_discretize(float value, float scale) {
296     SkASSERT(value >= 0 && value <= 1);
297     if (value == 1) {
298         return 1;
299     } else {
300         return sk_float_floor(value * scale + 0.5f) / scale;
301     }
302 }
303 
DEF_TEST(getalphaf,reporter)304 DEF_TEST(getalphaf, reporter) {
305     SkImageInfo info = SkImageInfo::MakeN32Premul(16, 16);
306     SkBitmap bm;
307     bm.allocPixels(info);
308 
309     int alpha = 0;
310     for (int y = 0; y < 16; ++y) {
311         for (int x = 0; x < 16; ++x) {
312             *bm.getAddr32(x, y) = alpha++ << 24;
313         }
314     }
315 
316     auto nearly = [](float expected, float actual) -> bool {
317         return unit_compare(expected, actual);
318     };
319     auto nearly4bit = [](float expected, float actual) -> bool {
320         expected = unit_discretize(expected, 15);
321         return unit_compare(expected, actual);
322     };
323     auto nearly2bit = [](float expected, float actual) -> bool {
324         expected = unit_discretize(expected, 3);
325         return unit_compare(expected, actual);
326     };
327     auto opaque = [](float expected, float actual) -> bool {
328         return actual == 1.0f;
329     };
330 
331     auto nearly_half = [](float expected, float actual) -> bool {
332         return unit_compare(expected, actual, 1.0f/(1<<10));
333     };
334 
335     const struct {
336         SkColorType fColorType;
337         bool (*fPred)(float, float);
338     } recs[] = {
339         { kRGB_565_SkColorType,     opaque },
340         { kGray_8_SkColorType,      opaque },
341         { kRGB_888x_SkColorType,    opaque },
342         { kRGB_101010x_SkColorType, opaque },
343 
344         { kAlpha_8_SkColorType,     nearly },
345         { kRGBA_8888_SkColorType,   nearly },
346         { kBGRA_8888_SkColorType,   nearly },
347         { kRGBA_F16_SkColorType,    nearly_half },
348         { kRGBA_F32_SkColorType,    nearly },
349 
350         { kRGBA_1010102_SkColorType, nearly2bit },
351 
352         { kARGB_4444_SkColorType,   nearly4bit },
353     };
354 
355     for (const auto& rec : recs) {
356         SkBitmap tmp;
357         tmp.allocPixels(bm.info().makeColorType(rec.fColorType));
358         if (bm.readPixels(tmp.pixmap())) {
359             check_alphas(reporter, tmp, rec.fPred);
360         } else {
361             SkDebugf("can't readpixels\n");
362         }
363     }
364 }
365 
366