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 "SkBitmap.h"
9#include "SkCanvas.h"
10#include "SkColorPriv.h"
11#include "SkGradientShader.h"
12#include "SkRect.h"
13#include "Test.h"
14
15// these are in the same order as the SkColorType enum
16static const char* gColorTypeName[] = {
17    "None", "A8", "565", "4444", "RGBA", "BGRA", "Index8"
18};
19
20/** Returns -1 on success, else the x coord of the first bad pixel, return its
21    value in bad
22 */
23typedef int (*Proc)(const void*, int width, uint32_t expected, uint32_t* bad);
24
25static int proc_32(const void* ptr, int w, uint32_t expected, uint32_t* bad) {
26    const SkPMColor* addr = static_cast<const SkPMColor*>(ptr);
27    for (int x = 0; x < w; x++) {
28        if (addr[x] != expected) {
29            *bad = addr[x];
30            return x;
31        }
32    }
33    return -1;
34}
35
36static int proc_16(const void* ptr, int w, uint32_t expected, uint32_t* bad) {
37    const uint16_t* addr = static_cast<const uint16_t*>(ptr);
38    for (int x = 0; x < w; x++) {
39        if (addr[x] != expected) {
40            *bad = addr[x];
41            return x;
42        }
43    }
44    return -1;
45}
46
47static int proc_8(const void* ptr, int w, uint32_t expected, uint32_t* bad) {
48    const SkPMColor* addr = static_cast<const SkPMColor*>(ptr);
49    for (int x = 0; x < w; x++) {
50        if (SkGetPackedA32(addr[x]) != expected) {
51            *bad = SkGetPackedA32(addr[x]);
52            return x;
53        }
54    }
55    return -1;
56}
57
58static int proc_bad(const void*, int, uint32_t, uint32_t* bad) {
59    *bad = 0;
60    return 0;
61}
62
63static Proc find_proc(const SkBitmap& bm, SkPMColor expect32, uint16_t expect16,
64                      uint8_t expect8, uint32_t* expect) {
65    switch (bm.colorType()) {
66        case kN32_SkColorType:
67            *expect = expect32;
68            return proc_32;
69        case kARGB_4444_SkColorType:
70        case kRGB_565_SkColorType:
71            *expect = expect16;
72            return proc_16;
73        case kAlpha_8_SkColorType:
74            *expect = expect8;
75            return proc_8;
76        default:
77            *expect = 0;
78            return proc_bad;
79    }
80}
81
82static bool check_color(const SkBitmap& bm, SkPMColor expect32,
83                        uint16_t expect16, uint8_t expect8,
84                        skiatest::Reporter* reporter) {
85    uint32_t expect;
86    Proc proc = find_proc(bm, expect32, expect16, expect8, &expect);
87    for (int y = 0; y < bm.height(); y++) {
88        uint32_t bad;
89        int x = proc(bm.getAddr(0, y), bm.width(), expect, &bad);
90        if (x >= 0) {
91            ERRORF(reporter, "BlitRow colortype=%s [%d %d] expected %x got %x",
92                   gColorTypeName[bm.colorType()], x, y, expect, bad);
93            return false;
94        }
95    }
96    return true;
97}
98
99// Make sure our blits always map src==0 to a noop, and src==FF to full opaque
100static void test_00_FF(skiatest::Reporter* reporter) {
101    static const int W = 256;
102
103    static const SkColorType gDstColorType[] = {
104        kN32_SkColorType,
105        kRGB_565_SkColorType,
106    };
107
108    static const struct {
109        SkColor     fSrc;
110        SkColor     fDst;
111        SkPMColor   fResult32;
112        uint16_t    fResult16;
113        uint8_t     fResult8;
114    } gSrcRec[] = {
115        { 0,            0,          0,                                    0,      0 },
116        { 0,            0xFFFFFFFF, SkPackARGB32(0xFF, 0xFF, 0xFF, 0xFF), 0xFFFF, 0xFF },
117        { 0xFFFFFFFF,   0,          SkPackARGB32(0xFF, 0xFF, 0xFF, 0xFF), 0xFFFF, 0xFF },
118        { 0xFFFFFFFF,   0xFFFFFFFF, SkPackARGB32(0xFF, 0xFF, 0xFF, 0xFF), 0xFFFF, 0xFF },
119    };
120
121    SkPaint paint;
122
123    SkBitmap srcBM;
124    srcBM.allocN32Pixels(W, 1);
125
126    for (size_t i = 0; i < SK_ARRAY_COUNT(gDstColorType); i++) {
127        SkImageInfo info = SkImageInfo::Make(W, 1, gDstColorType[i],
128                                             kPremul_SkAlphaType);
129        SkBitmap dstBM;
130        dstBM.allocPixels(info);
131
132        SkCanvas canvas(dstBM);
133        for (size_t j = 0; j < SK_ARRAY_COUNT(gSrcRec); j++) {
134            srcBM.eraseColor(gSrcRec[j].fSrc);
135            dstBM.eraseColor(gSrcRec[j].fDst);
136
137            for (int k = 0; k < 4; k++) {
138                bool dither = (k & 1) != 0;
139                bool blend = (k & 2) != 0;
140                if (gSrcRec[j].fSrc != 0 && blend) {
141                    // can't make a numerical promise about blending anything
142                    // but 0
143                 //   continue;
144                }
145                paint.setDither(dither);
146                paint.setAlpha(blend ? 0x80 : 0xFF);
147                canvas.drawBitmap(srcBM, 0, 0, &paint);
148                if (!check_color(dstBM, gSrcRec[j].fResult32, gSrcRec[j].fResult16,
149                                 gSrcRec[j].fResult8, reporter)) {
150                    SkDebugf("--- src index %d dither %d blend %d\n", j, dither, blend);
151                }
152            }
153        }
154    }
155}
156
157///////////////////////////////////////////////////////////////////////////////
158
159struct Mesh {
160    SkPoint     fPts[4];
161
162    Mesh(const SkBitmap& bm, SkPaint* paint) {
163        const SkScalar w = SkIntToScalar(bm.width());
164        const SkScalar h = SkIntToScalar(bm.height());
165        fPts[0].set(0, 0);
166        fPts[1].set(w, 0);
167        fPts[2].set(w, h);
168        fPts[3].set(0, h);
169        SkShader* s = SkShader::CreateBitmapShader(bm, SkShader::kClamp_TileMode,
170                                                   SkShader::kClamp_TileMode);
171        paint->setShader(s)->unref();
172
173    }
174
175    void draw(SkCanvas* canvas, SkPaint* paint) {
176        canvas->drawVertices(SkCanvas::kTriangleFan_VertexMode, 4, fPts, fPts,
177                             NULL, NULL, NULL, 0, *paint);
178    }
179};
180
181#include "SkImageEncoder.h"
182static void save_bm(const SkBitmap& bm, const char name[]) {
183    SkImageEncoder::EncodeFile(name, bm, SkImageEncoder::kPNG_Type, 100);
184}
185
186static bool gOnce;
187
188// Make sure our blits are invariant with the width of the blit (i.e. that
189// special case for 8 at a time have the same results as narrower blits)
190static void test_diagonal(skiatest::Reporter* reporter) {
191    static const int W = 64;
192    static const int H = W;
193
194    static const SkColorType gDstColorType[] = {
195        kN32_SkColorType,
196        kRGB_565_SkColorType,
197    };
198
199    static const SkColor gDstBG[] = { 0, 0xFFFFFFFF };
200
201    SkPaint paint;
202
203    SkBitmap srcBM;
204    srcBM.allocN32Pixels(W, H);
205    SkRect srcR = {
206        0, 0, SkIntToScalar(srcBM.width()), SkIntToScalar(srcBM.height()) };
207
208    // cons up a mesh to draw the bitmap with
209    Mesh mesh(srcBM, &paint);
210
211    SkImageInfo info = SkImageInfo::Make(W, H, kUnknown_SkColorType,
212                                         kPremul_SkAlphaType);
213
214    for (size_t i = 0; i < SK_ARRAY_COUNT(gDstColorType); i++) {
215        info = info.makeColorType(gDstColorType[i]);
216
217        SkBitmap dstBM0, dstBM1;
218        dstBM0.allocPixels(info);
219        dstBM1.allocPixels(info);
220
221        SkCanvas canvas0(dstBM0);
222        SkCanvas canvas1(dstBM1);
223        SkColor bgColor;
224
225        for (size_t j = 0; j < SK_ARRAY_COUNT(gDstBG); j++) {
226            bgColor = gDstBG[j];
227
228            for (int c = 0; c <= 0xFF; c++) {
229                srcBM.eraseARGB(0xFF, c, c, c);
230
231                for (int k = 0; k < 4; k++) {
232                    bool dither = (k & 1) != 0;
233                    uint8_t alpha = (k & 2) ? 0x80 : 0xFF;
234                    paint.setDither(dither);
235                    paint.setAlpha(alpha);
236
237                    dstBM0.eraseColor(bgColor);
238                    dstBM1.eraseColor(bgColor);
239
240                    canvas0.drawRect(srcR, paint);
241                    mesh.draw(&canvas1, &paint);
242
243                    if (!gOnce && false) {
244                        save_bm(dstBM0, "drawBitmap.png");
245                        save_bm(dstBM1, "drawMesh.png");
246                        gOnce = true;
247                    }
248
249                    if (memcmp(dstBM0.getPixels(), dstBM1.getPixels(), dstBM0.getSize())) {
250                        ERRORF(reporter, "Diagonal colortype=%s bg=0x%x dither=%d"
251                               " alpha=0x%x src=0x%x",
252                               gColorTypeName[gDstColorType[i]], bgColor, dither,
253                               alpha, c);
254                    }
255                }
256            }
257        }
258    }
259}
260
261DEF_TEST(BlitRow, reporter) {
262    test_00_FF(reporter);
263    test_diagonal(reporter);
264}
265