1 #include "SkBenchmark.h"
2 #include "SkBitmap.h"
3 #include "SkPaint.h"
4 #include "SkCanvas.h"
5 #include "SkColorPriv.h"
6 #include "SkRandom.h"
7 #include "SkString.h"
8
9 static const char* gTileName[] = {
10 "clamp", "repeat", "mirror"
11 };
12
13 static const char* gConfigName[] = {
14 "ERROR", "a1", "a8", "index8", "565", "4444", "8888"
15 };
16
drawIntoBitmap(const SkBitmap & bm)17 static void drawIntoBitmap(const SkBitmap& bm) {
18 const int w = bm.width();
19 const int h = bm.height();
20
21 SkCanvas canvas(bm);
22 SkPaint p;
23 p.setAntiAlias(true);
24 p.setColor(SK_ColorRED);
25 canvas.drawCircle(SkIntToScalar(w)/2, SkIntToScalar(h)/2,
26 SkIntToScalar(SkMin32(w, h))*3/8, p);
27
28 SkRect r;
29 r.set(0, 0, SkIntToScalar(w), SkIntToScalar(h));
30 p.setStyle(SkPaint::kStroke_Style);
31 p.setStrokeWidth(SkIntToScalar(4));
32 p.setColor(SK_ColorBLUE);
33 canvas.drawRect(r, p);
34 }
35
conv6ToByte(int x)36 static int conv6ToByte(int x) {
37 return x * 0xFF / 5;
38 }
39
convByteTo6(int x)40 static int convByteTo6(int x) {
41 return x * 5 / 255;
42 }
43
compute666Index(SkPMColor c)44 static uint8_t compute666Index(SkPMColor c) {
45 int r = SkGetPackedR32(c);
46 int g = SkGetPackedG32(c);
47 int b = SkGetPackedB32(c);
48
49 return convByteTo6(r) * 36 + convByteTo6(g) * 6 + convByteTo6(b);
50 }
51
convertToIndex666(const SkBitmap & src,SkBitmap * dst)52 static void convertToIndex666(const SkBitmap& src, SkBitmap* dst) {
53 SkColorTable* ctable = new SkColorTable(216);
54 SkPMColor* colors = ctable->lockColors();
55 // rrr ggg bbb
56 for (int r = 0; r < 6; r++) {
57 int rr = conv6ToByte(r);
58 for (int g = 0; g < 6; g++) {
59 int gg = conv6ToByte(g);
60 for (int b = 0; b < 6; b++) {
61 int bb = conv6ToByte(b);
62 *colors++ = SkPreMultiplyARGB(0xFF, rr, gg, bb);
63 }
64 }
65 }
66 ctable->unlockColors(true);
67 dst->setConfig(SkBitmap::kIndex8_Config, src.width(), src.height());
68 dst->allocPixels(ctable);
69 ctable->unref();
70
71 SkAutoLockPixels alps(src);
72 SkAutoLockPixels alpd(*dst);
73
74 for (int y = 0; y < src.height(); y++) {
75 const SkPMColor* srcP = src.getAddr32(0, y);
76 uint8_t* dstP = dst->getAddr8(0, y);
77 for (int x = src.width() - 1; x >= 0; --x) {
78 *dstP++ = compute666Index(*srcP++);
79 }
80 }
81 }
82
83 /* Variants for bitmaps
84
85 - src depth (32 w+w/o alpha), 565, 4444, index, a8
86 - paint options: filtering, dither, alpha
87 - matrix options: translate, scale, rotate, persp
88 - tiling: none, repeat, mirror, clamp
89
90 */
91
92 class BitmapBench : public SkBenchmark {
93 SkBitmap fBitmap;
94 SkPaint fPaint;
95 bool fIsOpaque;
96 int fTileX, fTileY; // -1 means don't use shader
97 SkString fName;
98 enum { N = 300 };
99 public:
BitmapBench(void * param,bool isOpaque,SkBitmap::Config c,int tx=-1,int ty=-1)100 BitmapBench(void* param, bool isOpaque, SkBitmap::Config c,
101 int tx = -1, int ty = -1)
102 : INHERITED(param), fIsOpaque(isOpaque), fTileX(tx), fTileY(ty) {
103 const int w = 128;
104 const int h = 128;
105 SkBitmap bm;
106
107 if (SkBitmap::kIndex8_Config == c) {
108 bm.setConfig(SkBitmap::kARGB_8888_Config, w, h);
109 } else {
110 bm.setConfig(c, w, h);
111 }
112 bm.allocPixels();
113 bm.eraseColor(isOpaque ? SK_ColorBLACK : 0);
114
115 drawIntoBitmap(bm);
116
117 if (SkBitmap::kIndex8_Config == c) {
118 convertToIndex666(bm, &fBitmap);
119 } else {
120 fBitmap = bm;
121 }
122
123 if (fBitmap.getColorTable()) {
124 fBitmap.getColorTable()->setIsOpaque(isOpaque);
125 }
126 fBitmap.setIsOpaque(isOpaque);
127 }
128
129 protected:
onGetName()130 virtual const char* onGetName() {
131 fName.set("bitmap");
132 if (fTileX >= 0) {
133 fName.appendf("_%s", gTileName[fTileX]);
134 if (fTileY != fTileX) {
135 fName.appendf("_%s", gTileName[fTileY]);
136 }
137 }
138 fName.appendf("_%s%s", gConfigName[fBitmap.config()],
139 fIsOpaque ? "" : "_A");
140 return fName.c_str();
141 }
142
onDraw(SkCanvas * canvas)143 virtual void onDraw(SkCanvas* canvas) {
144 SkIPoint dim = this->getSize();
145 SkRandom rand;
146
147 SkPaint paint(fPaint);
148 this->setupPaint(&paint);
149
150 const SkBitmap& bitmap = fBitmap;
151 const SkScalar x0 = SkIntToScalar(-bitmap.width() / 2);
152 const SkScalar y0 = SkIntToScalar(-bitmap.height() / 2);
153
154 for (int i = 0; i < N; i++) {
155 SkScalar x = x0 + rand.nextUScalar1() * dim.fX;
156 SkScalar y = y0 + rand.nextUScalar1() * dim.fY;
157 canvas->drawBitmap(bitmap, x, y, &paint);
158 }
159 }
160
161 private:
162 typedef SkBenchmark INHERITED;
163 };
164
Fact0(void * p)165 static SkBenchmark* Fact0(void* p) { return new BitmapBench(p, false, SkBitmap::kARGB_8888_Config); }
Fact1(void * p)166 static SkBenchmark* Fact1(void* p) { return new BitmapBench(p, true, SkBitmap::kARGB_8888_Config); }
Fact2(void * p)167 static SkBenchmark* Fact2(void* p) { return new BitmapBench(p, true, SkBitmap::kRGB_565_Config); }
Fact3(void * p)168 static SkBenchmark* Fact3(void* p) { return new BitmapBench(p, false, SkBitmap::kARGB_4444_Config); }
Fact4(void * p)169 static SkBenchmark* Fact4(void* p) { return new BitmapBench(p, true, SkBitmap::kARGB_4444_Config); }
Fact5(void * p)170 static SkBenchmark* Fact5(void* p) { return new BitmapBench(p, false, SkBitmap::kIndex8_Config); }
Fact6(void * p)171 static SkBenchmark* Fact6(void* p) { return new BitmapBench(p, true, SkBitmap::kIndex8_Config); }
172
173 static BenchRegistry gReg0(Fact0);
174 static BenchRegistry gReg1(Fact1);
175 static BenchRegistry gReg2(Fact2);
176 static BenchRegistry gReg3(Fact3);
177 static BenchRegistry gReg4(Fact4);
178 static BenchRegistry gReg5(Fact5);
179 static BenchRegistry gReg6(Fact6);
180