epoger@google.com | ec3ed6a | 2011-07-28 14:26:00 +0000 | [diff] [blame] | 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 | */ |
reed | 6c22573 | 2014-06-09 19:52:07 -0700 | [diff] [blame] | 7 | |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 8 | #include "bench/Benchmark.h" |
| 9 | #include "include/core/SkBitmap.h" |
| 10 | #include "include/core/SkCanvas.h" |
| 11 | #include "include/core/SkColorPriv.h" |
| 12 | #include "include/core/SkPaint.h" |
| 13 | #include "include/core/SkString.h" |
| 14 | #include "include/utils/SkRandom.h" |
| 15 | #include "tools/ToolUtils.h" |
reed@android.com | f523e25 | 2009-01-26 23:15:37 +0000 | [diff] [blame] | 16 | |
reed@android.com | f523e25 | 2009-01-26 23:15:37 +0000 | [diff] [blame] | 17 | /* Variants for bitmaps |
rmistry@google.com | fbfcd56 | 2012-08-23 18:09:54 +0000 | [diff] [blame] | 18 | |
reed@android.com | f523e25 | 2009-01-26 23:15:37 +0000 | [diff] [blame] | 19 | - src depth (32 w+w/o alpha), 565, 4444, index, a8 |
| 20 | - paint options: filtering, dither, alpha |
| 21 | - matrix options: translate, scale, rotate, persp |
| 22 | - tiling: none, repeat, mirror, clamp |
rmistry@google.com | fbfcd56 | 2012-08-23 18:09:54 +0000 | [diff] [blame] | 23 | |
reed@android.com | f523e25 | 2009-01-26 23:15:37 +0000 | [diff] [blame] | 24 | */ |
| 25 | |
tfarina | f168b86 | 2014-06-19 12:32:29 -0700 | [diff] [blame] | 26 | class BitmapBench : public Benchmark { |
reed | 6c22573 | 2014-06-09 19:52:07 -0700 | [diff] [blame] | 27 | const SkColorType fColorType; |
| 28 | const SkAlphaType fAlphaType; |
| 29 | const bool fForceUpdate; //bitmap marked as dirty before each draw. forces bitmap to be updated on device cache |
mtklein | 14e4d39 | 2014-10-23 14:35:01 -0700 | [diff] [blame] | 30 | const bool fDoScale; |
reed | 6c22573 | 2014-06-09 19:52:07 -0700 | [diff] [blame] | 31 | |
| 32 | SkBitmap fBitmap; |
| 33 | SkPaint fPaint; |
| 34 | SkString fName; |
| 35 | |
djsollen@google.com | c2532dd | 2013-04-09 18:06:06 +0000 | [diff] [blame] | 36 | enum { W = 128 }; |
| 37 | enum { H = 128 }; |
reed@android.com | f523e25 | 2009-01-26 23:15:37 +0000 | [diff] [blame] | 38 | public: |
Mike Reed | 609ea21 | 2020-07-12 15:07:25 -0400 | [diff] [blame] | 39 | BitmapBench(SkColorType ct, SkAlphaType at, bool forceUpdate, bool doScale) |
reed | 6c22573 | 2014-06-09 19:52:07 -0700 | [diff] [blame] | 40 | : fColorType(ct) |
| 41 | , fAlphaType(at) |
djsollen@google.com | c2532dd | 2013-04-09 18:06:06 +0000 | [diff] [blame] | 42 | , fForceUpdate(forceUpdate) |
mtklein | 14e4d39 | 2014-10-23 14:35:01 -0700 | [diff] [blame] | 43 | , fDoScale(doScale) |
reed | 6c22573 | 2014-06-09 19:52:07 -0700 | [diff] [blame] | 44 | {} |
reed@android.com | f523e25 | 2009-01-26 23:15:37 +0000 | [diff] [blame] | 45 | |
| 46 | protected: |
mtklein | f059900 | 2015-07-13 06:18:39 -0700 | [diff] [blame] | 47 | const char* onGetName() override { |
reed@android.com | f523e25 | 2009-01-26 23:15:37 +0000 | [diff] [blame] | 48 | fName.set("bitmap"); |
Mike Klein | ea3f014 | 2019-03-20 11:12:10 -0500 | [diff] [blame] | 49 | fName.appendf("_%s%s", |
| 50 | ToolUtils::colortype_name(fColorType), |
reed | 6c22573 | 2014-06-09 19:52:07 -0700 | [diff] [blame] | 51 | kOpaque_SkAlphaType == fAlphaType ? "" : "_A"); |
mtklein | 14e4d39 | 2014-10-23 14:35:01 -0700 | [diff] [blame] | 52 | if (fDoScale) { |
| 53 | fName.append("_scale"); |
| 54 | } |
| 55 | if (fForceUpdate) { |
junov@google.com | 4ee7ae5 | 2011-06-30 17:30:49 +0000 | [diff] [blame] | 56 | fName.append("_update"); |
mtklein | 14e4d39 | 2014-10-23 14:35:01 -0700 | [diff] [blame] | 57 | } |
junov@google.com | 4ee7ae5 | 2011-06-30 17:30:49 +0000 | [diff] [blame] | 58 | |
reed@android.com | f523e25 | 2009-01-26 23:15:37 +0000 | [diff] [blame] | 59 | return fName.c_str(); |
| 60 | } |
| 61 | |
joshualitt | 8a6697a | 2015-09-30 12:11:07 -0700 | [diff] [blame] | 62 | void onDelayedSetup() override { |
djsollen@google.com | c2532dd | 2013-04-09 18:06:06 +0000 | [diff] [blame] | 63 | SkBitmap bm; |
| 64 | |
Mike Reed | a920d36 | 2017-07-03 13:36:17 -0400 | [diff] [blame] | 65 | bm.allocPixels(SkImageInfo::Make(W, H, fColorType, fAlphaType)); |
reed | 6c22573 | 2014-06-09 19:52:07 -0700 | [diff] [blame] | 66 | bm.eraseColor(kOpaque_SkAlphaType == fAlphaType ? SK_ColorBLACK : 0); |
djsollen@google.com | c2532dd | 2013-04-09 18:06:06 +0000 | [diff] [blame] | 67 | |
mtklein | f059900 | 2015-07-13 06:18:39 -0700 | [diff] [blame] | 68 | this->onDrawIntoBitmap(bm); |
djsollen@google.com | c2532dd | 2013-04-09 18:06:06 +0000 | [diff] [blame] | 69 | |
Mike Reed | a920d36 | 2017-07-03 13:36:17 -0400 | [diff] [blame] | 70 | fBitmap = bm; |
Mike Reed | db0b998 | 2020-11-12 11:26:43 -0500 | [diff] [blame] | 71 | if (!fForceUpdate) { |
| 72 | fBitmap.setImmutable(); |
| 73 | } |
djsollen@google.com | c2532dd | 2013-04-09 18:06:06 +0000 | [diff] [blame] | 74 | } |
| 75 | |
mtklein | a1ebeb2 | 2015-10-01 09:43:39 -0700 | [diff] [blame] | 76 | void onDraw(int loops, SkCanvas* canvas) override { |
mtklein | 14e4d39 | 2014-10-23 14:35:01 -0700 | [diff] [blame] | 77 | if (fDoScale) { |
| 78 | canvas->scale(.99f, .99f); |
| 79 | } |
reed@android.com | f523e25 | 2009-01-26 23:15:37 +0000 | [diff] [blame] | 80 | SkIPoint dim = this->getSize(); |
commit-bot@chromium.org | e0e7cfe | 2013-09-09 20:09:12 +0000 | [diff] [blame] | 81 | SkRandom rand; |
reed@android.com | f523e25 | 2009-01-26 23:15:37 +0000 | [diff] [blame] | 82 | |
| 83 | SkPaint paint(fPaint); |
| 84 | this->setupPaint(&paint); |
| 85 | |
| 86 | const SkBitmap& bitmap = fBitmap; |
| 87 | const SkScalar x0 = SkIntToScalar(-bitmap.width() / 2); |
| 88 | const SkScalar y0 = SkIntToScalar(-bitmap.height() / 2); |
rmistry@google.com | fbfcd56 | 2012-08-23 18:09:54 +0000 | [diff] [blame] | 89 | |
commit-bot@chromium.org | 3361471 | 2013-12-03 18:17:16 +0000 | [diff] [blame] | 90 | for (int i = 0; i < loops; i++) { |
reed@android.com | f523e25 | 2009-01-26 23:15:37 +0000 | [diff] [blame] | 91 | SkScalar x = x0 + rand.nextUScalar1() * dim.fX; |
| 92 | SkScalar y = y0 + rand.nextUScalar1() * dim.fY; |
junov@google.com | 4ee7ae5 | 2011-06-30 17:30:49 +0000 | [diff] [blame] | 93 | |
| 94 | if (fForceUpdate) |
| 95 | bitmap.notifyPixelsChanged(); |
| 96 | |
reed@android.com | f523e25 | 2009-01-26 23:15:37 +0000 | [diff] [blame] | 97 | canvas->drawBitmap(bitmap, x, y, &paint); |
| 98 | } |
| 99 | } |
| 100 | |
mtklein | f059900 | 2015-07-13 06:18:39 -0700 | [diff] [blame] | 101 | virtual void onDrawIntoBitmap(const SkBitmap& bm) { |
djsollen@google.com | c2532dd | 2013-04-09 18:06:06 +0000 | [diff] [blame] | 102 | const int w = bm.width(); |
| 103 | const int h = bm.height(); |
| 104 | |
| 105 | SkCanvas canvas(bm); |
| 106 | SkPaint p; |
| 107 | p.setAntiAlias(true); |
| 108 | p.setColor(SK_ColorRED); |
| 109 | canvas.drawCircle(SkIntToScalar(w)/2, SkIntToScalar(h)/2, |
Brian Osman | 7f36405 | 2020-02-06 11:25:43 -0500 | [diff] [blame] | 110 | SkIntToScalar(std::min(w, h))*3/8, p); |
djsollen@google.com | c2532dd | 2013-04-09 18:06:06 +0000 | [diff] [blame] | 111 | |
| 112 | SkRect r; |
Mike Reed | 92b3335 | 2019-08-24 19:39:13 -0400 | [diff] [blame] | 113 | r.setWH(SkIntToScalar(w), SkIntToScalar(h)); |
djsollen@google.com | c2532dd | 2013-04-09 18:06:06 +0000 | [diff] [blame] | 114 | p.setStyle(SkPaint::kStroke_Style); |
| 115 | p.setStrokeWidth(SkIntToScalar(4)); |
| 116 | p.setColor(SK_ColorBLUE); |
| 117 | canvas.drawRect(r, p); |
| 118 | } |
| 119 | |
reed@android.com | f523e25 | 2009-01-26 23:15:37 +0000 | [diff] [blame] | 120 | private: |
John Stiles | 7571f9e | 2020-09-02 22:42:33 -0400 | [diff] [blame] | 121 | using INHERITED = Benchmark; |
reed@android.com | f523e25 | 2009-01-26 23:15:37 +0000 | [diff] [blame] | 122 | }; |
| 123 | |
tomhudson@google.com | c3be34d | 2012-05-15 20:09:33 +0000 | [diff] [blame] | 124 | /** Explicitly invoke some filter types to improve coverage of acceleration |
| 125 | procs. */ |
| 126 | |
reed@google.com | ef77ec2 | 2013-05-29 15:39:54 +0000 | [diff] [blame] | 127 | enum Flags { |
| 128 | kScale_Flag = 1 << 0, |
| 129 | kRotate_Flag = 1 << 1, |
| 130 | kBilerp_Flag = 1 << 2, |
| 131 | kBicubic_Flag = 1 << 3, |
| 132 | }; |
| 133 | |
| 134 | static bool isBilerp(uint32_t flags) { |
| 135 | return (flags & (kBilerp_Flag | kBicubic_Flag)) == (kBilerp_Flag); |
| 136 | } |
| 137 | |
| 138 | static bool isBicubic(uint32_t flags) { |
| 139 | return (flags & (kBilerp_Flag | kBicubic_Flag)) == (kBilerp_Flag | kBicubic_Flag); |
| 140 | } |
| 141 | |
tomhudson@google.com | c3be34d | 2012-05-15 20:09:33 +0000 | [diff] [blame] | 142 | class FilterBitmapBench : public BitmapBench { |
reed@google.com | ef77ec2 | 2013-05-29 15:39:54 +0000 | [diff] [blame] | 143 | uint32_t fFlags; |
tomhudson@google.com | c3be34d | 2012-05-15 20:09:33 +0000 | [diff] [blame] | 144 | SkString fFullName; |
tomhudson@google.com | c3be34d | 2012-05-15 20:09:33 +0000 | [diff] [blame] | 145 | public: |
Mike Reed | 609ea21 | 2020-07-12 15:07:25 -0400 | [diff] [blame] | 146 | FilterBitmapBench(SkColorType ct, SkAlphaType at, bool forceUpdate, uint32_t flags) |
| 147 | : INHERITED(ct, at, forceUpdate, false) |
reed@google.com | ef77ec2 | 2013-05-29 15:39:54 +0000 | [diff] [blame] | 148 | , fFlags(flags) { |
tomhudson@google.com | c3be34d | 2012-05-15 20:09:33 +0000 | [diff] [blame] | 149 | } |
| 150 | |
| 151 | protected: |
mtklein | f059900 | 2015-07-13 06:18:39 -0700 | [diff] [blame] | 152 | const char* onGetName() override { |
tomhudson@google.com | c3be34d | 2012-05-15 20:09:33 +0000 | [diff] [blame] | 153 | fFullName.set(INHERITED::onGetName()); |
reed@google.com | ef77ec2 | 2013-05-29 15:39:54 +0000 | [diff] [blame] | 154 | if (fFlags & kScale_Flag) { |
tomhudson@google.com | c3be34d | 2012-05-15 20:09:33 +0000 | [diff] [blame] | 155 | fFullName.append("_scale"); |
reed@google.com | ef77ec2 | 2013-05-29 15:39:54 +0000 | [diff] [blame] | 156 | } |
| 157 | if (fFlags & kRotate_Flag) { |
tomhudson@google.com | c3be34d | 2012-05-15 20:09:33 +0000 | [diff] [blame] | 158 | fFullName.append("_rotate"); |
reed@google.com | ef77ec2 | 2013-05-29 15:39:54 +0000 | [diff] [blame] | 159 | } |
| 160 | if (isBilerp(fFlags)) { |
| 161 | fFullName.append("_bilerp"); |
| 162 | } else if (isBicubic(fFlags)) { |
| 163 | fFullName.append("_bicubic"); |
| 164 | } |
tomhudson@google.com | c3be34d | 2012-05-15 20:09:33 +0000 | [diff] [blame] | 165 | |
| 166 | return fFullName.c_str(); |
| 167 | } |
| 168 | |
mtklein | a1ebeb2 | 2015-10-01 09:43:39 -0700 | [diff] [blame] | 169 | void onDraw(int loops, SkCanvas* canvas) override { |
Mike Reed | 3661bc9 | 2017-02-22 13:21:42 -0500 | [diff] [blame] | 170 | SkISize dim = canvas->getBaseLayerSize(); |
reed@google.com | ef77ec2 | 2013-05-29 15:39:54 +0000 | [diff] [blame] | 171 | if (fFlags & kScale_Flag) { |
tomhudson@google.com | c3be34d | 2012-05-15 20:09:33 +0000 | [diff] [blame] | 172 | const SkScalar x = SkIntToScalar(dim.fWidth) / 2; |
| 173 | const SkScalar y = SkIntToScalar(dim.fHeight) / 2; |
rmistry@google.com | fbfcd56 | 2012-08-23 18:09:54 +0000 | [diff] [blame] | 174 | |
tomhudson@google.com | c3be34d | 2012-05-15 20:09:33 +0000 | [diff] [blame] | 175 | canvas->translate(x, y); |
| 176 | // just enough so we can't take the sprite case |
Mike Reed | 76c6ff0 | 2019-07-31 16:33:55 -0400 | [diff] [blame] | 177 | canvas->scale(1.1f, 1.1f); |
tomhudson@google.com | c3be34d | 2012-05-15 20:09:33 +0000 | [diff] [blame] | 178 | canvas->translate(-x, -y); |
| 179 | } |
reed@google.com | ef77ec2 | 2013-05-29 15:39:54 +0000 | [diff] [blame] | 180 | if (fFlags & kRotate_Flag) { |
tomhudson@google.com | c3be34d | 2012-05-15 20:09:33 +0000 | [diff] [blame] | 181 | const SkScalar x = SkIntToScalar(dim.fWidth) / 2; |
| 182 | const SkScalar y = SkIntToScalar(dim.fHeight) / 2; |
bungeman | 7438bfc | 2016-07-12 15:01:19 -0700 | [diff] [blame] | 183 | canvas->rotate(SkIntToScalar(35), x, y); |
tomhudson@google.com | c3be34d | 2012-05-15 20:09:33 +0000 | [diff] [blame] | 184 | } |
commit-bot@chromium.org | 3361471 | 2013-12-03 18:17:16 +0000 | [diff] [blame] | 185 | INHERITED::onDraw(loops, canvas); |
tomhudson@google.com | c3be34d | 2012-05-15 20:09:33 +0000 | [diff] [blame] | 186 | } |
| 187 | |
mtklein | 36352bf | 2015-03-25 18:17:31 -0700 | [diff] [blame] | 188 | void setupPaint(SkPaint* paint) override { |
reed@google.com | 9cfc83c | 2013-07-22 17:18:18 +0000 | [diff] [blame] | 189 | this->INHERITED::setupPaint(paint); |
| 190 | |
| 191 | int index = 0; |
| 192 | if (fFlags & kBilerp_Flag) { |
| 193 | index |= 1; |
| 194 | } |
| 195 | if (fFlags & kBicubic_Flag) { |
| 196 | index |= 2; |
| 197 | } |
reed | 93a1215 | 2015-03-16 10:08:34 -0700 | [diff] [blame] | 198 | static const SkFilterQuality gQualitys[] = { |
| 199 | kNone_SkFilterQuality, |
| 200 | kLow_SkFilterQuality, |
| 201 | kMedium_SkFilterQuality, |
| 202 | kHigh_SkFilterQuality |
reed@google.com | 9cfc83c | 2013-07-22 17:18:18 +0000 | [diff] [blame] | 203 | }; |
reed | 93a1215 | 2015-03-16 10:08:34 -0700 | [diff] [blame] | 204 | paint->setFilterQuality(gQualitys[index]); |
reed@google.com | 9cfc83c | 2013-07-22 17:18:18 +0000 | [diff] [blame] | 205 | } |
| 206 | |
tomhudson@google.com | c3be34d | 2012-05-15 20:09:33 +0000 | [diff] [blame] | 207 | private: |
John Stiles | 7571f9e | 2020-09-02 22:42:33 -0400 | [diff] [blame] | 208 | using INHERITED = BitmapBench; |
tomhudson@google.com | c3be34d | 2012-05-15 20:09:33 +0000 | [diff] [blame] | 209 | }; |
| 210 | |
djsollen@google.com | c2532dd | 2013-04-09 18:06:06 +0000 | [diff] [blame] | 211 | /** Verify optimizations that test source alpha values. */ |
| 212 | |
| 213 | class SourceAlphaBitmapBench : public BitmapBench { |
| 214 | public: |
| 215 | enum SourceAlpha { kOpaque_SourceAlpha, kTransparent_SourceAlpha, |
| 216 | kTwoStripes_SourceAlpha, kThreeStripes_SourceAlpha}; |
| 217 | private: |
| 218 | SkString fFullName; |
| 219 | SourceAlpha fSourceAlpha; |
| 220 | public: |
Mike Reed | 609ea21 | 2020-07-12 15:07:25 -0400 | [diff] [blame] | 221 | SourceAlphaBitmapBench(SourceAlpha alpha, SkColorType ct, bool forceUpdate = false) |
| 222 | : INHERITED(ct, kPremul_SkAlphaType, forceUpdate, false) |
djsollen@google.com | c2532dd | 2013-04-09 18:06:06 +0000 | [diff] [blame] | 223 | , fSourceAlpha(alpha) { |
| 224 | } |
| 225 | |
| 226 | protected: |
mtklein | f059900 | 2015-07-13 06:18:39 -0700 | [diff] [blame] | 227 | const char* onGetName() override { |
djsollen@google.com | c2532dd | 2013-04-09 18:06:06 +0000 | [diff] [blame] | 228 | fFullName.set(INHERITED::onGetName()); |
| 229 | |
| 230 | if (fSourceAlpha == kOpaque_SourceAlpha) { |
| 231 | fFullName.append("_source_opaque"); |
| 232 | } else if (fSourceAlpha == kTransparent_SourceAlpha) { |
| 233 | fFullName.append("_source_transparent"); |
| 234 | } else if (fSourceAlpha == kTwoStripes_SourceAlpha) { |
| 235 | fFullName.append("_source_stripes_two"); |
| 236 | } else if (fSourceAlpha == kThreeStripes_SourceAlpha) { |
| 237 | fFullName.append("_source_stripes_three"); |
| 238 | } |
| 239 | |
| 240 | return fFullName.c_str(); |
| 241 | } |
| 242 | |
mtklein | 36352bf | 2015-03-25 18:17:31 -0700 | [diff] [blame] | 243 | void onDrawIntoBitmap(const SkBitmap& bm) override { |
djsollen@google.com | c2532dd | 2013-04-09 18:06:06 +0000 | [diff] [blame] | 244 | const int w = bm.width(); |
| 245 | const int h = bm.height(); |
| 246 | |
| 247 | if (kOpaque_SourceAlpha == fSourceAlpha) { |
| 248 | bm.eraseColor(SK_ColorBLACK); |
| 249 | } else if (kTransparent_SourceAlpha == fSourceAlpha) { |
| 250 | bm.eraseColor(0); |
| 251 | } else if (kTwoStripes_SourceAlpha == fSourceAlpha) { |
| 252 | bm.eraseColor(0); |
| 253 | |
| 254 | SkCanvas canvas(bm); |
| 255 | SkPaint p; |
| 256 | p.setAntiAlias(false); |
| 257 | p.setStyle(SkPaint::kFill_Style); |
| 258 | p.setColor(SK_ColorRED); |
| 259 | |
| 260 | // Draw red vertical stripes on transparent background |
| 261 | SkRect r; |
| 262 | for (int x = 0; x < w; x+=2) |
| 263 | { |
Mike Reed | 92b3335 | 2019-08-24 19:39:13 -0400 | [diff] [blame] | 264 | r.setLTRB(SkIntToScalar(x), 0, SkIntToScalar(x+1), SkIntToScalar(h)); |
djsollen@google.com | c2532dd | 2013-04-09 18:06:06 +0000 | [diff] [blame] | 265 | canvas.drawRect(r, p); |
| 266 | } |
| 267 | |
| 268 | } else if (kThreeStripes_SourceAlpha == fSourceAlpha) { |
| 269 | bm.eraseColor(0); |
| 270 | |
| 271 | SkCanvas canvas(bm); |
| 272 | SkPaint p; |
| 273 | p.setAntiAlias(false); |
| 274 | p.setStyle(SkPaint::kFill_Style); |
| 275 | |
| 276 | // Draw vertical stripes on transparent background with a pattern |
| 277 | // where the first pixel is fully transparent, the next is semi-transparent |
| 278 | // and the third is fully opaque. |
| 279 | SkRect r; |
| 280 | for (int x = 0; x < w; x++) |
| 281 | { |
| 282 | if (x % 3 == 0) { |
| 283 | continue; // Keep transparent |
| 284 | } else if (x % 3 == 1) { |
| 285 | p.setColor(SkColorSetARGB(127, 127, 127, 127)); // Semi-transparent |
| 286 | } else if (x % 3 == 2) { |
| 287 | p.setColor(SK_ColorRED); // Opaque |
| 288 | } |
Mike Reed | 92b3335 | 2019-08-24 19:39:13 -0400 | [diff] [blame] | 289 | r.setLTRB(SkIntToScalar(x), 0, SkIntToScalar(x+1), SkIntToScalar(h)); |
djsollen@google.com | c2532dd | 2013-04-09 18:06:06 +0000 | [diff] [blame] | 290 | canvas.drawRect(r, p); |
| 291 | } |
| 292 | } |
| 293 | } |
| 294 | |
| 295 | private: |
John Stiles | 7571f9e | 2020-09-02 22:42:33 -0400 | [diff] [blame] | 296 | using INHERITED = BitmapBench; |
djsollen@google.com | c2532dd | 2013-04-09 18:06:06 +0000 | [diff] [blame] | 297 | }; |
reed@google.com | 2ece287 | 2013-05-28 20:48:14 +0000 | [diff] [blame] | 298 | |
Mike Reed | 609ea21 | 2020-07-12 15:07:25 -0400 | [diff] [blame] | 299 | DEF_BENCH( return new BitmapBench(kN32_SkColorType, kPremul_SkAlphaType, false, false); ) |
| 300 | DEF_BENCH( return new BitmapBench(kN32_SkColorType, kOpaque_SkAlphaType, false, false); ) |
| 301 | DEF_BENCH( return new BitmapBench(kN32_SkColorType, kOpaque_SkAlphaType, false, true); ) |
| 302 | DEF_BENCH( return new BitmapBench(kRGB_565_SkColorType, kOpaque_SkAlphaType, false, false); ) |
| 303 | DEF_BENCH( return new BitmapBench(kN32_SkColorType, kOpaque_SkAlphaType, true, false); ) |
| 304 | DEF_BENCH( return new BitmapBench(kN32_SkColorType, kOpaque_SkAlphaType, true, false); ) |
reed@android.com | f523e25 | 2009-01-26 23:15:37 +0000 | [diff] [blame] | 305 | |
rmistry@google.com | fbfcd56 | 2012-08-23 18:09:54 +0000 | [diff] [blame] | 306 | // scale filter -> S32_opaque_D32_filter_DX_{SSE2,SSSE3} and Fact9 is also for S32_D16_filter_DX_SSE2 |
Mike Reed | 609ea21 | 2020-07-12 15:07:25 -0400 | [diff] [blame] | 307 | DEF_BENCH( return new FilterBitmapBench(kN32_SkColorType, kPremul_SkAlphaType, false, kScale_Flag | kBilerp_Flag); ) |
| 308 | DEF_BENCH( return new FilterBitmapBench(kN32_SkColorType, kOpaque_SkAlphaType, false, kScale_Flag | kBilerp_Flag); ) |
| 309 | DEF_BENCH( return new FilterBitmapBench(kN32_SkColorType, kOpaque_SkAlphaType, true, kScale_Flag | kBilerp_Flag); ) |
| 310 | DEF_BENCH( return new FilterBitmapBench(kN32_SkColorType, kOpaque_SkAlphaType, true, kScale_Flag | kBilerp_Flag); ) |
tomhudson@google.com | c3be34d | 2012-05-15 20:09:33 +0000 | [diff] [blame] | 311 | |
Yuqian Li | 24e963d | 2017-12-06 11:30:58 -0500 | [diff] [blame] | 312 | // The following two cases test the performance regression of b/70172912 . |
Mike Reed | 609ea21 | 2020-07-12 15:07:25 -0400 | [diff] [blame] | 313 | DEF_BENCH( return new FilterBitmapBench(kRGB_565_SkColorType, kOpaque_SkAlphaType, false, kScale_Flag | kBilerp_Flag); ) |
| 314 | DEF_BENCH( return new BitmapBench(kRGB_565_SkColorType, kOpaque_SkAlphaType, false, true); ) |
Yuqian Li | 24e963d | 2017-12-06 11:30:58 -0500 | [diff] [blame] | 315 | |
tomhudson@google.com | c3be34d | 2012-05-15 20:09:33 +0000 | [diff] [blame] | 316 | // scale rotate filter -> S32_opaque_D32_filter_DXDY_{SSE2,SSSE3} |
Mike Reed | 609ea21 | 2020-07-12 15:07:25 -0400 | [diff] [blame] | 317 | DEF_BENCH( return new FilterBitmapBench(kN32_SkColorType, kPremul_SkAlphaType, false, kScale_Flag | kRotate_Flag | kBilerp_Flag); ) |
| 318 | DEF_BENCH( return new FilterBitmapBench(kN32_SkColorType, kOpaque_SkAlphaType, false, kScale_Flag | kRotate_Flag | kBilerp_Flag); ) |
| 319 | DEF_BENCH( return new FilterBitmapBench(kN32_SkColorType, kOpaque_SkAlphaType, true, kScale_Flag | kRotate_Flag | kBilerp_Flag); ) |
| 320 | DEF_BENCH( return new FilterBitmapBench(kN32_SkColorType, kOpaque_SkAlphaType, true, kScale_Flag | kRotate_Flag | kBilerp_Flag); ) |
reed@google.com | ef77ec2 | 2013-05-29 15:39:54 +0000 | [diff] [blame] | 321 | |
Mike Reed | 609ea21 | 2020-07-12 15:07:25 -0400 | [diff] [blame] | 322 | DEF_BENCH( return new FilterBitmapBench(kN32_SkColorType, kPremul_SkAlphaType, false, kScale_Flag | kBilerp_Flag | kBicubic_Flag); ) |
| 323 | DEF_BENCH( return new FilterBitmapBench(kN32_SkColorType, kPremul_SkAlphaType, false, kScale_Flag | kRotate_Flag | kBilerp_Flag | kBicubic_Flag); ) |
tomhudson@google.com | c3be34d | 2012-05-15 20:09:33 +0000 | [diff] [blame] | 324 | |
djsollen@google.com | c2532dd | 2013-04-09 18:06:06 +0000 | [diff] [blame] | 325 | // source alpha tests -> S32A_Opaque_BlitRow32_{arm,neon} |
reed | 6c22573 | 2014-06-09 19:52:07 -0700 | [diff] [blame] | 326 | DEF_BENCH( return new SourceAlphaBitmapBench(SourceAlphaBitmapBench::kOpaque_SourceAlpha, kN32_SkColorType); ) |
| 327 | DEF_BENCH( return new SourceAlphaBitmapBench(SourceAlphaBitmapBench::kTransparent_SourceAlpha, kN32_SkColorType); ) |
| 328 | DEF_BENCH( return new SourceAlphaBitmapBench(SourceAlphaBitmapBench::kTwoStripes_SourceAlpha, kN32_SkColorType); ) |
| 329 | DEF_BENCH( return new SourceAlphaBitmapBench(SourceAlphaBitmapBench::kThreeStripes_SourceAlpha, kN32_SkColorType); ) |