?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Correctly track texture cleared state for sharing
[chromium-blink-merge.git] / ui / gfx / codec / png_codec_unittest.cc
blob610421a22d74fb10a0059d146ae6aed63d3fc0ce
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include <algorithm>
6 #include <cmath>
7
8 #include "base/logging.h"
9 #include "testing/gtest/include/gtest/gtest.h"
10 #include "third_party/libpng/png.h"
11 #include "third_party/skia/include/core/SkBitmap.h"
12 #include "third_party/skia/include/core/SkColorPriv.h"
13 #include "third_party/skia/include/core/SkUnPreMultiply.h"
14 #include "third_party/zlib/zlib.h"
15 #include "ui/gfx/codec/png_codec.h"
16 #include "ui/gfx/geometry/size.h"
17 #include "ui/gfx/skia_util.h"
18
19 namespace gfx {
20
21 namespace {
22
23 void MakeRGBImage(int w, int h, std::vector<unsigned char>* data) {
24 data->resize(w * h * 3);
25 for (int y = 0; y < h; y++) {
26 for (int x = 0; x < w; x++) {
27 unsigned char* org_px = &(*data)[(y * w + x) * 3];
28 org_px[0] = x * 3; // r
29 org_px[1] = x * 3 + 1; // g
30 org_px[2] = x * 3 + 2; // b
31 }
32 }
33 }
34
35 // Set use_transparency to write data into the alpha channel, otherwise it will
36 // be filled with 0xff. With the alpha channel stripped, this should yield the
37 // same image as MakeRGBImage above, so the code below can make reference
38 // images for conversion testing.
39 void MakeRGBAImage(int w, int h, bool use_transparency,
40 std::vector<unsigned char>* data) {
41 data->resize(w * h * 4);
42 for (int y = 0; y < h; y++) {
43 for (int x = 0; x < w; x++) {
44 unsigned char* org_px = &(*data)[(y * w + x) * 4];
45 org_px[0] = x * 3; // r
46 org_px[1] = x * 3 + 1; // g
47 org_px[2] = x * 3 + 2; // b
48 if (use_transparency)
49 org_px[3] = x*3 + 3; // a
50 else
51 org_px[3] = 0xFF; // a (opaque)
52 }
53 }
54 }
55
56 // Creates a palette-based image.
57 void MakePaletteImage(int w, int h,
58 std::vector<unsigned char>* data,
59 std::vector<png_color>* palette,
60 std::vector<unsigned char>* trans_chunk = 0) {
61 data->resize(w * h);
62 palette->resize(w);
63 for (int i = 0; i < w; ++i) {
64 png_color& color = (*palette)[i];
65 color.red = i * 3;
66 color.green = color.red + 1;
67 color.blue = color.red + 2;
68 }
69 for (int y = 0; y < h; y++) {
70 for (int x = 0; x < w; x++) {
71 (*data)[y * w + x] = x; // palette index
72 }
73 }
74 if (trans_chunk) {
75 trans_chunk->resize(palette->size());
76 for (std::size_t i = 0; i < trans_chunk->size(); ++i) {
77 (*trans_chunk)[i] = i % 256;
78 }
79 }
80 }
81
82 // Creates a grayscale image without an alpha channel.
83 void MakeGrayscaleImage(int w, int h,
84 std::vector<unsigned char>* data) {
85 data->resize(w * h);
86 for (int y = 0; y < h; y++) {
87 for (int x = 0; x < w; x++) {
88 (*data)[y * w + x] = x; // gray value
89 }
90 }
91 }
92
93 // Creates a grayscale image with an alpha channel.
94 void MakeGrayscaleAlphaImage(int w, int h,
95 std::vector<unsigned char>* data) {
96 data->resize(w * h * 2);
97 for (int y = 0; y < h; y++) {
98 for (int x = 0; x < w; x++) {
99 unsigned char* px = &(*data)[(y * w + x) * 2];
100 px[0] = x; // gray value
101 px[1] = x % 256; // alpha
102 }
103 }
104 }
105
106 // User write function (to be passed to libpng by EncodeImage) which writes
107 // into a buffer instead of to a file.
108 void WriteImageData(png_structp png_ptr,
109 png_bytep data,
110 png_size_t length) {
111 std::vector<unsigned char>& v =
112 *static_cast<std::vector<unsigned char>*>(png_get_io_ptr(png_ptr));
113 v.resize(v.size() + length);
114 memcpy(&v[v.size() - length], data, length);
115 }
116
117 // User flush function; goes with WriteImageData, above.
118 void FlushImageData(png_structp /*png_ptr*/) {
119 }
120
121 // Libpng user error function which allows us to print libpng errors using
122 // Chrome's logging facilities instead of stderr.
123 void LogLibPNGError(png_structp png_ptr,
124 png_const_charp error_msg) {
125 DLOG(ERROR) << "libpng encode error: " << error_msg;
126 longjmp(png_jmpbuf(png_ptr), 1);
127 }
128
129 // Goes with LogLibPNGError, above.
130 void LogLibPNGWarning(png_structp png_ptr,
131 png_const_charp warning_msg) {
132 DLOG(ERROR) << "libpng encode warning: " << warning_msg;
133 }
134
135 // Color types supported by EncodeImage. Required because neither libpng nor
136 // PNGCodec::Encode supports all of the required values.
137 enum ColorType {
138 COLOR_TYPE_GRAY = PNG_COLOR_TYPE_GRAY,
139 COLOR_TYPE_GRAY_ALPHA = PNG_COLOR_TYPE_GRAY_ALPHA,
140 COLOR_TYPE_PALETTE = PNG_COLOR_TYPE_PALETTE,
141 COLOR_TYPE_RGB = PNG_COLOR_TYPE_RGB,
142 COLOR_TYPE_RGBA = PNG_COLOR_TYPE_RGBA,
143 COLOR_TYPE_BGR,
144 COLOR_TYPE_BGRA
145 };
146
147 // PNG encoder used for testing. Required because PNGCodec::Encode doesn't do
148 // interlaced, palette-based, or grayscale images, but PNGCodec::Decode is
149 // actually asked to decode these types of images by Chrome.
150 bool EncodeImage(const std::vector<unsigned char>& input,
151 const int width,
152 const int height,
153 ColorType output_color_type,
154 std::vector<unsigned char>* output,
155 const int interlace_type = PNG_INTERLACE_NONE,
156 std::vector<png_color>* palette = 0,
157 std::vector<unsigned char>* palette_alpha = 0) {
158 DCHECK(output);
159
160 int input_rowbytes = 0;
161 int transforms = PNG_TRANSFORM_IDENTITY;
162
163 switch (output_color_type) {
164 case COLOR_TYPE_GRAY:
165 input_rowbytes = width;
166 break;
167 case COLOR_TYPE_GRAY_ALPHA:
168 input_rowbytes = width * 2;
169 break;
170 case COLOR_TYPE_PALETTE:
171 if (!palette)
172 return false;
173 input_rowbytes = width;
174 break;
175 case COLOR_TYPE_RGB:
176 input_rowbytes = width * 3;
177 break;
178 case COLOR_TYPE_RGBA:
179 input_rowbytes = width * 4;
180 break;
181 case COLOR_TYPE_BGR:
182 input_rowbytes = width * 3;
183 output_color_type = static_cast<ColorType>(PNG_COLOR_TYPE_RGB);
184 transforms |= PNG_TRANSFORM_BGR;
185 break;
186 case COLOR_TYPE_BGRA:
187 input_rowbytes = width * 4;
188 output_color_type = static_cast<ColorType>(PNG_COLOR_TYPE_RGBA);
189 transforms |= PNG_TRANSFORM_BGR;
190 break;
191 };
192
193 png_struct* png_ptr =
194 png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
195 if (!png_ptr)
196 return false;
197 png_infop info_ptr = png_create_info_struct(png_ptr);
198 if (!info_ptr) {
199 png_destroy_write_struct(&png_ptr, NULL);
200 return false;
201 }
202
203 std::vector<png_bytep> row_pointers(height);
204 for (int y = 0 ; y < height; ++y) {
205 row_pointers[y] = const_cast<unsigned char*>(&input[y * input_rowbytes]);
206 }
207
208 if (setjmp(png_jmpbuf(png_ptr))) {
209 png_destroy_write_struct(&png_ptr, &info_ptr);
210 return false;
211 }
212
213 png_set_error_fn(png_ptr, NULL, LogLibPNGError, LogLibPNGWarning);
214 png_set_rows(png_ptr, info_ptr, &row_pointers[0]);
215 png_set_write_fn(png_ptr, output, WriteImageData, FlushImageData);
216 png_set_IHDR(png_ptr, info_ptr, width, height, 8, output_color_type,
217 interlace_type, PNG_COMPRESSION_TYPE_DEFAULT,
218 PNG_FILTER_TYPE_DEFAULT);
219 if (output_color_type == COLOR_TYPE_PALETTE) {
220 png_set_PLTE(png_ptr, info_ptr, &palette->front(), palette->size());
221 if (palette_alpha) {
222 unsigned char* alpha_data = &palette_alpha->front();
223 size_t alpha_size = palette_alpha->size();
224 png_set_tRNS(png_ptr, info_ptr, alpha_data, alpha_size, NULL);
225 }
226 }
227
228 png_write_png(png_ptr, info_ptr, transforms, NULL);
229
230 png_destroy_write_struct(&png_ptr, &info_ptr);
231 return true;
232 }
233
234 } // namespace
235
236 // Returns true if each channel of the given two colors are "close." This is
237 // used for comparing colors where rounding errors may cause off-by-one.
238 bool ColorsClose(uint32_t a, uint32_t b) {
239 return abs(static_cast<int>(SkColorGetB(a) - SkColorGetB(b))) < 2 &&
240 abs(static_cast<int>(SkColorGetG(a) - SkColorGetG(b))) < 2 &&
241 abs(static_cast<int>(SkColorGetR(a) - SkColorGetR(b))) < 2 &&
242 abs(static_cast<int>(SkColorGetA(a) - SkColorGetA(b))) < 2;
243 }
244
245 // Returns true if the RGB components are "close."
246 bool NonAlphaColorsClose(uint32_t a, uint32_t b) {
247 return abs(static_cast<int>(SkColorGetB(a) - SkColorGetB(b))) < 2 &&
248 abs(static_cast<int>(SkColorGetG(a) - SkColorGetG(b))) < 2 &&
249 abs(static_cast<int>(SkColorGetR(a) - SkColorGetR(b))) < 2;
250 }
251
252 // Returns true if the BGRA 32-bit SkColor specified by |a| is equivalent to the
253 // 8-bit Gray color specified by |b|.
254 bool BGRAGrayEqualsA8Gray(uint32_t a, uint8_t b) {
255 return SkColorGetB(a) == b && SkColorGetG(a) == b &&
256 SkColorGetR(a) == b && SkColorGetA(a) == 255;
257 }
258
259 void MakeTestBGRASkBitmap(int w, int h, SkBitmap* bmp) {
260 bmp->allocN32Pixels(w, h);
261
262 uint32_t* src_data = bmp->getAddr32(0, 0);
263 for (int i = 0; i < w * h; i++)
264 src_data[i] = SkPreMultiplyARGB(i % 255, i % 250, i % 245, i % 240);
265 }
266
267 void MakeTestA8SkBitmap(int w, int h, SkBitmap* bmp) {
268 bmp->allocPixels(SkImageInfo::MakeA8(w, h));
269
270 uint8_t* src_data = bmp->getAddr8(0, 0);
271 for (int i = 0; i < w * h; i++)
272 src_data[i] = i % 255;
273 }
274
275 TEST(PNGCodec, EncodeDecodeRGB) {
276 const int w = 20, h = 20;
277
278 // create an image with known values
279 std::vector<unsigned char> original;
280 MakeRGBImage(w, h, &original);
281
282 // encode
283 std::vector<unsigned char> encoded;
284 ASSERT_TRUE(PNGCodec::Encode(&original[0], PNGCodec::FORMAT_RGB,
285 Size(w, h), w * 3, false,
286 std::vector<PNGCodec::Comment>(),
287 &encoded));
288
289 // decode, it should have the same size as the original
290 std::vector<unsigned char> decoded;
291 int outw, outh;
292 ASSERT_TRUE(PNGCodec::Decode(&encoded[0], encoded.size(),
293 PNGCodec::FORMAT_RGB, &decoded,
294 &outw, &outh));
295 ASSERT_EQ(w, outw);
296 ASSERT_EQ(h, outh);
297 ASSERT_EQ(original.size(), decoded.size());
298
299 // Images must be equal
300 ASSERT_TRUE(original == decoded);
301 }
302
303 TEST(PNGCodec, EncodeDecodeRGBA) {
304 const int w = 20, h = 20;
305
306 // create an image with known values, a must be opaque because it will be
307 // lost during encoding
308 std::vector<unsigned char> original;
309 MakeRGBAImage(w, h, true, &original);
310
311 // encode
312 std::vector<unsigned char> encoded;
313 ASSERT_TRUE(PNGCodec::Encode(&original[0], PNGCodec::FORMAT_RGBA,
314 Size(w, h), w * 4, false,
315 std::vector<PNGCodec::Comment>(),
316 &encoded));
317
318 // decode, it should have the same size as the original
319 std::vector<unsigned char> decoded;
320 int outw, outh;
321 ASSERT_TRUE(PNGCodec::Decode(&encoded[0], encoded.size(),
322 PNGCodec::FORMAT_RGBA, &decoded,
323 &outw, &outh));
324 ASSERT_EQ(w, outw);
325 ASSERT_EQ(h, outh);
326 ASSERT_EQ(original.size(), decoded.size());
327
328 // Images must be exactly equal
329 ASSERT_TRUE(original == decoded);
330 }
331
332 TEST(PNGCodec, EncodeDecodeBGRA) {
333 const int w = 20, h = 20;
334
335 // Create an image with known values, alpha must be opaque because it will be
336 // lost during encoding.
337 std::vector<unsigned char> original;
338 MakeRGBAImage(w, h, true, &original);
339
340 // Encode.
341 std::vector<unsigned char> encoded;
342 ASSERT_TRUE(PNGCodec::Encode(&original[0], PNGCodec::FORMAT_BGRA,
343 Size(w, h), w * 4, false,
344 std::vector<PNGCodec::Comment>(),
345 &encoded));
346
347 // Decode, it should have the same size as the original.
348 std::vector<unsigned char> decoded;
349 int outw, outh;
350 ASSERT_TRUE(PNGCodec::Decode(&encoded[0], encoded.size(),
351 PNGCodec::FORMAT_BGRA, &decoded,
352 &outw, &outh));
353 ASSERT_EQ(w, outw);
354 ASSERT_EQ(h, outh);
355 ASSERT_EQ(original.size(), decoded.size());
356
357 // Images must be exactly equal.
358 ASSERT_TRUE(original == decoded);
359 }
360
361 TEST(PNGCodec, DecodePalette) {
362 const int w = 20, h = 20;
363
364 // create an image with known values
365 std::vector<unsigned char> original;
366 std::vector<png_color> original_palette;
367 std::vector<unsigned char> original_trans_chunk;
368 MakePaletteImage(w, h, &original, &original_palette, &original_trans_chunk);
369
370 // encode
371 std::vector<unsigned char> encoded;
372 ASSERT_TRUE(EncodeImage(original,
373 w, h,
374 COLOR_TYPE_PALETTE,
375 &encoded,
376 PNG_INTERLACE_NONE,
377 &original_palette,
378 &original_trans_chunk));
379
380 // decode
381 std::vector<unsigned char> decoded;
382 int outw, outh;
383 ASSERT_TRUE(PNGCodec::Decode(&encoded[0], encoded.size(),
384 PNGCodec::FORMAT_RGBA, &decoded,
385 &outw, &outh));
386 ASSERT_EQ(w, outw);
387 ASSERT_EQ(h, outh);
388 ASSERT_EQ(decoded.size(), w * h * 4U);
389
390 // Images must be equal
391 for (int y = 0; y < h; ++y) {
392 for (int x = 0; x < w; ++x) {
393 unsigned char palette_pixel = original[y * w + x];
394 png_color& palette_color = original_palette[palette_pixel];
395 int alpha = original_trans_chunk[palette_pixel];
396 unsigned char* rgba_pixel = &decoded[(y * w + x) * 4];
397
398 EXPECT_EQ(palette_color.red, rgba_pixel[0]);
399 EXPECT_EQ(palette_color.green, rgba_pixel[1]);
400 EXPECT_EQ(palette_color.blue, rgba_pixel[2]);
401 EXPECT_EQ(alpha, rgba_pixel[3]);
402 }
403 }
404 }
405
406 TEST(PNGCodec, DecodePaletteDiscardAlpha) {
407 const int w = 20, h = 20;
408
409 // create an image with known values
410 std::vector<unsigned char> original;
411 std::vector<png_color> original_palette;
412 std::vector<unsigned char> original_trans_chunk;
413 MakePaletteImage(w, h, &original, &original_palette, &original_trans_chunk);
414
415 // encode
416 std::vector<unsigned char> encoded;
417 ASSERT_TRUE(EncodeImage(original,
418 w, h,
419 COLOR_TYPE_PALETTE,
420 &encoded,
421 PNG_INTERLACE_NONE,
422 &original_palette,
423 &original_trans_chunk));
424
425 // decode
426 std::vector<unsigned char> decoded;
427 int outw, outh;
428 ASSERT_TRUE(PNGCodec::Decode(&encoded[0], encoded.size(),
429 PNGCodec::FORMAT_RGB, &decoded,
430 &outw, &outh));
431 ASSERT_EQ(w, outw);
432 ASSERT_EQ(h, outh);
433 ASSERT_EQ(decoded.size(), w * h * 3U);
434
435 // Images must be equal
436 for (int y = 0; y < h; ++y) {
437 for (int x = 0; x < w; ++x) {
438 unsigned char palette_pixel = original[y * w + x];
439 png_color& palette_color = original_palette[palette_pixel];
440 unsigned char* rgba_pixel = &decoded[(y * w + x) * 3];
441
442 EXPECT_EQ(palette_color.red, rgba_pixel[0]);
443 EXPECT_EQ(palette_color.green, rgba_pixel[1]);
444 EXPECT_EQ(palette_color.blue, rgba_pixel[2]);
445 }
446 }
447 }
448
449 TEST(PNGCodec, DecodeInterlacedPalette) {
450 const int w = 20, h = 20;
451
452 // create an image with known values
453 std::vector<unsigned char> original;
454 std::vector<png_color> original_palette;
455 std::vector<unsigned char> original_trans_chunk;
456 MakePaletteImage(w, h, &original, &original_palette, &original_trans_chunk);
457
458 // encode
459 std::vector<unsigned char> encoded;
460 ASSERT_TRUE(EncodeImage(original,
461 w, h,
462 COLOR_TYPE_PALETTE,
463 &encoded,
464 PNG_INTERLACE_ADAM7,
465 &original_palette,
466 &original_trans_chunk));
467
468 // decode
469 std::vector<unsigned char> decoded;
470 int outw, outh;
471 ASSERT_TRUE(PNGCodec::Decode(&encoded[0], encoded.size(),
472 PNGCodec::FORMAT_RGBA, &decoded,
473 &outw, &outh));
474 ASSERT_EQ(w, outw);
475 ASSERT_EQ(h, outh);
476 ASSERT_EQ(decoded.size(), w * h * 4U);
477
478 // Images must be equal
479 for (int y = 0; y < h; ++y) {
480 for (int x = 0; x < w; ++x) {
481 unsigned char palette_pixel = original[y * w + x];
482 png_color& palette_color = original_palette[palette_pixel];
483 int alpha = original_trans_chunk[palette_pixel];
484 unsigned char* rgba_pixel = &decoded[(y * w + x) * 4];
485
486 EXPECT_EQ(palette_color.red, rgba_pixel[0]);
487 EXPECT_EQ(palette_color.green, rgba_pixel[1]);
488 EXPECT_EQ(palette_color.blue, rgba_pixel[2]);
489 EXPECT_EQ(alpha, rgba_pixel[3]);
490 }
491 }
492 }
493
494 TEST(PNGCodec, DecodeGrayscale) {
495 const int w = 20, h = 20;
496
497 // create an image with known values
498 std::vector<unsigned char> original;
499 MakeGrayscaleImage(w, h, &original);
500
501 // encode
502 std::vector<unsigned char> encoded;
503 ASSERT_TRUE(EncodeImage(original, w, h, COLOR_TYPE_GRAY, &encoded));
504
505 // decode
506 std::vector<unsigned char> decoded;
507 int outw, outh;
508 ASSERT_TRUE(PNGCodec::Decode(&encoded[0], encoded.size(),
509 PNGCodec::FORMAT_RGB, &decoded,
510 &outw, &outh));
511 ASSERT_EQ(w, outw);
512 ASSERT_EQ(h, outh);
513 ASSERT_EQ(decoded.size(), original.size() * 3);
514
515 // Images must be equal
516 for (int y = 0; y < h; ++y) {
517 for (int x = 0; x < w; ++x) {
518 unsigned char gray_pixel = original[(y * w + x)];
519 unsigned char* rgba_pixel = &decoded[(y * w + x) * 3];
520 EXPECT_EQ(rgba_pixel[0], gray_pixel);
521 EXPECT_EQ(rgba_pixel[1], gray_pixel);
522 EXPECT_EQ(rgba_pixel[2], gray_pixel);
523 }
524 }
525 }
526
527 TEST(PNGCodec, DecodeGrayscaleWithAlpha) {
528 const int w = 20, h = 20;
529
530 // create an image with known values
531 std::vector<unsigned char> original;
532 MakeGrayscaleAlphaImage(w, h, &original);
533
534 // encode
535 std::vector<unsigned char> encoded;
536 ASSERT_TRUE(EncodeImage(original,
537 w, h,
538 COLOR_TYPE_GRAY_ALPHA,
539 &encoded));
540
541 // decode
542 std::vector<unsigned char> decoded;
543 int outw, outh;
544 ASSERT_TRUE(PNGCodec::Decode(&encoded[0], encoded.size(),
545 PNGCodec::FORMAT_RGBA, &decoded,
546 &outw, &outh));
547 ASSERT_EQ(w, outw);
548 ASSERT_EQ(h, outh);
549 ASSERT_EQ(decoded.size(), original.size() * 2);
550
551 // Images must be equal
552 for (int y = 0; y < h; ++y) {
553 for (int x = 0; x < w; ++x) {
554 unsigned char* gray_pixel = &original[(y * w + x) * 2];
555 unsigned char* rgba_pixel = &decoded[(y * w + x) * 4];
556 EXPECT_EQ(rgba_pixel[0], gray_pixel[0]);
557 EXPECT_EQ(rgba_pixel[1], gray_pixel[0]);
558 EXPECT_EQ(rgba_pixel[2], gray_pixel[0]);
559 EXPECT_EQ(rgba_pixel[3], gray_pixel[1]);
560 }
561 }
562 }
563
564 TEST(PNGCodec, DecodeGrayscaleWithAlphaDiscardAlpha) {
565 const int w = 20, h = 20;
566
567 // create an image with known values
568 std::vector<unsigned char> original;
569 MakeGrayscaleAlphaImage(w, h, &original);
570
571 // encode
572 std::vector<unsigned char> encoded;
573 ASSERT_TRUE(EncodeImage(original,
574 w, h,
575 COLOR_TYPE_GRAY_ALPHA,
576 &encoded));
577
578 // decode
579 std::vector<unsigned char> decoded;
580 int outw, outh;
581 ASSERT_TRUE(PNGCodec::Decode(&encoded[0], encoded.size(),
582 PNGCodec::FORMAT_RGB, &decoded,
583 &outw, &outh));
584 ASSERT_EQ(w, outw);
585 ASSERT_EQ(h, outh);
586 ASSERT_EQ(decoded.size(), w * h * 3U);
587
588 // Images must be equal
589 for (int y = 0; y < h; ++y) {
590 for (int x = 0; x < w; ++x) {
591 unsigned char* gray_pixel = &original[(y * w + x) * 2];
592 unsigned char* rgba_pixel = &decoded[(y * w + x) * 3];
593 EXPECT_EQ(rgba_pixel[0], gray_pixel[0]);
594 EXPECT_EQ(rgba_pixel[1], gray_pixel[0]);
595 EXPECT_EQ(rgba_pixel[2], gray_pixel[0]);
596 }
597 }
598 }
599
600 TEST(PNGCodec, DecodeInterlacedGrayscale) {
601 const int w = 20, h = 20;
602
603 // create an image with known values
604 std::vector<unsigned char> original;
605 MakeGrayscaleImage(w, h, &original);
606
607 // encode
608 std::vector<unsigned char> encoded;
609 ASSERT_TRUE(EncodeImage(original,
610 w, h,
611 COLOR_TYPE_GRAY,
612 &encoded,
613 PNG_INTERLACE_ADAM7));
614
615 // decode
616 std::vector<unsigned char> decoded;
617 int outw, outh;
618 ASSERT_TRUE(PNGCodec::Decode(&encoded[0], encoded.size(),
619 PNGCodec::FORMAT_RGBA, &decoded,
620 &outw, &outh));
621 ASSERT_EQ(w, outw);
622 ASSERT_EQ(h, outh);
623 ASSERT_EQ(decoded.size(), original.size() * 4);
624
625 // Images must be equal
626 for (int y = 0; y < h; ++y) {
627 for (int x = 0; x < w; ++x) {
628 unsigned char gray_pixel = original[(y * w + x)];
629 unsigned char* rgba_pixel = &decoded[(y * w + x) * 4];
630 EXPECT_EQ(rgba_pixel[0], gray_pixel);
631 EXPECT_EQ(rgba_pixel[1], gray_pixel);
632 EXPECT_EQ(rgba_pixel[2], gray_pixel);
633 EXPECT_EQ(rgba_pixel[3], 0xFF);
634 }
635 }
636 }
637
638 TEST(PNGCodec, DecodeInterlacedGrayscaleWithAlpha) {
639 const int w = 20, h = 20;
640
641 // create an image with known values
642 std::vector<unsigned char> original;
643 MakeGrayscaleAlphaImage(w, h, &original);
644
645 // encode
646 std::vector<unsigned char> encoded;
647 ASSERT_TRUE(EncodeImage(original,
648 w, h,
649 COLOR_TYPE_GRAY_ALPHA,
650 &encoded,
651 PNG_INTERLACE_ADAM7));
652
653 // decode
654 std::vector<unsigned char> decoded;
655 int outw, outh;
656 ASSERT_TRUE(PNGCodec::Decode(&encoded[0], encoded.size(),
657 PNGCodec::FORMAT_RGBA, &decoded,
658 &outw, &outh));
659 ASSERT_EQ(w, outw);
660 ASSERT_EQ(h, outh);
661 ASSERT_EQ(decoded.size(), original.size() * 2);
662
663 // Images must be equal
664 for (int y = 0; y < h; ++y) {
665 for (int x = 0; x < w; ++x) {
666 unsigned char* gray_pixel = &original[(y * w + x) * 2];
667 unsigned char* rgba_pixel = &decoded[(y * w + x) * 4];
668 EXPECT_EQ(rgba_pixel[0], gray_pixel[0]);
669 EXPECT_EQ(rgba_pixel[1], gray_pixel[0]);
670 EXPECT_EQ(rgba_pixel[2], gray_pixel[0]);
671 EXPECT_EQ(rgba_pixel[3], gray_pixel[1]);
672 }
673 }
674 }
675
676 TEST(PNGCodec, DecodeInterlacedRGB) {
677 const int w = 20, h = 20;
678
679 // create an image with known values
680 std::vector<unsigned char> original;
681 MakeRGBImage(w, h, &original);
682
683 // encode
684 std::vector<unsigned char> encoded;
685 ASSERT_TRUE(EncodeImage(original,
686 w, h,
687 COLOR_TYPE_RGB,
688 &encoded,
689 PNG_INTERLACE_ADAM7));
690
691 // decode, it should have the same size as the original
692 std::vector<unsigned char> decoded;
693 int outw, outh;
694 ASSERT_TRUE(PNGCodec::Decode(&encoded[0], encoded.size(),
695 PNGCodec::FORMAT_RGB, &decoded,
696 &outw, &outh));
697 ASSERT_EQ(w, outw);
698 ASSERT_EQ(h, outh);
699 ASSERT_EQ(original.size(), decoded.size());
700
701 // Images must be equal
702 ASSERT_EQ(original, decoded);
703 }
704
705 TEST(PNGCodec, DecodeInterlacedRGBA) {
706 const int w = 20, h = 20;
707
708 // create an image with known values
709 std::vector<unsigned char> original;
710 MakeRGBAImage(w, h, false, &original);
711
712 // encode
713 std::vector<unsigned char> encoded;
714 ASSERT_TRUE(EncodeImage(original,
715 w, h,
716 COLOR_TYPE_RGBA,
717 &encoded,
718 PNG_INTERLACE_ADAM7));
719
720 // decode, it should have the same size as the original
721 std::vector<unsigned char> decoded;
722 int outw, outh;
723 ASSERT_TRUE(PNGCodec::Decode(&encoded[0], encoded.size(),
724 PNGCodec::FORMAT_RGBA, &decoded,
725 &outw, &outh));
726 ASSERT_EQ(w, outw);
727 ASSERT_EQ(h, outh);
728 ASSERT_EQ(original.size(), decoded.size());
729
730 // Images must be equal
731 ASSERT_EQ(original, decoded);
732 }
733
734 TEST(PNGCodec, DecodeInterlacedRGBADiscardAlpha) {
735 const int w = 20, h = 20;
736
737 // create an image with known values
738 std::vector<unsigned char> original;
739 MakeRGBAImage(w, h, false, &original);
740
741 // encode
742 std::vector<unsigned char> encoded;
743 ASSERT_TRUE(EncodeImage(original,
744 w, h,
745 COLOR_TYPE_RGBA,
746 &encoded,
747 PNG_INTERLACE_ADAM7));
748
749 // decode
750 std::vector<unsigned char> decoded;
751 int outw, outh;
752 ASSERT_TRUE(PNGCodec::Decode(&encoded[0], encoded.size(),
753 PNGCodec::FORMAT_RGB, &decoded,
754 &outw, &outh));
755 ASSERT_EQ(w, outw);
756 ASSERT_EQ(h, outh);
757 ASSERT_EQ(decoded.size(), w * h * 3U);
758
759 // Images must be equal
760 for (int x = 0; x < w; x++) {
761 for (int y = 0; y < h; y++) {
762 unsigned char* orig_px = &original[(y * w + x) * 4];
763 unsigned char* dec_px = &decoded[(y * w + x) * 3];
764 EXPECT_EQ(dec_px[0], orig_px[0]);
765 EXPECT_EQ(dec_px[1], orig_px[1]);
766 EXPECT_EQ(dec_px[2], orig_px[2]);
767 }
768 }
769 }
770
771 TEST(PNGCodec, DecodeInterlacedBGR) {
772 const int w = 20, h = 20;
773
774 // create an image with known values
775 std::vector<unsigned char> original;
776 MakeRGBImage(w, h, &original);
777
778 // encode
779 std::vector<unsigned char> encoded;
780 ASSERT_TRUE(EncodeImage(original,
781 w, h,
782 COLOR_TYPE_BGR,
783 &encoded,
784 PNG_INTERLACE_ADAM7));
785
786 // decode, it should have the same size as the original
787 std::vector<unsigned char> decoded;
788 int outw, outh;
789 ASSERT_TRUE(PNGCodec::Decode(&encoded[0], encoded.size(),
790 PNGCodec::FORMAT_BGRA, &decoded,
791 &outw, &outh));
792 ASSERT_EQ(w, outw);
793 ASSERT_EQ(h, outh);
794 ASSERT_EQ(decoded.size(), w * h * 4U);
795
796 // Images must be equal
797 for (int x = 0; x < w; x++) {
798 for (int y = 0; y < h; y++) {
799 unsigned char* orig_px = &original[(y * w + x) * 3];
800 unsigned char* dec_px = &decoded[(y * w + x) * 4];
801 EXPECT_EQ(dec_px[0], orig_px[0]);
802 EXPECT_EQ(dec_px[1], orig_px[1]);
803 EXPECT_EQ(dec_px[2], orig_px[2]);
804 }
805 }
806 }
807
808 TEST(PNGCodec, DecodeInterlacedBGRA) {
809 const int w = 20, h = 20;
810
811 // create an image with known values
812 std::vector<unsigned char> original;
813 MakeRGBAImage(w, h, false, &original);
814
815 // encode
816 std::vector<unsigned char> encoded;
817 ASSERT_TRUE(EncodeImage(original,
818 w, h,
819 COLOR_TYPE_BGRA,
820 &encoded,
821 PNG_INTERLACE_ADAM7));
822
823 // decode, it should have the same size as the original
824 std::vector<unsigned char> decoded;
825 int outw, outh;
826 ASSERT_TRUE(PNGCodec::Decode(&encoded[0], encoded.size(),
827 PNGCodec::FORMAT_BGRA, &decoded,
828 &outw, &outh));
829 ASSERT_EQ(w, outw);
830 ASSERT_EQ(h, outh);
831 ASSERT_EQ(original.size(), decoded.size());
832
833 // Images must be equal
834 ASSERT_EQ(original, decoded);
835 }
836
837 // Not encoding an interlaced PNG from SkBitmap because we don't do it
838 // anywhere, and the ability to do that requires more code changes.
839 TEST(PNGCodec, DecodeInterlacedRGBtoSkBitmap) {
840 const int w = 20, h = 20;
841
842 // create an image with known values
843 std::vector<unsigned char> original;
844 MakeRGBImage(w, h, &original);
845
846 // encode
847 std::vector<unsigned char> encoded;
848 ASSERT_TRUE(EncodeImage(original,
849 w, h,
850 COLOR_TYPE_RGB,
851 &encoded,
852 PNG_INTERLACE_ADAM7));
853
854 // Decode the encoded string.
855 SkBitmap decoded_bitmap;
856 ASSERT_TRUE(PNGCodec::Decode(&encoded.front(), encoded.size(),
857 &decoded_bitmap));
858
859 for (int x = 0; x < w; x++) {
860 for (int y = 0; y < h; y++) {
861 const unsigned char* original_pixel = &original[(y * w + x) * 3];
862 const uint32_t original_pixel_sk = SkPackARGB32(0xFF,
863 original_pixel[0],
864 original_pixel[1],
865 original_pixel[2]);
866 const uint32_t decoded_pixel = decoded_bitmap.getAddr32(0, y)[x];
867 EXPECT_EQ(original_pixel_sk, decoded_pixel);
868 }
869 }
870 }
871
872 TEST(PNGCodec, DecodeInterlacedRGBAtoSkBitmap) {
873 const int w = 20, h = 20;
874
875 // create an image with known values
876 std::vector<unsigned char> original;
877 MakeRGBAImage(w, h, false, &original);
878
879 // encode
880 std::vector<unsigned char> encoded;
881 ASSERT_TRUE(EncodeImage(original,
882 w, h,
883 COLOR_TYPE_RGBA,
884 &encoded,
885 PNG_INTERLACE_ADAM7));
886
887 // Decode the encoded string.
888 SkBitmap decoded_bitmap;
889 ASSERT_TRUE(PNGCodec::Decode(&encoded.front(), encoded.size(),
890 &decoded_bitmap));
891
892 for (int x = 0; x < w; x++) {
893 for (int y = 0; y < h; y++) {
894 const unsigned char* original_pixel = &original[(y * w + x) * 4];
895 const uint32_t original_pixel_sk = SkPackARGB32(original_pixel[3],
896 original_pixel[0],
897 original_pixel[1],
898 original_pixel[2]);
899 const uint32_t decoded_pixel = decoded_bitmap.getAddr32(0, y)[x];
900 EXPECT_EQ(original_pixel_sk, decoded_pixel);
901 }
902 }
903 }
904
905 // Test that corrupted data decompression causes failures.
906 TEST(PNGCodec, DecodeCorrupted) {
907 int w = 20, h = 20;
908
909 // Make some random data (an uncompressed image).
910 std::vector<unsigned char> original;
911 MakeRGBImage(w, h, &original);
912
913 // It should fail when given non-JPEG compressed data.
914 std::vector<unsigned char> output;
915 int outw, outh;
916 EXPECT_FALSE(PNGCodec::Decode(&original[0], original.size(),
917 PNGCodec::FORMAT_RGB, &output,
918 &outw, &outh));
919
920 // Make some compressed data.
921 std::vector<unsigned char> compressed;
922 ASSERT_TRUE(PNGCodec::Encode(&original[0], PNGCodec::FORMAT_RGB,
923 Size(w, h), w * 3, false,
924 std::vector<PNGCodec::Comment>(),
925 &compressed));
926
927 // Try decompressing a truncated version.
928 EXPECT_FALSE(PNGCodec::Decode(&compressed[0], compressed.size() / 2,
929 PNGCodec::FORMAT_RGB, &output,
930 &outw, &outh));
931
932 // Corrupt it and try decompressing that.
933 for (int i = 10; i < 30; i++)
934 compressed[i] = i;
935 EXPECT_FALSE(PNGCodec::Decode(&compressed[0], compressed.size(),
936 PNGCodec::FORMAT_RGB, &output,
937 &outw, &outh));
938 }
939
940 TEST(PNGCodec, StripAddAlpha) {
941 const int w = 20, h = 20;
942
943 // These should be the same except one has a 0xff alpha channel.
944 std::vector<unsigned char> original_rgb;
945 MakeRGBImage(w, h, &original_rgb);
946 std::vector<unsigned char> original_rgba;
947 MakeRGBAImage(w, h, false, &original_rgba);
948
949 // Encode RGBA data as RGB.
950 std::vector<unsigned char> encoded;
951 EXPECT_TRUE(PNGCodec::Encode(&original_rgba[0], PNGCodec::FORMAT_RGBA,
952 Size(w, h), w * 4, true,
953 std::vector<PNGCodec::Comment>(),
954 &encoded));
955
956 // Decode the RGB to RGBA.
957 std::vector<unsigned char> decoded;
958 int outw, outh;
959 EXPECT_TRUE(PNGCodec::Decode(&encoded[0], encoded.size(),
960 PNGCodec::FORMAT_RGBA, &decoded,
961 &outw, &outh));
962
963 // Decoded and reference should be the same (opaque alpha).
964 ASSERT_EQ(w, outw);
965 ASSERT_EQ(h, outh);
966 ASSERT_EQ(original_rgba.size(), decoded.size());
967 ASSERT_EQ(original_rgba, decoded);
968
969 // Encode RGBA to RGBA.
970 EXPECT_TRUE(PNGCodec::Encode(&original_rgba[0], PNGCodec::FORMAT_RGBA,
971 Size(w, h), w * 4, false,
972 std::vector<PNGCodec::Comment>(),
973 &encoded));
974
975 // Decode the RGBA to RGB.
976 EXPECT_TRUE(PNGCodec::Decode(&encoded[0], encoded.size(),
977 PNGCodec::FORMAT_RGB, &decoded,
978 &outw, &outh));
979
980 // It should be the same as our non-alpha-channel reference.
981 ASSERT_EQ(w, outw);
982 ASSERT_EQ(h, outh);
983 ASSERT_EQ(original_rgb.size(), decoded.size());
984 ASSERT_EQ(original_rgb, decoded);
985 }
986
987 TEST(PNGCodec, EncodeBGRASkBitmapStridePadded) {
988 const int kWidth = 20;
989 const int kHeight = 20;
990 const int kPaddedWidth = 32;
991 const int kBytesPerPixel = 4;
992 const int kPaddedSize = kPaddedWidth * kHeight;
993 const int kRowBytes = kPaddedWidth * kBytesPerPixel;
994
995 SkImageInfo info = SkImageInfo::MakeN32Premul(kWidth, kHeight);
996 SkBitmap original_bitmap;
997 original_bitmap.setInfo(info, kRowBytes);
998 original_bitmap.allocPixels();
999
1000 // Write data over the source bitmap.
1001 // We write on the pad area here too.
1002 // The encoder should ignore the pad area.
1003 uint32_t* src_data = original_bitmap.getAddr32(0, 0);
1004 for (int i = 0; i < kPaddedSize; i++) {
1005 src_data[i] = SkPreMultiplyARGB(i % 255, i % 250, i % 245, i % 240);
1006 }
1007
1008 // Encode the bitmap.
1009 std::vector<unsigned char> encoded;
1010 PNGCodec::EncodeBGRASkBitmap(original_bitmap, false, &encoded);
1011
1012 // Decode the encoded string.
1013 SkBitmap decoded_bitmap;
1014 EXPECT_TRUE(PNGCodec::Decode(&encoded.front(), encoded.size(),
1015 &decoded_bitmap));
1016
1017 // Compare the original bitmap and the output bitmap. We use ColorsClose
1018 // as SkBitmaps are considered to be pre-multiplied, the unpremultiplication
1019 // (in Encode) and repremultiplication (in Decode) can be lossy.
1020 for (int x = 0; x < kWidth; x++) {
1021 for (int y = 0; y < kHeight; y++) {
1022 uint32_t original_pixel = original_bitmap.getAddr32(0, y)[x];
1023 uint32_t decoded_pixel = decoded_bitmap.getAddr32(0, y)[x];
1024 EXPECT_TRUE(ColorsClose(original_pixel, decoded_pixel));
1025 }
1026 }
1027 }
1028
1029 TEST(PNGCodec, EncodeBGRASkBitmap) {
1030 const int w = 20, h = 20;
1031
1032 SkBitmap original_bitmap;
1033 MakeTestBGRASkBitmap(w, h, &original_bitmap);
1034
1035 // Encode the bitmap.
1036 std::vector<unsigned char> encoded;
1037 PNGCodec::EncodeBGRASkBitmap(original_bitmap, false, &encoded);
1038
1039 // Decode the encoded string.
1040 SkBitmap decoded_bitmap;
1041 EXPECT_TRUE(PNGCodec::Decode(&encoded.front(), encoded.size(),
1042 &decoded_bitmap));
1043
1044 // Compare the original bitmap and the output bitmap. We use ColorsClose
1045 // as SkBitmaps are considered to be pre-multiplied, the unpremultiplication
1046 // (in Encode) and repremultiplication (in Decode) can be lossy.
1047 for (int x = 0; x < w; x++) {
1048 for (int y = 0; y < h; y++) {
1049 uint32_t original_pixel = original_bitmap.getAddr32(0, y)[x];
1050 uint32_t decoded_pixel = decoded_bitmap.getAddr32(0, y)[x];
1051 EXPECT_TRUE(ColorsClose(original_pixel, decoded_pixel));
1052 }
1053 }
1054 }
1055
1056 TEST(PNGCodec, EncodeA8SkBitmap) {
1057 const int w = 20, h = 20;
1058
1059 SkBitmap original_bitmap;
1060 MakeTestA8SkBitmap(w, h, &original_bitmap);
1061
1062 // Encode the bitmap.
1063 std::vector<unsigned char> encoded;
1064 EXPECT_TRUE(PNGCodec::EncodeA8SkBitmap(original_bitmap, &encoded));
1065
1066 // Decode the encoded string.
1067 SkBitmap decoded_bitmap;
1068 EXPECT_TRUE(PNGCodec::Decode(&encoded.front(), encoded.size(),
1069 &decoded_bitmap));
1070
1071 for (int x = 0; x < w; x++) {
1072 for (int y = 0; y < h; y++) {
1073 uint8_t original_pixel = *original_bitmap.getAddr8(x, y);
1074 uint32_t decoded_pixel = *decoded_bitmap.getAddr32(x, y);
1075 EXPECT_TRUE(BGRAGrayEqualsA8Gray(decoded_pixel, original_pixel));
1076 }
1077 }
1078 }
1079
1080 TEST(PNGCodec, EncodeBGRASkBitmapDiscardTransparency) {
1081 const int w = 20, h = 20;
1082
1083 SkBitmap original_bitmap;
1084 MakeTestBGRASkBitmap(w, h, &original_bitmap);
1085
1086 // Encode the bitmap.
1087 std::vector<unsigned char> encoded;
1088 PNGCodec::EncodeBGRASkBitmap(original_bitmap, true, &encoded);
1089
1090 // Decode the encoded string.
1091 SkBitmap decoded_bitmap;
1092 EXPECT_TRUE(PNGCodec::Decode(&encoded.front(), encoded.size(),
1093 &decoded_bitmap));
1094
1095 // Compare the original bitmap and the output bitmap. We need to
1096 // unpremultiply original_pixel, as the decoded bitmap doesn't have an alpha
1097 // channel.
1098 for (int x = 0; x < w; x++) {
1099 for (int y = 0; y < h; y++) {
1100 uint32_t original_pixel = original_bitmap.getAddr32(0, y)[x];
1101 uint32_t unpremultiplied =
1102 SkUnPreMultiply::PMColorToColor(original_pixel);
1103 uint32_t decoded_pixel = decoded_bitmap.getAddr32(0, y)[x];
1104 uint32_t unpremultiplied_decoded =
1105 SkUnPreMultiply::PMColorToColor(decoded_pixel);
1106
1107 EXPECT_TRUE(NonAlphaColorsClose(unpremultiplied, unpremultiplied_decoded))
1108 << "Original_pixel: ("
1109 << SkColorGetR(unpremultiplied) << ", "
1110 << SkColorGetG(unpremultiplied) << ", "
1111 << SkColorGetB(unpremultiplied) << "), "
1112 << "Decoded pixel: ("
1113 << SkColorGetR(unpremultiplied_decoded) << ", "
1114 << SkColorGetG(unpremultiplied_decoded) << ", "
1115 << SkColorGetB(unpremultiplied_decoded) << ")";
1116 }
1117 }
1118 }
1119
1120 TEST(PNGCodec, EncodeWithComment) {
1121 const int w = 10, h = 10;
1122
1123 std::vector<unsigned char> original;
1124 MakeRGBImage(w, h, &original);
1125
1126 std::vector<unsigned char> encoded;
1127 std::vector<PNGCodec::Comment> comments;
1128 comments.push_back(PNGCodec::Comment("key", "text"));
1129 comments.push_back(PNGCodec::Comment("test", "something"));
1130 comments.push_back(PNGCodec::Comment("have some", "spaces in both"));
1131 EXPECT_TRUE(PNGCodec::Encode(&original[0], PNGCodec::FORMAT_RGB,
1132 Size(w, h), w * 3, false, comments, &encoded));
1133
1134 // Each chunk is of the form length (4 bytes), chunk type (tEXt), data,
1135 // checksum (4 bytes). Make sure we find all of them in the encoded
1136 // results.
1137 const unsigned char kExpected1[] =
1138 "\x00\x00\x00\x08tEXtkey\x00text\x9e\xe7\x66\x51";
1139 const unsigned char kExpected2[] =
1140 "\x00\x00\x00\x0etEXttest\x00something\x29\xba\xef\xac";
1141 const unsigned char kExpected3[] =
1142 "\x00\x00\x00\x18tEXthave some\x00spaces in both\x8d\x69\x34\x2d";
1143
1144 EXPECT_NE(std::search(encoded.begin(), encoded.end(), kExpected1,
1145 kExpected1 + arraysize(kExpected1)),
1146 encoded.end());
1147 EXPECT_NE(std::search(encoded.begin(), encoded.end(), kExpected2,
1148 kExpected2 + arraysize(kExpected2)),
1149 encoded.end());
1150 EXPECT_NE(std::search(encoded.begin(), encoded.end(), kExpected3,
1151 kExpected3 + arraysize(kExpected3)),
1152 encoded.end());
1153 }
1154
1155 TEST(PNGCodec, EncodeDecodeWithVaryingCompressionLevels) {
1156 const int w = 20, h = 20;
1157
1158 // create an image with known values, a must be opaque because it will be
1159 // lost during encoding
1160 SkBitmap original_bitmap;
1161 MakeTestBGRASkBitmap(w, h, &original_bitmap);
1162
1163 // encode
1164 std::vector<unsigned char> encoded_normal;
1165 EXPECT_TRUE(
1166 PNGCodec::EncodeBGRASkBitmap(original_bitmap, false, &encoded_normal));
1167
1168 std::vector<unsigned char> encoded_fast;
1169 EXPECT_TRUE(
1170 PNGCodec::FastEncodeBGRASkBitmap(original_bitmap, false, &encoded_fast));
1171
1172 // Make sure the different compression settings actually do something; the
1173 // sizes should be different.
1174 EXPECT_NE(encoded_normal.size(), encoded_fast.size());
1175
1176 // decode, they should be identical to the original.
1177 SkBitmap decoded;
1178 EXPECT_TRUE(
1179 PNGCodec::Decode(&encoded_normal[0], encoded_normal.size(), &decoded));
1180 EXPECT_TRUE(BitmapsAreEqual(decoded, original_bitmap));
1181
1182 EXPECT_TRUE(
1183 PNGCodec::Decode(&encoded_fast[0], encoded_fast.size(), &decoded));
1184 EXPECT_TRUE(BitmapsAreEqual(decoded, original_bitmap));
1185 }
1186
1187
1188 } // namespace gfx