Home | History | Annotate | Download | only in tests 
      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 }
    135