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