hide SkBitmap::setConfig

bench/BitmapBench.cpp

-
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
+
 #include "SkBenchmark.h"
 #include "SkBitmap.h"
 #include "SkPaint.h"
 #include "SkCanvas.h"
 #include "SkColorPriv.h"
 #include "SkRandom.h"
 #include "SkString.h"
-
-static const char* gConfigName[] = {
-    "ERROR", "a1", "a8", "index8", "565", "4444", "8888"
-};
+#include "sk_tool_utils.h"
 
 static int conv6ToByte(int x) {
     return x * 0xFF / 5;
 }
 
 static int convByteTo6(int x) {
     return x * 5 / 255;
 }
 
 static uint8_t compute666Index(SkPMColor c) {
     int r = SkGetPackedR32(c);
     int g = SkGetPackedG32(c);
     int b = SkGetPackedB32(c);
 
     return convByteTo6(r) * 36 + convByteTo6(g) * 6 + convByteTo6(b);
 }
 
-static void convertToIndex666(const SkBitmap& src, SkBitmap* dst, bool isOpaque) {
+static void convertToIndex666(const SkBitmap& src, SkBitmap* dst, SkAlphaType aType) {
     SkPMColor storage[216];
     SkPMColor* colors = storage;
     // rrr ggg bbb
     for (int r = 0; r < 6; r++) {
         int rr = conv6ToByte(r);
         for (int g = 0; g < 6; g++) {
             int gg = conv6ToByte(g);
             for (int b = 0; b < 6; b++) {
                 int bb = conv6ToByte(b);
                 *colors++ = SkPreMultiplyARGB(0xFF, rr, gg, bb);
             }
         }
     }
-    SkColorTable* ctable = new SkColorTable(storage, 216,
-                         isOpaque ? kOpaque_SkAlphaType : kPremul_SkAlphaType);
-    dst->setConfig(SkBitmap::kIndex8_Config, src.width(), src.height());
-    dst->allocPixels(ctable);
+    SkColorTable* ctable = new SkColorTable(storage, 216, aType);
+    dst->allocPixels(SkImageInfo::Make(src.width(), src.height(), kIndex_8_SkColorType, aType),
+                     NULL, ctable);
     ctable->unref();
 
     SkAutoLockPixels alps(src);
     SkAutoLockPixels alpd(*dst);
 
     for (int y = 0; y < src.height(); y++) {
         const SkPMColor* srcP = src.getAddr32(0, y);
         uint8_t* dstP = dst->getAddr8(0, y);
         for (int x = src.width() - 1; x >= 0; --x) {
             *dstP++ = compute666Index(*srcP++);
         }
     }
 }
 
 /*  Variants for bitmaps
 
     - src depth (32 w+w/o alpha), 565, 4444, index, a8
     - paint options: filtering, dither, alpha
     - matrix options: translate, scale, rotate, persp
     - tiling: none, repeat, mirror, clamp
 
  */
 
 class BitmapBench : public SkBenchmark {
-    SkBitmap    fBitmap;
-    SkPaint     fPaint;
-    bool        fIsOpaque;
-    bool        fForceUpdate; //bitmap marked as dirty before each draw. forces bitmap to be updated on device cache
-    bool        fIsVolatile;
-    SkBitmap::Config fConfig;
-    SkString    fName;
+    const SkColorType   fColorType;
+    const SkAlphaType   fAlphaType;
+    const bool          fForceUpdate; //bitmap marked as dirty before each draw. forces bitmap to be updated on device cache
+    const bool          fIsVolatile;
+
+    SkBitmap            fBitmap;
+    SkPaint             fPaint;
+    SkString            fName;
+
     enum { W = 128 };
     enum { H = 128 };
 public:
-    BitmapBench(bool isOpaque, SkBitmap::Config c,
-                bool forceUpdate = false, bool bitmapVolatile = false)
-        : fIsOpaque(isOpaque)
+    BitmapBench(SkColorType ct, SkAlphaType at, bool forceUpdate = false, bool isVolatile = false)
+        : fColorType(ct)
+        , fAlphaType(at)
         , fForceUpdate(forceUpdate)
-        , fIsVolatile(bitmapVolatile)
-        , fConfig(c) {
-    }
+        , fIsVolatile(isVolatile)
+    {}
 
 protected:
     virtual const char* onGetName() {
         fName.set("bitmap");
-        fName.appendf("_%s%s", gConfigName[fConfig],
-                      fIsOpaque ? "" : "_A");
+        fName.appendf("_%s%s", sk_tool_utils::colortype_name(fColorType),
+                      kOpaque_SkAlphaType == fAlphaType ? "" : "_A");
         if (fForceUpdate)
             fName.append("_update");
         if (fIsVolatile)
             fName.append("_volatile");
 
         return fName.c_str();
     }
 
     virtual void onPreDraw() {
         SkBitmap bm;
 
-        if (SkBitmap::kIndex8_Config == fConfig) {
-            bm.setConfig(SkBitmap::kARGB_8888_Config, W, H);
+        if (kIndex_8_SkColorType == fColorType) {
+            bm.setInfo(SkImageInfo::MakeN32(W, H, fAlphaType));
         } else {
-            bm.setConfig(fConfig, W, H);
+            bm.setInfo(SkImageInfo::Make(W, H, fColorType, fAlphaType));
         }
 
         bm.allocPixels();
-        bm.eraseColor(fIsOpaque ? SK_ColorBLACK : 0);
+        bm.eraseColor(kOpaque_SkAlphaType == fAlphaType ? SK_ColorBLACK : 0);
 
         onDrawIntoBitmap(bm);
 
-        if (SkBitmap::kIndex8_Config == fConfig) {
-            convertToIndex666(bm, &fBitmap, fIsOpaque);
+        if (kIndex_8_SkColorType == fColorType) {
+            convertToIndex666(bm, &fBitmap, fAlphaType);
         } else {
             fBitmap = bm;
         }
 
-        fBitmap.setAlphaType(fIsOpaque ? kOpaque_SkAlphaType : kPremul_SkAlphaType);
         fBitmap.setIsVolatile(fIsVolatile);
     }
 
     virtual void onDraw(const int loops, SkCanvas* canvas) {
         SkIPoint dim = this->getSize();
         SkRandom rand;
 
         SkPaint paint(fPaint);
         this->setupPaint(&paint);
 
@@ skipping 50 matching lines @@
 }
 
 static bool isBicubic(uint32_t flags) {
     return (flags & (kBilerp_Flag | kBicubic_Flag)) == (kBilerp_Flag | kBicubic_Flag);
 }
 
 class FilterBitmapBench : public BitmapBench {
     uint32_t    fFlags;
     SkString    fFullName;
 public:
-    FilterBitmapBench(bool isOpaque, SkBitmap::Config c,
+    FilterBitmapBench(SkColorType ct, SkAlphaType at,
                       bool forceUpdate, bool isVolitile, uint32_t flags)
-        : INHERITED(isOpaque, c, forceUpdate, isVolitile)
+        : INHERITED(ct, at, forceUpdate, isVolitile)
         , fFlags(flags) {
     }
 
 protected:
     virtual const char* onGetName() {
         fFullName.set(INHERITED::onGetName());
         if (fFlags & kScale_Flag) {
             fFullName.append("_scale");
         }
         if (fFlags & kRotate_Flag) {
@@ skipping 56 matching lines @@
 /** Verify optimizations that test source alpha values. */
 
 class SourceAlphaBitmapBench : public BitmapBench {
 public:
     enum SourceAlpha { kOpaque_SourceAlpha, kTransparent_SourceAlpha,
                        kTwoStripes_SourceAlpha, kThreeStripes_SourceAlpha};
 private:
     SkString    fFullName;
     SourceAlpha fSourceAlpha;
 public:
-    SourceAlphaBitmapBench(SourceAlpha alpha, SkBitmap::Config c,
+    SourceAlphaBitmapBench(SourceAlpha alpha, SkColorType ct,
                 bool forceUpdate = false, bool bitmapVolatile = false)
-        : INHERITED(false, c, forceUpdate, bitmapVolatile)
+        : INHERITED(ct, kPremul_SkAlphaType, forceUpdate, bitmapVolatile)
         , fSourceAlpha(alpha) {
     }
 
 protected:
     virtual const char* onGetName() {
         fFullName.set(INHERITED::onGetName());
 
         if (fSourceAlpha == kOpaque_SourceAlpha) {
                 fFullName.append("_source_opaque");
         } else if (fSourceAlpha == kTransparent_SourceAlpha) {
@@ skipping 56 matching lines @@
                 r.set(SkIntToScalar(x), 0, SkIntToScalar(x+1), SkIntToScalar(h));
                 canvas.drawRect(r, p);
             }
         }
     }
 
 private:
     typedef BitmapBench INHERITED;
 };
 
-DEF_BENCH( return new BitmapBench(false, SkBitmap::kARGB_8888_Config); )
-DEF_BENCH( return new BitmapBench(true, SkBitmap::kARGB_8888_Config); )
-DEF_BENCH( return new BitmapBench(true, SkBitmap::kRGB_565_Config); )
-DEF_BENCH( return new BitmapBench(false, SkBitmap::kIndex8_Config); )
-DEF_BENCH( return new BitmapBench(true, SkBitmap::kIndex8_Config); )
-DEF_BENCH( return new BitmapBench(true, SkBitmap::kARGB_8888_Config, true, true); )
-DEF_BENCH( return new BitmapBench(true, SkBitmap::kARGB_8888_Config, true, false); )
+DEF_BENCH( return new BitmapBench(kN32_SkColorType, kPremul_SkAlphaType); )
+DEF_BENCH( return new BitmapBench(kN32_SkColorType, kOpaque_SkAlphaType); )
+DEF_BENCH( return new BitmapBench(kRGB_565_SkColorType, kOpaque_SkAlphaType); )
+DEF_BENCH( return new BitmapBench(kIndex_8_SkColorType, kPremul_SkAlphaType); )
+DEF_BENCH( return new BitmapBench(kIndex_8_SkColorType, kOpaque_SkAlphaType); )
+DEF_BENCH( return new BitmapBench(kN32_SkColorType, kOpaque_SkAlphaType, true, true); )
+DEF_BENCH( return new BitmapBench(kN32_SkColorType, kOpaque_SkAlphaType, true, false); )
 
 // scale filter -> S32_opaque_D32_filter_DX_{SSE2,SSSE3} and Fact9 is also for S32_D16_filter_DX_SSE2
-DEF_BENCH( return new FilterBitmapBench(false, SkBitmap::kARGB_8888_Config, false, false, kScale_Flag | kBilerp_Flag); )
-DEF_BENCH( return new FilterBitmapBench(true, SkBitmap::kARGB_8888_Config, false, false, kScale_Flag | kBilerp_Flag); )
-DEF_BENCH( return new FilterBitmapBench(true, SkBitmap::kARGB_8888_Config, true, true, kScale_Flag | kBilerp_Flag); )
-DEF_BENCH( return new FilterBitmapBench(true, SkBitmap::kARGB_8888_Config, true, false, kScale_Flag | kBilerp_Flag); )
+DEF_BENCH( return new FilterBitmapBench(kN32_SkColorType, kPremul_SkAlphaType, false, false, kScale_Flag | kBilerp_Flag); )
+DEF_BENCH( return new FilterBitmapBench(kN32_SkColorType, kOpaque_SkAlphaType, false, false, kScale_Flag | kBilerp_Flag); )
+DEF_BENCH( return new FilterBitmapBench(kN32_SkColorType, kOpaque_SkAlphaType, true, true, kScale_Flag | kBilerp_Flag); )
+DEF_BENCH( return new FilterBitmapBench(kN32_SkColorType, kOpaque_SkAlphaType, true, false, kScale_Flag | kBilerp_Flag); )
 
 // scale rotate filter -> S32_opaque_D32_filter_DXDY_{SSE2,SSSE3}
-DEF_BENCH( return new FilterBitmapBench(false, SkBitmap::kARGB_8888_Config, false, false, kScale_Flag | kRotate_Flag | kBilerp_Flag); )
-DEF_BENCH( return new FilterBitmapBench(true, SkBitmap::kARGB_8888_Config, false, false, kScale_Flag | kRotate_Flag | kBilerp_Flag); )
-DEF_BENCH( return new FilterBitmapBench(true, SkBitmap::kARGB_8888_Config, true, true, kScale_Flag | kRotate_Flag | kBilerp_Flag); )
-DEF_BENCH( return new FilterBitmapBench(true, SkBitmap::kARGB_8888_Config, true, false, kScale_Flag | kRotate_Flag | kBilerp_Flag); )
+DEF_BENCH( return new FilterBitmapBench(kN32_SkColorType, kPremul_SkAlphaType, false, false, kScale_Flag | kRotate_Flag | kBilerp_Flag); )
+DEF_BENCH( return new FilterBitmapBench(kN32_SkColorType, kOpaque_SkAlphaType, false, false, kScale_Flag | kRotate_Flag | kBilerp_Flag); )
+DEF_BENCH( return new FilterBitmapBench(kN32_SkColorType, kOpaque_SkAlphaType, true, true, kScale_Flag | kRotate_Flag | kBilerp_Flag); )
+DEF_BENCH( return new FilterBitmapBench(kN32_SkColorType, kOpaque_SkAlphaType, true, false, kScale_Flag | kRotate_Flag | kBilerp_Flag); )
 
-DEF_BENCH( return new FilterBitmapBench(false, SkBitmap::kARGB_8888_Config, false, false, kScale_Flag | kBilerp_Flag | kBicubic_Flag); )
-DEF_BENCH( return new FilterBitmapBench(false, SkBitmap::kARGB_8888_Config, false, false, kScale_Flag | kRotate_Flag | kBilerp_Flag | kBicubic_Flag); )
+DEF_BENCH( return new FilterBitmapBench(kN32_SkColorType, kPremul_SkAlphaType, false, false, kScale_Flag | kBilerp_Flag | kBicubic_Flag); )
+DEF_BENCH( return new FilterBitmapBench(kN32_SkColorType, kPremul_SkAlphaType, false, false, kScale_Flag | kRotate_Flag | kBilerp_Flag | kBicubic_Flag); )
 
 // source alpha tests -> S32A_Opaque_BlitRow32_{arm,neon}
-DEF_BENCH( return new SourceAlphaBitmapBench(SourceAlphaBitmapBench::kOpaque_SourceAlpha, SkBitmap::kARGB_8888_Config); )
-DEF_BENCH( return new SourceAlphaBitmapBench(SourceAlphaBitmapBench::kTransparent_SourceAlpha, SkBitmap::kARGB_8888_Config); )
-DEF_BENCH( return new SourceAlphaBitmapBench(SourceAlphaBitmapBench::kTwoStripes_SourceAlpha, SkBitmap::kARGB_8888_Config); )
-DEF_BENCH( return new SourceAlphaBitmapBench(SourceAlphaBitmapBench::kThreeStripes_SourceAlpha, SkBitmap::kARGB_8888_Config); )
+DEF_BENCH( return new SourceAlphaBitmapBench(SourceAlphaBitmapBench::kOpaque_SourceAlpha, kN32_SkColorType); )
+DEF_BENCH( return new SourceAlphaBitmapBench(SourceAlphaBitmapBench::kTransparent_SourceAlpha, kN32_SkColorType); )
+DEF_BENCH( return new SourceAlphaBitmapBench(SourceAlphaBitmapBench::kTwoStripes_SourceAlpha, kN32_SkColorType); )
+DEF_BENCH( return new SourceAlphaBitmapBench(SourceAlphaBitmapBench::kThreeStripes_SourceAlpha, kN32_SkColorType); )