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 "SkCanvas.h"
9#include "SkSurface.h"
10#include "Test.h"
11#include "sk_tool_utils.h"
12
13#if SK_SUPPORT_GPU
14#include "GrContext.h"
15#endif
16
17static uint32_t pack_unpremul_rgba(SkColor c) {
18    uint32_t packed;
19    uint8_t* byte = reinterpret_cast<uint8_t*>(&packed);
20    byte[0] = SkColorGetR(c);
21    byte[1] = SkColorGetG(c);
22    byte[2] = SkColorGetB(c);
23    byte[3] = SkColorGetA(c);
24    return packed;
25}
26
27static uint32_t pack_unpremul_bgra(SkColor c) {
28    uint32_t packed;
29    uint8_t* byte = reinterpret_cast<uint8_t*>(&packed);
30    byte[0] = SkColorGetB(c);
31    byte[1] = SkColorGetG(c);
32    byte[2] = SkColorGetR(c);
33    byte[3] = SkColorGetA(c);
34    return packed;
35}
36
37typedef uint32_t (*PackUnpremulProc)(SkColor);
38
39const struct {
40    SkColorType         fColorType;
41    PackUnpremulProc    fPackProc;
42} gUnpremul[] = {
43    { kRGBA_8888_SkColorType, pack_unpremul_rgba },
44    { kBGRA_8888_SkColorType, pack_unpremul_bgra },
45};
46
47static void fill_canvas(SkCanvas* canvas, SkColorType colorType, PackUnpremulProc proc) {
48    // Don't strictly need a bitmap, but its a handy way to allocate the pixels
49    SkBitmap bmp;
50    bmp.allocN32Pixels(256, 256);
51
52    for (int a = 0; a < 256; ++a) {
53        uint32_t* pixels = bmp.getAddr32(0, a);
54        for (int r = 0; r < 256; ++r) {
55            pixels[r] = proc(SkColorSetARGB(a, r, 0, 0));
56        }
57    }
58
59    const SkImageInfo info = SkImageInfo::Make(bmp.width(), bmp.height(),
60                                               colorType, kUnpremul_SkAlphaType);
61    canvas->writePixels(info, bmp.getPixels(), bmp.rowBytes(), 0, 0);
62}
63
64static void test_premul_alpha_roundtrip(skiatest::Reporter* reporter, SkSurface* surf) {
65    SkCanvas* canvas = surf->getCanvas();
66    for (size_t upmaIdx = 0; upmaIdx < SK_ARRAY_COUNT(gUnpremul); ++upmaIdx) {
67        fill_canvas(canvas, gUnpremul[upmaIdx].fColorType, gUnpremul[upmaIdx].fPackProc);
68
69        const SkImageInfo info = SkImageInfo::Make(256, 256, gUnpremul[upmaIdx].fColorType,
70                                                   kUnpremul_SkAlphaType);
71        SkBitmap readBmp1;
72        readBmp1.allocPixels(info);
73        SkBitmap readBmp2;
74        readBmp2.allocPixels(info);
75
76        readBmp1.eraseColor(0);
77        readBmp2.eraseColor(0);
78
79        canvas->readPixels(readBmp1, 0, 0);
80        sk_tool_utils::write_pixels(canvas, readBmp1, 0, 0, gUnpremul[upmaIdx].fColorType,
81                                    kUnpremul_SkAlphaType);
82        canvas->readPixels(readBmp2, 0, 0);
83
84        bool success = true;
85        for (int y = 0; y < 256 && success; ++y) {
86            const uint32_t* pixels1 = readBmp1.getAddr32(0, y);
87            const uint32_t* pixels2 = readBmp2.getAddr32(0, y);
88            for (int x = 0; x < 256 && success; ++x) {
89                // We see sporadic failures here. May help to see where it goes wrong.
90                if (pixels1[x] != pixels2[x]) {
91                    SkDebugf("%x != %x, x = %d, y = %d\n", pixels1[x], pixels2[x], x, y);
92                }
93                REPORTER_ASSERT(reporter, success = pixels1[x] == pixels2[x]);
94            }
95        }
96    }
97}
98
99DEF_TEST(PremulAlphaRoundTrip, reporter) {
100    const SkImageInfo info = SkImageInfo::MakeN32Premul(256, 256);
101
102    sk_sp<SkSurface> surf(SkSurface::MakeRaster(info));
103
104    test_premul_alpha_roundtrip(reporter, surf.get());
105}
106#if SK_SUPPORT_GPU
107DEF_GPUTEST_FOR_RENDERING_CONTEXTS(PremulAlphaRoundTrip_Gpu, reporter, ctxInfo) {
108    const SkImageInfo info = SkImageInfo::MakeN32Premul(256, 256);
109
110    sk_sp<SkSurface> surf(SkSurface::MakeRenderTarget(ctxInfo.grContext(),
111                                                      SkBudgeted::kNo,
112                                                      info));
113    test_premul_alpha_roundtrip(reporter, surf.get());
114}
115#endif
116