src/third_party/skia/tests/PremulAlphaRoundTripTest.cpp

   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
  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
  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
  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     const SkImageInfo info = SkImageInfo::Make(bmp.width(), bmp.height(),
  62                                                colorType, kUnpremul_SkAlphaType);
  63     canvas->writePixels(info, bmp.getPixels(), bmp.rowBytes(), 0, 0);
  64 }
  65
  66 DEF_GPUTEST(PremulAlphaRoundTrip, reporter, factory) {
  67     const SkImageInfo info = SkImageInfo::MakeN32Premul(256, 256);
  68
  69     for (int dtype = 0; dtype < 2; ++dtype) {
  70
  71         int glCtxTypeCnt = 1;
  72 #if SK_SUPPORT_GPU
  73         if (0 != dtype)  {
  74             glCtxTypeCnt = GrContextFactory::kGLContextTypeCnt;
  75         }
  76 #endif
  77         for (int glCtxType = 0; glCtxType < glCtxTypeCnt; ++glCtxType) {
  78             SkAutoTUnref<SkBaseDevice> device;
  79             if (0 == dtype) {
  80                 device.reset(SkBitmapDevice::Create(info));
  81             } else {
  82 #if SK_SUPPORT_GPU
  83                 GrContextFactory::GLContextType type =
  84                     static_cast<GrContextFactory::GLContextType>(glCtxType);
  85                 if (!GrContextFactory::IsRenderingGLContext(type)) {
  86                     continue;
  87                 }
  88                 GrContext* context = factory->get(type);
  89                 if (NULL == context) {
  90                     continue;
  91                 }
  92
  93                 device.reset(SkGpuDevice::Create(context, info,
  94                                      SkSurfaceProps(SkSurfaceProps::kLegacyFontHost_InitType), 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                         // We see sporadic failures here. May help to see where it goes wrong.
 125                         if (pixels1[x] != pixels2[x]) {
 126                             SkDebugf("%x != %x, x = %d, y = %d\n", pixels1[x], pixels2[x], x, y);
 127                         }
 128                         REPORTER_ASSERT(reporter, success = pixels1[x] == pixels2[x]);
 129                     }
 130                 }
 131             }
 132         }
 133     }
 134 }