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/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 1189
