diff options
51 files changed, 347 insertions, 439 deletions
diff --git a/bench/BitmapBench.cpp b/bench/BitmapBench.cpp index 2b0cabfc37..e877bd472d 100644 --- a/bench/BitmapBench.cpp +++ b/bench/BitmapBench.cpp @@ -1,10 +1,10 @@ - /* * 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" @@ -12,10 +12,7 @@ #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; @@ -33,7 +30,7 @@ static uint8_t compute666Index(SkPMColor 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 @@ -47,10 +44,9 @@ static void convertToIndex666(const SkBitmap& src, SkBitmap* dst, bool isOpaque) } } } - 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); @@ -75,29 +71,30 @@ static void convertToIndex666(const SkBitmap& src, SkBitmap* dst, bool isOpaque) */ 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) @@ -109,24 +106,23 @@ protected: 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); } @@ -197,9 +193,9 @@ 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) { } @@ -276,9 +272,9 @@ 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) { } @@ -355,31 +351,31 @@ 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); ) diff --git a/bench/BitmapRectBench.cpp b/bench/BitmapRectBench.cpp index affed723d9..32589fc38d 100644 --- a/bench/BitmapRectBench.cpp +++ b/bench/BitmapRectBench.cpp @@ -55,7 +55,7 @@ public: fFilterLevel = filterLevel; fSlightMatrix = slightMatrix; - fBitmap.setConfig(SkBitmap::kARGB_8888_Config, kWidth, kHeight); + fBitmap.setInfo(SkImageInfo::MakeN32Premul(kWidth, kHeight)); } protected: diff --git a/bench/BitmapScaleBench.cpp b/bench/BitmapScaleBench.cpp index f6c2da17a9..93e10fa43c 100644 --- a/bench/BitmapScaleBench.cpp +++ b/bench/BitmapScaleBench.cpp @@ -57,14 +57,10 @@ protected: } virtual void onPreDraw() { - fInputBitmap.setConfig(SkBitmap::kARGB_8888_Config, - fInputSize, fInputSize, 0, kOpaque_SkAlphaType); - fInputBitmap.allocPixels(); + fInputBitmap.allocN32Pixels(fInputSize, fInputSize, true); fInputBitmap.eraseColor(SK_ColorWHITE); - fOutputBitmap.setConfig(SkBitmap::kARGB_8888_Config, - fOutputSize, fOutputSize, 0, kOpaque_SkAlphaType); - fOutputBitmap.allocPixels(); + fOutputBitmap.allocN32Pixels(fOutputSize, fOutputSize, true); fMatrix.setScale( scale(), scale() ); } diff --git a/bench/BlurImageFilterBench.cpp b/bench/BlurImageFilterBench.cpp index bd36b5b3c4..7739730a77 100644 --- a/bench/BlurImageFilterBench.cpp +++ b/bench/BlurImageFilterBench.cpp @@ -55,10 +55,8 @@ private: void make_checkerboard() { const int w = fIsSmall ? FILTER_WIDTH_SMALL : FILTER_WIDTH_LARGE; const int h = fIsSmall ? FILTER_HEIGHT_LARGE : FILTER_HEIGHT_LARGE; - fCheckerboard.setConfig(SkBitmap::kARGB_8888_Config, w, h); - fCheckerboard.allocPixels(); - SkBitmapDevice device(fCheckerboard); - SkCanvas canvas(&device); + fCheckerboard.allocN32Pixels(w, h); + SkCanvas canvas(fCheckerboard); canvas.clear(0x00000000); SkPaint darkPaint; darkPaint.setColor(0xFF804020); diff --git a/bench/CoverageBench.cpp b/bench/CoverageBench.cpp index 2c84102f7d..0631c179ac 100644 --- a/bench/CoverageBench.cpp +++ b/bench/CoverageBench.cpp @@ -32,8 +32,7 @@ public: fPath.quadTo(500, 0, 500, 500); fPath.quadTo(250, 0, 0, 500); - fBitmap.setConfig(SkBitmap::kA8_Config, 500, 500); - fBitmap.allocPixels(); + fBitmap.allocPixels(SkImageInfo::MakeA8(500, 500)); fIdentity.setIdentity(); fRC.setRect(fPath.getBounds().round()); diff --git a/bench/DisplacementBench.cpp b/bench/DisplacementBench.cpp index 08da9b19af..904f47d842 100644 --- a/bench/DisplacementBench.cpp +++ b/bench/DisplacementBench.cpp @@ -33,10 +33,8 @@ protected: void makeBitmap() { const int w = this->isSmall() ? FILTER_WIDTH_SMALL : FILTER_WIDTH_LARGE; const int h = this->isSmall() ? FILTER_HEIGHT_LARGE : FILTER_HEIGHT_LARGE; - fBitmap.setConfig(SkBitmap::kARGB_8888_Config, w, h); - fBitmap.allocPixels(); - SkBitmapDevice device(fBitmap); - SkCanvas canvas(&device); + fBitmap.allocN32Pixels(w, h); + SkCanvas canvas(fBitmap); canvas.clear(0x00000000); SkPaint paint; paint.setAntiAlias(true); @@ -49,10 +47,8 @@ protected: void makeCheckerboard() { const int w = this->isSmall() ? FILTER_WIDTH_SMALL : FILTER_WIDTH_LARGE; const int h = this->isSmall() ? FILTER_HEIGHT_LARGE : FILTER_HEIGHT_LARGE; - fCheckerboard.setConfig(SkBitmap::kARGB_8888_Config, w, h); - fCheckerboard.allocPixels(); - SkBitmapDevice device(fCheckerboard); - SkCanvas canvas(&device); + fCheckerboard.allocN32Pixels(w, h); + SkCanvas canvas(fCheckerboard); canvas.clear(0x00000000); SkPaint darkPaint; darkPaint.setColor(0xFF804020); diff --git a/bench/GameBench.cpp b/bench/GameBench.cpp index c0a0e1b1b3..d197f3e170 100644 --- a/bench/GameBench.cpp +++ b/bench/GameBench.cpp @@ -248,9 +248,7 @@ private: void makeCheckerboard() { static int kCheckSize = 16; - fCheckerboard.setConfig(SkBitmap::kARGB_8888_Config, - kCheckerboardWidth, kCheckerboardHeight); - fCheckerboard.allocPixels(); + fCheckerboard.allocN32Pixels(kCheckerboardWidth, kCheckerboardHeight); SkAutoLockPixels lock(fCheckerboard); for (int y = 0; y < kCheckerboardHeight; ++y) { int even = (y / kCheckSize) % 2; @@ -283,8 +281,7 @@ private: } } - fAtlas.setConfig(SkBitmap::kARGB_8888_Config, kTotAtlasWidth, kTotAtlasHeight); - fAtlas.allocPixels(); + fAtlas.allocN32Pixels(kTotAtlasWidth, kTotAtlasHeight); SkAutoLockPixels lock(fAtlas); for (int y = 0; y < kTotAtlasHeight; ++y) { diff --git a/bench/ImageCacheBench.cpp b/bench/ImageCacheBench.cpp index 9fc538ebef..ef29cf88ff 100644 --- a/bench/ImageCacheBench.cpp +++ b/bench/ImageCacheBench.cpp @@ -18,16 +18,14 @@ class ImageCacheBench : public SkBenchmark { }; public: ImageCacheBench() : fCache(CACHE_COUNT * 100) { - fBM.setConfig(SkBitmap::kARGB_8888_Config, DIM, DIM); - fBM.allocPixels(); + fBM.allocN32Pixels(DIM, DIM); } void populateCache() { SkScalar scale = 1; for (int i = 0; i < CACHE_COUNT; ++i) { SkBitmap tmp; - tmp.setConfig(SkBitmap::kARGB_8888_Config, 1, 1); - tmp.allocPixels(); + tmp.allocN32Pixels(1, 1); fCache.unlock(fCache.addAndLock(fBM, scale, scale, tmp)); scale += 1; } diff --git a/bench/MagnifierBench.cpp b/bench/MagnifierBench.cpp index 3ef2062c4e..e4a51815d4 100644 --- a/bench/MagnifierBench.cpp +++ b/bench/MagnifierBench.cpp @@ -53,10 +53,8 @@ private: void make_checkerboard() { const int w = fIsSmall ? FILTER_WIDTH_SMALL : FILTER_WIDTH_LARGE; const int h = fIsSmall ? FILTER_HEIGHT_LARGE : FILTER_HEIGHT_LARGE; - fCheckerboard.setConfig(SkBitmap::kARGB_8888_Config, w, h); - fCheckerboard.allocPixels(); - SkBitmapDevice device(fCheckerboard); - SkCanvas canvas(&device); + fCheckerboard.allocN32Pixels(w, h); + SkCanvas canvas(fCheckerboard); canvas.clear(0x00000000); SkPaint darkPaint; darkPaint.setColor(0xFF804020); diff --git a/bench/MergeBench.cpp b/bench/MergeBench.cpp index cec0ea93e4..9f16449a82 100644 --- a/bench/MergeBench.cpp +++ b/bench/MergeBench.cpp @@ -52,10 +52,8 @@ private: } void make_bitmap() { - fBitmap.setConfig(SkBitmap::kARGB_8888_Config, 80, 80); - fBitmap.allocPixels(); - SkBitmapDevice device(fBitmap); - SkCanvas canvas(&device); + fBitmap.allocN32Pixels(80, 80); + SkCanvas canvas(fBitmap); canvas.clear(0x00000000); SkPaint paint; paint.setAntiAlias(true); @@ -66,10 +64,8 @@ private: } void make_checkerboard() { - fCheckerboard.setConfig(SkBitmap::kARGB_8888_Config, 80, 80); - fCheckerboard.allocPixels(); - SkBitmapDevice device(fCheckerboard); - SkCanvas canvas(&device); + fCheckerboard.allocN32Pixels(80, 80); + SkCanvas canvas(fCheckerboard); canvas.clear(0x00000000); SkPaint darkPaint; darkPaint.setColor(0xFF804020); diff --git a/bench/PictureRecordBench.cpp b/bench/PictureRecordBench.cpp index 0666cc4211..f890e0d4f6 100644 --- a/bench/PictureRecordBench.cpp +++ b/bench/PictureRecordBench.cpp @@ -85,8 +85,8 @@ protected: // create a simple bitmap SkBitmap bitmap; - bitmap.setConfig(SkBitmap::kRGB_565_Config, 10, 10); - bitmap.allocPixels(); + bitmap.allocPixels(SkImageInfo::Make(10, 10, + kRGB_565_SkColorType, kOpaque_SkAlphaType)); // draw a single color into the bitmap SkCanvas bitmapCanvas(bitmap); diff --git a/bench/ReadPixBench.cpp b/bench/ReadPixBench.cpp index f761e3306c..805aaeb5f8 100644 --- a/bench/ReadPixBench.cpp +++ b/bench/ReadPixBench.cpp @@ -43,7 +43,7 @@ protected: SkBitmap bitmap; - bitmap.setConfig(SkBitmap::kARGB_8888_Config, kWindowSize, kWindowSize); + bitmap.setInfo(SkImageInfo::MakeN32Premul(kWindowSize, kWindowSize)); for (int i = 0; i < loops; i++) { for (int x = 0; x < kNumStepsX; ++x) { diff --git a/bench/RectBench.cpp b/bench/RectBench.cpp index 901304442f..a2029e601f 100644 --- a/bench/RectBench.cpp +++ b/bench/RectBench.cpp @@ -263,8 +263,7 @@ protected: paint.setStrokeCap(SkPaint::kRound_Cap); if (_type == KMaskShader) { SkBitmap srcBM; - srcBM.setConfig(SkBitmap::kARGB_8888_Config, 10, 1); - srcBM.allocPixels(); + srcBM.allocN32Pixels(10, 1); srcBM.eraseColor(0xFF00FF00); SkShader* s; diff --git a/bench/RepeatTileBench.cpp b/bench/RepeatTileBench.cpp index fcbffb2a10..0e33ec0281 100644 --- a/bench/RepeatTileBench.cpp +++ b/bench/RepeatTileBench.cpp @@ -12,10 +12,7 @@ #include "SkPaint.h" #include "SkShader.h" #include "SkString.h" - -static const char* gConfigName[] = { - "ERROR", "a1", "a8", "index8", "565", "4444", "8888" -}; +#include "sk_tool_utils.h" static void draw_into_bitmap(const SkBitmap& bm) { const int w = bm.width(); @@ -52,8 +49,7 @@ static uint8_t compute_666_index(SkPMColor c) { return conv_byte_to_6(r) * 36 + conv_byte_to_6(g) * 6 + conv_byte_to_6(b); } -static void convert_to_index666(const SkBitmap& src, SkBitmap* dst, - bool isOpaque) { +static void convert_to_index666(const SkBitmap& src, SkBitmap* dst) { SkPMColor storage[216]; SkPMColor* colors = storage; // rrr ggg bbb @@ -67,10 +63,10 @@ static void convert_to_index666(const SkBitmap& src, SkBitmap* dst, } } } - SkAlphaType aType = isOpaque ? kOpaque_SkAlphaType : kPremul_SkAlphaType; - SkColorTable* ctable = new SkColorTable(storage, 216, aType); - dst->setConfig(SkBitmap::kIndex8_Config, src.width(), src.height()); - dst->allocPixels(ctable); + SkColorTable* ctable = new SkColorTable(storage, 216, kOpaque_SkAlphaType); + dst->allocPixels(SkImageInfo::Make(src.width(), src.height(), + kIndex_8_SkColorType, kOpaque_SkAlphaType), + NULL, ctable); ctable->unref(); SkAutoLockPixels alps(src); @@ -86,25 +82,25 @@ static void convert_to_index666(const SkBitmap& src, SkBitmap* dst, } class RepeatTileBench : public SkBenchmark { - SkPaint fPaint; - SkString fName; - SkBitmap fBitmap; - bool fIsOpaque; - SkBitmap::Config fConfig; + const SkColorType fColorType; + const SkAlphaType fAlphaType; + SkPaint fPaint; + SkString fName; + SkBitmap fBitmap; public: - RepeatTileBench(SkBitmap::Config c, bool isOpaque = false) { + RepeatTileBench(SkColorType ct, SkAlphaType at = kPremul_SkAlphaType) + : fColorType(ct), fAlphaType(at) + { const int w = 50; const int h = 50; - fConfig = c; - fIsOpaque = isOpaque; - if (SkBitmap::kIndex8_Config == fConfig) { - fBitmap.setConfig(SkBitmap::kARGB_8888_Config, w, h); + if (kIndex_8_SkColorType == ct) { + fBitmap.setInfo(SkImageInfo::MakeN32(w, h, at)); } else { - fBitmap.setConfig(fConfig, w, h); + fBitmap.setInfo(SkImageInfo::Make(w, h, ct, at)); } fName.printf("repeatTile_%s_%c", - gConfigName[fBitmap.config()], isOpaque ? 'X' : 'A'); + sk_tool_utils::colortype_name(ct), kOpaque_SkAlphaType == at ? 'X' : 'A'); } protected: @@ -114,15 +110,13 @@ protected: virtual void onPreDraw() SK_OVERRIDE { fBitmap.allocPixels(); - fBitmap.eraseColor(fIsOpaque ? SK_ColorWHITE : 0); - fBitmap.setAlphaType(fIsOpaque ? - kOpaque_SkAlphaType : kPremul_SkAlphaType); + fBitmap.eraseColor(kOpaque_SkAlphaType == fAlphaType ? SK_ColorWHITE : 0); draw_into_bitmap(fBitmap); - if (SkBitmap::kIndex8_Config == fConfig) { + if (kIndex_8_SkColorType == fColorType) { SkBitmap tmp; - convert_to_index666(fBitmap, &tmp, fIsOpaque); + convert_to_index666(fBitmap, &tmp); fBitmap = tmp; } @@ -146,7 +140,7 @@ private: typedef SkBenchmark INHERITED; }; -DEF_BENCH(return new RepeatTileBench(SkBitmap::kARGB_8888_Config, true)) -DEF_BENCH(return new RepeatTileBench(SkBitmap::kARGB_8888_Config, false)) -DEF_BENCH(return new RepeatTileBench(SkBitmap::kRGB_565_Config)) -DEF_BENCH(return new RepeatTileBench(SkBitmap::kIndex8_Config)) +DEF_BENCH(return new RepeatTileBench(kN32_SkColorType, kOpaque_SkAlphaType)) +DEF_BENCH(return new RepeatTileBench(kN32_SkColorType, kPremul_SkAlphaType)) +DEF_BENCH(return new RepeatTileBench(kRGB_565_SkColorType, kOpaque_SkAlphaType)) +DEF_BENCH(return new RepeatTileBench(kIndex_8_SkColorType, kPremul_SkAlphaType)) diff --git a/bench/TileBench.cpp b/bench/TileBench.cpp index 9a9e27e951..12c9629ee2 100644 --- a/bench/TileBench.cpp +++ b/bench/TileBench.cpp @@ -48,9 +48,7 @@ public: , fDoScale(doScale) { SkBitmap bm; - bm.setConfig(SkBitmap::kARGB_8888_Config, kWidth, kHeight, 0, - kOpaque_SkAlphaType); - bm.allocPixels(); + bm.allocN32Pixels(kWidth, kHeight, true); bm.eraseColor(SK_ColorWHITE); create_gradient(&bm); diff --git a/debugger/QT/SkRasterWidget.cpp b/debugger/QT/SkRasterWidget.cpp index d78e5f8559..705fdf0bd8 100644 --- a/debugger/QT/SkRasterWidget.cpp +++ b/debugger/QT/SkRasterWidget.cpp @@ -9,8 +9,7 @@ #include "SkRasterWidget.h" SkRasterWidget::SkRasterWidget(SkDebugger *debugger) : QWidget() { - fBitmap.setConfig(SkBitmap::kARGB_8888_Config, 800, 800); - fBitmap.allocPixels(); + fBitmap.allocN32Pixels(800, 800); fBitmap.eraseColor(SK_ColorTRANSPARENT); fDevice = new SkBitmapDevice(fBitmap); fDebugger = debugger; @@ -24,8 +23,7 @@ SkRasterWidget::~SkRasterWidget() { } void SkRasterWidget::resizeEvent(QResizeEvent* event) { - fBitmap.setConfig(SkBitmap::kARGB_8888_Config, event->size().width(), event->size().height()); - fBitmap.allocPixels(); + fBitmap.allocN32Pixels(event->size().width(), event->size().height()); fBitmap.eraseColor(SK_ColorTRANSPARENT); SkSafeUnref(fCanvas); SkSafeUnref(fDevice); diff --git a/experimental/PdfViewer/chop_transparency_main.cpp b/experimental/PdfViewer/chop_transparency_main.cpp index 7dbf3fcb14..b6a104cc59 100644 --- a/experimental/PdfViewer/chop_transparency_main.cpp +++ b/experimental/PdfViewer/chop_transparency_main.cpp @@ -58,9 +58,7 @@ static SkISize opaqueSize(const SkBitmap& bm) { } static void setup_bitmap(SkBitmap* bitmap, int width, int height) { - bitmap->setConfig(SkBitmap::kARGB_8888_Config, width, height); - - bitmap->allocPixels(); + bitmap->allocN32Pixels(width, height); } diff --git a/experimental/PdfViewer/pdf_viewer_main.cpp b/experimental/PdfViewer/pdf_viewer_main.cpp index 6395585c4d..2f1a055e4d 100644 --- a/experimental/PdfViewer/pdf_viewer_main.cpp +++ b/experimental/PdfViewer/pdf_viewer_main.cpp @@ -110,9 +110,7 @@ static bool make_output_filepath(SkString* path, const SkString& dir, } static void setup_bitmap(SkBitmap* bitmap, int width, int height, SkColor color) { - bitmap->setConfig(SkBitmap::kARGB_8888_Config, width, height); - - bitmap->allocPixels(); + bitmap->allocN32Pixels(width, height); bitmap->eraseColor(color); } diff --git a/experimental/PdfViewer/src/SkPdfRenderer.cpp b/experimental/PdfViewer/src/SkPdfRenderer.cpp index eea7c6e477..0995344093 100644 --- a/experimental/PdfViewer/src/SkPdfRenderer.cpp +++ b/experimental/PdfViewer/src/SkPdfRenderer.cpp @@ -232,9 +232,7 @@ private: // Utilities static void setup_bitmap(SkBitmap* bitmap, int width, int height, SkColor color = SK_ColorWHITE) { - bitmap->setConfig(SkBitmap::kARGB_8888_Config, width, height); - - bitmap->allocPixels(); + bitmap->allocN32Pixels(width, height); bitmap->eraseColor(color); } @@ -398,8 +396,8 @@ static SkBitmap* transferImageStreamToBitmap(const unsigned char* uncompressedSt uncompressedStream += bytesPerLine; } - bitmap->setConfig(SkBitmap::kARGB_8888_Config, width, height); - bitmap->setPixels(uncompressedStreamArgb); + const SkImageInfo info = SkImageInfo::MakeN32Premul(width, height); + bitmap->installPixels(info, uncompressedStreamArgb, info.minRowBytes()); } else if ((colorSpace.equals("DeviceGray") || colorSpace.equals("Gray")) && bpc == 8) { unsigned char* uncompressedStreamA8 = (unsigned char*)malloc(width * height); @@ -414,9 +412,10 @@ static SkBitmap* transferImageStreamToBitmap(const unsigned char* uncompressedSt uncompressedStream += bytesPerLine; } - bitmap->setConfig(transparencyMask ? SkBitmap::kA8_Config : SkBitmap::kIndex8_Config, - width, height); - bitmap->setPixels(uncompressedStreamA8, transparencyMask ? NULL : getGrayColortable()); + const SkColorType ct = transparencyMask ? kAlpha_8_SkColorType : kIndex_8_SkColorType; + const SkImageInfo info = SkImageInfo::Make(width, height, ct, kPremul_SkAlphaType); + bitmap->installPixels(info, uncompressedStreamA8, info.minRowBytes(), + transparencyMask ? NULL : getGrayColortable(), NULL, NULL); } // TODO(edisonn): pass color space and context here? @@ -519,9 +518,11 @@ static SkBitmap* getImageFromObjectCore(SkPdfContext* pdfContext, // TODO(edisonn): assumes RGB for now, since it is the only one implemented if (indexed) { SkBitmap* bitmap = new SkBitmap(); - bitmap->setConfig(SkBitmap::kIndex8_Config, width, height); - SkColorTable* colorTable = new SkColorTable(colors, cnt); - bitmap->setPixels((void*)uncompressedStream, colorTable); + const SkImageInfo info = SkImageInfo::Make(width, height, kIndex_8_SkColorType, + kPremul_SkAlphaType); + SkAutoTUnref<SkColorTable> colorTable(new SkColorTable(colors, cnt)); + bitmap->installPixels(info, (void*)uncompressedStream, info.minRowBytes(), colorTable, + NULL, NULL); return bitmap; } diff --git a/gm/stroketext.cpp b/gm/stroketext.cpp index 4f57cf6c41..13c64fa4cc 100644 --- a/gm/stroketext.cpp +++ b/gm/stroketext.cpp @@ -11,7 +11,7 @@ static void test_nulldev(SkCanvas* canvas) { SkBitmap bm; - bm.setConfig(SkBitmap::kARGB_8888_Config, 30, 30); + bm.setInfo(SkImageInfo::MakeN32Premul(30, 30)); // notice: no pixels mom! be sure we don't crash // https://code.google.com/p/chromium/issues/detail?id=352616 SkCanvas c(bm); diff --git a/gyp/skia_for_android_framework_defines.gypi b/gyp/skia_for_android_framework_defines.gypi index e6175cef19..e31a095c0b 100644 --- a/gyp/skia_for_android_framework_defines.gypi +++ b/gyp/skia_for_android_framework_defines.gypi @@ -15,6 +15,7 @@ 'skia_for_android_framework_defines': [ 'SK_SUPPORT_LEGACY_SETCONFIG_INFO', 'SK_SUPPORT_LEGACY_DEVICE_CONFIG', + 'SK_SUPPORT_LEGACY_SETCONFIG', # Needed until we fix skbug.com/2440. 'SK_SUPPORT_LEGACY_CLIPTOLAYERFLAG', # Transitional, for deprecated SkCanvas::SaveFlags methods. diff --git a/gyp/skia_for_chromium_defines.gypi b/gyp/skia_for_chromium_defines.gypi index eff5f238af..30ec2905c3 100644 --- a/gyp/skia_for_chromium_defines.gypi +++ b/gyp/skia_for_chromium_defines.gypi @@ -15,6 +15,7 @@ 'skia_for_chromium_defines': [ 'SK_SUPPORT_LEGACY_GETTOPDEVICE', 'SK_SUPPORT_LEGACY_N32_NAME', + 'SK_SUPPORT_LEGACY_SETCONFIG', 'SK_IGNORE_ETC1_SUPPORT', 'SK_SUPPORT_LEGACY_RECORDING_FLAG', ], diff --git a/include/core/SkBitmap.h b/include/core/SkBitmap.h index 6de95be24e..ddeac2573b 100644 --- a/include/core/SkBitmap.h +++ b/include/core/SkBitmap.h @@ -266,6 +266,7 @@ public: void getBounds(SkRect* bounds) const; void getBounds(SkIRect* bounds) const; +#ifdef SK_SUPPORT_LEGACY_SETCONFIG /** Set the bitmap's config and dimensions. If rowBytes is 0, then ComputeRowBytes() is called to compute the optimal value. This resets any pixel/colortable ownership, just like reset(). @@ -276,6 +277,7 @@ public: return this->setConfig(config, width, height, rowBytes, kPremul_SkAlphaType); } +#endif bool setInfo(const SkImageInfo&, size_t rowBytes = 0); diff --git a/include/core/SkImageDecoder.h b/include/core/SkImageDecoder.h index 950505a4b5..f8e682baf0 100644 --- a/include/core/SkImageDecoder.h +++ b/include/core/SkImageDecoder.h @@ -438,7 +438,7 @@ protected: // helper function for decoders to handle the (common) case where there is only // once choice available in the image file. - bool chooseFromOneChoice(SkBitmap::Config config, int width, int height) const; + bool chooseFromOneChoice(SkColorType, int width, int height) const; /* Helper for subclasses. Call this to allocate the pixel memory given the bitmap's width/height/rowbytes/config. Returns true on success. This method handles checking @@ -457,15 +457,15 @@ protected: // 8 bits per component. Used for 24 bit if there is no alpha. k32Bit_SrcDepth, }; - /** The subclass, inside onDecode(), calls this to determine the config of + /** The subclass, inside onDecode(), calls this to determine the colorType of the returned bitmap. SrcDepth and hasAlpha reflect the raw data of the src image. This routine returns the caller's preference given - srcDepth and hasAlpha, or kNo_Config if there is no preference. + srcDepth and hasAlpha, or kUnknown_SkColorType if there is no preference. Note: this also takes into account GetDeviceConfig(), so the subclass need not call that. */ - SkBitmap::Config getPrefConfig(SrcDepth, bool hasAlpha) const; + SkColorType getPrefColorType(SrcDepth, bool hasAlpha) const; private: Peeker* fPeeker; diff --git a/include/gpu/GrSurface.h b/include/gpu/GrSurface.h index f741c77d2b..a851c9e03c 100644 --- a/include/gpu/GrSurface.h +++ b/include/gpu/GrSurface.h @@ -59,7 +59,7 @@ public: */ const GrTextureDesc& desc() const { return fDesc; } - void asImageInfo(SkImageInfo*) const; + SkImageInfo info() const; /** * @return the texture associated with the surface, may be NULL. diff --git a/src/animator/SkDrawBitmap.cpp b/src/animator/SkDrawBitmap.cpp index 327e81365a..ce96efbed2 100644 --- a/src/animator/SkDrawBitmap.cpp +++ b/src/animator/SkDrawBitmap.cpp @@ -88,7 +88,8 @@ void SkDrawBitmap::onEndElement(SkAnimateMaker&) { SkASSERT(width != -1); SkASSERT(height != -1); SkASSERT(rowBytes >= 0); - fBitmap.setConfig((SkBitmap::Config) format, width, height, rowBytes); + SkColorType colorType = SkBitmapConfigToColorType((SkBitmap::Config)format); + fBitmap.setInfo(SkImageInfo::Make(width, height, colorType, kPremul_SkAlphaType), rowBytes); fBitmap.allocPixels(); if (fColorSet) fBitmap.eraseColor(fColor); diff --git a/src/core/SkBitmap.cpp b/src/core/SkBitmap.cpp index e63b2c4aa9..ab7a511302 100644 --- a/src/core/SkBitmap.cpp +++ b/src/core/SkBitmap.cpp @@ -217,11 +217,13 @@ bool SkBitmap::setInfo(const SkImageInfo& origInfo, size_t rowBytes) { return true; } +#ifdef SK_SUPPORT_LEGACY_SETCONFIG bool SkBitmap::setConfig(Config config, int width, int height, size_t rowBytes, SkAlphaType alphaType) { SkColorType ct = SkBitmapConfigToColorType(config); return this->setInfo(SkImageInfo::Make(width, height, ct, alphaType), rowBytes); } +#endif bool SkBitmap::setAlphaType(SkAlphaType alphaType) { if (!validate_alphaType(fInfo.fColorType, alphaType, &alphaType)) { diff --git a/src/effects/SkMatrixConvolutionImageFilter.cpp b/src/effects/SkMatrixConvolutionImageFilter.cpp index 89e113b8ce..ca2cfcaab7 100644 --- a/src/effects/SkMatrixConvolutionImageFilter.cpp +++ b/src/effects/SkMatrixConvolutionImageFilter.cpp @@ -282,9 +282,7 @@ bool SkMatrixConvolutionImageFilter::onFilterImage(Proxy* proxy, return false; } - result->setConfig(src.config(), bounds.width(), bounds.height()); - result->allocPixels(); - if (!result->getPixels()) { + if (!result->allocPixels(src.info().makeWH(bounds.width(), bounds.height()))) { return false; } diff --git a/src/fonts/SkGScalerContext.cpp b/src/fonts/SkGScalerContext.cpp index 551b01c961..e1ab921337 100644 --- a/src/fonts/SkGScalerContext.cpp +++ b/src/fonts/SkGScalerContext.cpp @@ -119,9 +119,8 @@ void SkGScalerContext::generateImage(const SkGlyph& glyph) { fProxy->getPath(glyph, &path); SkBitmap bm; - bm.setConfig(SkBitmap::kARGB_8888_Config, glyph.fWidth, glyph.fHeight, - glyph.rowBytes()); - bm.setPixels(glyph.fImage); + bm.installPixels(SkImageInfo::MakeN32Premul(glyph.fWidth, glyph.fHeight), + glyph.fImage, glyph.rowBytes()); bm.eraseColor(0); SkCanvas canvas(bm); diff --git a/src/gpu/GrSurface.cpp b/src/gpu/GrSurface.cpp index 66ebe3b1e1..a07fe67ae4 100644 --- a/src/gpu/GrSurface.cpp +++ b/src/gpu/GrSurface.cpp @@ -12,13 +12,15 @@ #include "SkImageEncoder.h" #include <stdio.h> -void GrSurface::asImageInfo(SkImageInfo* info) const { - if (!GrPixelConfig2ColorType(this->config(), &info->fColorType)) { +SkImageInfo GrSurface::info() const { + SkImageInfo info; + if (!GrPixelConfig2ColorType(this->config(), &info.fColorType)) { sk_throw(); } - info->fWidth = this->width(); - info->fHeight = this->height(); - info->fAlphaType = kPremul_SkAlphaType; + info.fWidth = this->width(); + info.fHeight = this->height(); + info.fAlphaType = kPremul_SkAlphaType; + return info; } bool GrSurface::savePixels(const char* filename) { diff --git a/src/gpu/SkGpuDevice.cpp b/src/gpu/SkGpuDevice.cpp index 8d3f75ade0..44120a220f 100644 --- a/src/gpu/SkGpuDevice.cpp +++ b/src/gpu/SkGpuDevice.cpp @@ -125,39 +125,13 @@ public: /////////////////////////////////////////////////////////////////////////////// -static SkBitmap::Config grConfig2skConfig(GrPixelConfig config, bool* isOpaque) { - switch (config) { - case kAlpha_8_GrPixelConfig: - *isOpaque = false; - return SkBitmap::kA8_Config; - case kRGB_565_GrPixelConfig: - *isOpaque = true; - return SkBitmap::kRGB_565_Config; - case kRGBA_4444_GrPixelConfig: - *isOpaque = false; - return SkBitmap::kARGB_4444_Config; - case kSkia8888_GrPixelConfig: - // we don't currently have a way of knowing whether - // a 8888 is opaque based on the config. - *isOpaque = false; - return SkBitmap::kARGB_8888_Config; - default: - *isOpaque = false; - return SkBitmap::kNo_Config; - } -} - /* * GrRenderTarget does not know its opaqueness, only its config, so we have * to make conservative guesses when we return an "equivalent" bitmap. */ static SkBitmap make_bitmap(GrContext* context, GrRenderTarget* renderTarget) { - bool isOpaque; - SkBitmap::Config config = grConfig2skConfig(renderTarget->config(), &isOpaque); - SkBitmap bitmap; - bitmap.setConfig(config, renderTarget->width(), renderTarget->height(), 0, - isOpaque ? kOpaque_SkAlphaType : kPremul_SkAlphaType); + bitmap.setInfo(renderTarget->info()); return bitmap; } @@ -212,9 +186,8 @@ void SkGpuDevice::initFromRenderTarget(GrContext* context, surface = fRenderTarget; } - SkImageInfo info; - surface->asImageInfo(&info); - SkPixelRef* pr = SkNEW_ARGS(SkGrPixelRef, (info, surface, SkToBool(flags & kCached_Flag))); + SkPixelRef* pr = SkNEW_ARGS(SkGrPixelRef, + (surface->info(), surface, SkToBool(flags & kCached_Flag))); this->setPixelRef(pr)->unref(); } @@ -728,12 +701,9 @@ bool create_mask_GPU(GrContext* context, } SkBitmap wrap_texture(GrTexture* texture) { - SkImageInfo info; - texture->asImageInfo(&info); - SkBitmap result; - result.setInfo(info); - result.setPixelRef(SkNEW_ARGS(SkGrPixelRef, (info, texture)))->unref(); + result.setInfo(texture->info()); + result.setPixelRef(SkNEW_ARGS(SkGrPixelRef, (result.info(), texture)))->unref(); return result; } diff --git a/src/images/SkImageDecoder.cpp b/src/images/SkImageDecoder.cpp index 491d9aa72f..5d38b40412 100644 --- a/src/images/SkImageDecoder.cpp +++ b/src/images/SkImageDecoder.cpp @@ -124,15 +124,16 @@ void SkImageDecoder::setSampleSize(int size) { fSampleSize = size; } -bool SkImageDecoder::chooseFromOneChoice(SkBitmap::Config config, int width, - int height) const { +// TODO: change Chooser virtual to take colorType, so we can stop calling SkColorTypeToBitmapConfig +// +bool SkImageDecoder::chooseFromOneChoice(SkColorType colorType, int width, int height) const { Chooser* chooser = fChooser; - + if (NULL == chooser) { // no chooser, we just say YES to decoding :) return true; } chooser->begin(1); - chooser->inspect(0, config, width, height); + chooser->inspect(0, SkColorTypeToBitmapConfig(colorType), width, height); return chooser->choose() == 0; } @@ -148,8 +149,10 @@ void SkImageDecoder::setPrefConfigTable(const PrefConfigTable& prefTable) { fPrefTable = prefTable; } -SkBitmap::Config SkImageDecoder::getPrefConfig(SrcDepth srcDepth, - bool srcHasAlpha) const { +// TODO: use colortype in fPrefTable, fDefaultPref and GetDeviceConfig() +// so we can stop using SkBitmapConfigToColorType() +// +SkColorType SkImageDecoder::getPrefColorType(SrcDepth srcDepth, bool srcHasAlpha) const { SkBitmap::Config config = SkBitmap::kNo_Config; if (fUsePrefTable) { @@ -173,7 +176,7 @@ SkBitmap::Config SkImageDecoder::getPrefConfig(SrcDepth srcDepth, if (SkBitmap::kNo_Config == config) { config = SkImageDecoder::GetDeviceConfig(); } - return config; + return SkBitmapConfigToColorType(config); } bool SkImageDecoder::decode(SkStream* stream, SkBitmap* bm, @@ -232,7 +235,7 @@ bool SkImageDecoder::cropBitmap(SkBitmap *dst, SkBitmap *src, int sampleSize, } // if the destination has no pixels then we must allocate them. if (dst->isNull()) { - dst->setConfig(src->config(), w, h, 0, src->alphaType()); + dst->setInfo(src->info().makeWH(w, h)); if (!this->allocPixelRef(dst, NULL)) { SkDEBUGF(("failed to allocate pixels needed to crop the bitmap")); diff --git a/src/images/SkImageDecoder_ktx.cpp b/src/images/SkImageDecoder_ktx.cpp index 6ff2459540..0dd987cef1 100644 --- a/src/images/SkImageDecoder_ktx.cpp +++ b/src/images/SkImageDecoder_ktx.cpp @@ -63,7 +63,7 @@ bool SkKTXImageDecoder::onDecode(SkStream* stream, SkBitmap* bm, Mode mode) { const unsigned short height = ktxFile.height(); // should we allow the Chooser (if present) to pick a config for us??? - if (!this->chooseFromOneChoice(SkBitmap::kARGB_8888_Config, width, height)) { + if (!this->chooseFromOneChoice(kN32_SkColorType, width, height)) { return false; } @@ -71,10 +71,8 @@ bool SkKTXImageDecoder::onDecode(SkStream* stream, SkBitmap* bm, Mode mode) { SkScaledBitmapSampler sampler(width, height, this->getSampleSize()); // Set the config... - bm->setConfig(SkBitmap::kARGB_8888_Config, - sampler.scaledWidth(), sampler.scaledHeight(), - 0, - ktxFile.isRGBA8()? kPremul_SkAlphaType : kOpaque_SkAlphaType); + bm->setInfo(SkImageInfo::MakeN32(sampler.scaledWidth(), sampler.scaledHeight(), + ktxFile.isRGBA8()? kPremul_SkAlphaType : kOpaque_SkAlphaType)); if (SkImageDecoder::kDecodeBounds_Mode == mode) { return true; } diff --git a/src/images/SkImageDecoder_libbmp.cpp b/src/images/SkImageDecoder_libbmp.cpp index 34a88ac6b0..f9dd2472a0 100644 --- a/src/images/SkImageDecoder_libbmp.cpp +++ b/src/images/SkImageDecoder_libbmp.cpp @@ -123,18 +123,17 @@ bool SkBMPImageDecoder::onDecode(SkStream* stream, SkBitmap* bm, Mode mode) { int width = callback.width(); int height = callback.height(); - SkBitmap::Config config = this->getPrefConfig(k32Bit_SrcDepth, false); + SkColorType colorType = this->getPrefColorType(k32Bit_SrcDepth, false); // only accept prefConfig if it makes sense for us - if (SkBitmap::kARGB_4444_Config != config && - SkBitmap::kRGB_565_Config != config) { - config = SkBitmap::kARGB_8888_Config; + if (kARGB_4444_SkColorType != colorType && kRGB_565_SkColorType != colorType) { + colorType = kN32_SkColorType; } SkScaledBitmapSampler sampler(width, height, getSampleSize()); - bm->setConfig(config, sampler.scaledWidth(), sampler.scaledHeight(), 0, - kOpaque_SkAlphaType); + bm->setInfo(SkImageInfo::Make(sampler.scaledWidth(), sampler.scaledHeight(), + colorType, kOpaque_SkAlphaType)); if (justBounds) { return true; diff --git a/src/images/SkImageDecoder_libgif.cpp b/src/images/SkImageDecoder_libgif.cpp index a045c27e16..bbcd223169 100644 --- a/src/images/SkImageDecoder_libgif.cpp +++ b/src/images/SkImageDecoder_libgif.cpp @@ -310,14 +310,14 @@ bool SkGIFImageDecoder::onDecode(SkStream* sk_stream, SkBitmap* bm, Mode mode) { } // FIXME: We could give the caller a choice of images or configs. - if (!this->chooseFromOneChoice(SkBitmap::kIndex8_Config, width, height)) { + if (!this->chooseFromOneChoice(kIndex_8_SkColorType, width, height)) { return error_return(*bm, "chooseFromOneChoice"); } SkScaledBitmapSampler sampler(width, height, this->getSampleSize()); - bm->setConfig(SkBitmap::kIndex8_Config, sampler.scaledWidth(), - sampler.scaledHeight()); + bm->setInfo(SkImageInfo::Make(sampler.scaledWidth(), sampler.scaledHeight(), + kIndex_8_SkColorType, kPremul_SkAlphaType)); if (SkImageDecoder::kDecodeBounds_Mode == mode) { return true; diff --git a/src/images/SkImageDecoder_libico.cpp b/src/images/SkImageDecoder_libico.cpp index 2b65a36c76..c6dd6f0836 100644 --- a/src/images/SkImageDecoder_libico.cpp +++ b/src/images/SkImageDecoder_libico.cpp @@ -246,7 +246,7 @@ bool SkICOImageDecoder::onDecode(SkStream* stream, SkBitmap* bm, Mode mode) //if the andbitmap (mask) is all zeroes, then we can easily do an index bitmap //however, with small images with large colortables, maybe it's better to still do argb_8888 - bm->setConfig(SkBitmap::kARGB_8888_Config, w, h, calculateRowBytesFor8888(w, bitCount)); + bm->setInfo(SkImageInfo::MakeN32Premul(w, h), calculateRowBytesFor8888(w, bitCount)); if (SkImageDecoder::kDecodeBounds_Mode == mode) { delete[] colors; diff --git a/src/images/SkImageDecoder_libjpeg.cpp b/src/images/SkImageDecoder_libjpeg.cpp index b08835b542..befe6dc580 100644 --- a/src/images/SkImageDecoder_libjpeg.cpp +++ b/src/images/SkImageDecoder_libjpeg.cpp @@ -248,12 +248,12 @@ private: #endif /** - * Determine the appropriate bitmap config and out_color_space based on + * Determine the appropriate bitmap colortype and out_color_space based on * both the preference of the caller and the jpeg_color_space on the * jpeg_decompress_struct passed in. * Must be called after jpeg_read_header. */ - SkBitmap::Config getBitmapConfig(jpeg_decompress_struct*); + SkColorType getBitmapColorType(jpeg_decompress_struct*); typedef SkImageDecoder INHERITED; }; @@ -400,7 +400,7 @@ static void set_dct_method(const SkImageDecoder& decoder, jpeg_decompress_struct #endif } -SkBitmap::Config SkJPEGImageDecoder::getBitmapConfig(jpeg_decompress_struct* cinfo) { +SkColorType SkJPEGImageDecoder::getBitmapColorType(jpeg_decompress_struct* cinfo) { SkASSERT(cinfo != NULL); SrcDepth srcDepth = k32Bit_SrcDepth; @@ -408,26 +408,26 @@ SkBitmap::Config SkJPEGImageDecoder::getBitmapConfig(jpeg_decompress_struct* cin srcDepth = k8BitGray_SrcDepth; } - SkBitmap::Config config = this->getPrefConfig(srcDepth, /*hasAlpha*/ false); - switch (config) { - case SkBitmap::kA8_Config: - // Only respect A8 config if the original is grayscale, + SkColorType colorType = this->getPrefColorType(srcDepth, /*hasAlpha*/ false); + switch (colorType) { + case kAlpha_8_SkColorType: + // Only respect A8 colortype if the original is grayscale, // in which case we will treat the grayscale as alpha // values. if (cinfo->jpeg_color_space != JCS_GRAYSCALE) { - config = SkBitmap::kARGB_8888_Config; + colorType = kN32_SkColorType; } break; - case SkBitmap::kARGB_8888_Config: + case kN32_SkColorType: // Fall through. - case SkBitmap::kARGB_4444_Config: + case kARGB_4444_SkColorType: // Fall through. - case SkBitmap::kRGB_565_Config: - // These are acceptable destination configs. + case kRGB_565_SkColorType: + // These are acceptable destination colortypes. break; default: - // Force all other configs to 8888. - config = SkBitmap::kARGB_8888_Config; + // Force all other colortypes to 8888. + colorType = kN32_SkColorType; break; } @@ -441,37 +441,37 @@ SkBitmap::Config SkJPEGImageDecoder::getBitmapConfig(jpeg_decompress_struct* cin cinfo->out_color_space = JCS_CMYK; break; case JCS_GRAYSCALE: - if (SkBitmap::kA8_Config == config) { + if (kAlpha_8_SkColorType == colorType) { cinfo->out_color_space = JCS_GRAYSCALE; break; } // The data is JCS_GRAYSCALE, but the caller wants some sort of RGB - // config. Fall through to set to the default. + // colortype. Fall through to set to the default. default: cinfo->out_color_space = JCS_RGB; break; } - return config; + return colorType; } -#ifdef ANDROID_RGB /** - * Based on the config and dither mode, adjust out_color_space and - * dither_mode of cinfo. + * Based on the colortype and dither mode, adjust out_color_space and + * dither_mode of cinfo. Only does work in ANDROID_RGB */ static void adjust_out_color_space_and_dither(jpeg_decompress_struct* cinfo, - SkBitmap::Config config, + SkColorType colorType, const SkImageDecoder& decoder) { SkASSERT(cinfo != NULL); +#ifdef ANDROID_RGB cinfo->dither_mode = JDITHER_NONE; if (JCS_CMYK == cinfo->out_color_space) { return; } - switch(config) { - case SkBitmap::kARGB_8888_Config: + switch (colorType) { + case kN32_SkColorType: cinfo->out_color_space = JCS_RGBA_8888; break; - case SkBitmap::kRGB_565_Config: + case kRGB_565_SkColorType: cinfo->out_color_space = JCS_RGB_565; if (decoder.getDitherImage()) { cinfo->dither_mode = JDITHER_ORDERED; @@ -480,8 +480,8 @@ static void adjust_out_color_space_and_dither(jpeg_decompress_struct* cinfo, default: break; } -} #endif +} /** @@ -569,20 +569,19 @@ bool SkJPEGImageDecoder::onDecode(SkStream* stream, SkBitmap* bm, Mode mode) { turn_off_visual_optimizations(&cinfo); - const SkBitmap::Config config = this->getBitmapConfig(&cinfo); + const SkColorType colorType = this->getBitmapColorType(&cinfo); + const SkAlphaType alphaType = kAlpha_8_SkColorType == colorType ? + kPremul_SkAlphaType : kOpaque_SkAlphaType; -#ifdef ANDROID_RGB - adjust_out_color_space_and_dither(&cinfo, config, *this); -#endif + adjust_out_color_space_and_dither(&cinfo, colorType, *this); if (1 == sampleSize && SkImageDecoder::kDecodeBounds_Mode == mode) { // Assume an A8 bitmap is not opaque to avoid the check of each // individual pixel. It is very unlikely to be opaque, since // an opaque A8 bitmap would not be very interesting. // Otherwise, a jpeg image is opaque. - return bm->setConfig(config, cinfo.image_width, cinfo.image_height, 0, - SkBitmap::kA8_Config == config ? - kPremul_SkAlphaType : kOpaque_SkAlphaType); + return bm->setInfo(SkImageInfo::Make(cinfo.image_width, cinfo.image_height, + colorType, alphaType)); } /* image_width and image_height are the original dimensions, available @@ -606,17 +605,16 @@ bool SkJPEGImageDecoder::onDecode(SkStream* stream, SkBitmap* bm, Mode mode) { // individual pixel. It is very unlikely to be opaque, since // an opaque A8 bitmap would not be very interesting. // Otherwise, a jpeg image is opaque. - return bm->setConfig(config, smpl.scaledWidth(), smpl.scaledHeight(), - 0, SkBitmap::kA8_Config == config ? - kPremul_SkAlphaType : kOpaque_SkAlphaType); + return bm->setInfo(SkImageInfo::Make(smpl.scaledWidth(), smpl.scaledHeight(), + colorType, alphaType)); } else { return return_false(cinfo, *bm, "start_decompress"); } } sampleSize = recompute_sampleSize(sampleSize, cinfo); - // should we allow the Chooser (if present) to pick a config for us??? - if (!this->chooseFromOneChoice(config, cinfo.output_width, cinfo.output_height)) { + // should we allow the Chooser (if present) to pick a colortype for us??? + if (!this->chooseFromOneChoice(colorType, cinfo.output_width, cinfo.output_height)) { return return_false(cinfo, *bm, "chooseFromOneChoice"); } @@ -625,8 +623,8 @@ bool SkJPEGImageDecoder::onDecode(SkStream* stream, SkBitmap* bm, Mode mode) { // individual pixel. It is very unlikely to be opaque, since // an opaque A8 bitmap would not be very interesting. // Otherwise, a jpeg image is opaque. - bm->setConfig(config, sampler.scaledWidth(), sampler.scaledHeight(), 0, - SkBitmap::kA8_Config != config ? kOpaque_SkAlphaType : kPremul_SkAlphaType); + bm->setInfo(SkImageInfo::Make(sampler.scaledWidth(), sampler.scaledHeight(), + colorType, alphaType)); if (SkImageDecoder::kDecodeBounds_Mode == mode) { return true; } @@ -641,10 +639,8 @@ bool SkJPEGImageDecoder::onDecode(SkStream* stream, SkBitmap* bm, Mode mode) { a significant performance boost. */ if (sampleSize == 1 && - ((config == SkBitmap::kARGB_8888_Config && - cinfo.out_color_space == JCS_RGBA_8888) || - (config == SkBitmap::kRGB_565_Config && - cinfo.out_color_space == JCS_RGB_565))) + ((kN32_SkColorType == colorType && cinfo.out_color_space == JCS_RGBA_8888) || + (kRGB_565_SkColorType == colorType && cinfo.out_color_space == JCS_RGB_565))) { JSAMPLE* rowptr = (JSAMPLE*)bm->getPixels(); INT32 const bpr = bm->rowBytes(); @@ -764,7 +760,7 @@ bool SkJPEGImageDecoder::onBuildTileIndex(SkStreamRewindable* stream, int *width // based on the config in onDecodeSubset. This should be fine, since // jpeg_init_read_tile_scanline will check out_color_space again after // that change (when it calls jinit_color_deconverter). - (void) this->getBitmapConfig(cinfo); + (void) this->getBitmapColorType(cinfo); turn_off_visual_optimizations(cinfo); @@ -815,10 +811,8 @@ bool SkJPEGImageDecoder::onDecodeSubset(SkBitmap* bm, const SkIRect& region) { set_dct_method(*this, cinfo); - const SkBitmap::Config config = this->getBitmapConfig(cinfo); -#ifdef ANDROID_RGB - adjust_out_color_space_and_dither(cinfo, config, *this); -#endif + const SkColorType colorType = this->getBitmapColorType(cinfo); + adjust_out_color_space_and_dither(cinfo, colorType, *this); int startX = rect.fLeft; int startY = rect.fTop; @@ -833,14 +827,13 @@ bool SkJPEGImageDecoder::onDecodeSubset(SkBitmap* bm, const SkIRect& region) { SkScaledBitmapSampler sampler(width, height, skiaSampleSize); SkBitmap bitmap; - bitmap.setConfig(config, sampler.scaledWidth(), sampler.scaledHeight()); // Assume an A8 bitmap is not opaque to avoid the check of each // individual pixel. It is very unlikely to be opaque, since // an opaque A8 bitmap would not be very interesting. // Otherwise, a jpeg image is opaque. - bitmap.setConfig(config, sampler.scaledWidth(), sampler.scaledHeight(), 0, - config == SkBitmap::kA8_Config ? kPremul_SkAlphaType : - kOpaque_SkAlphaType); + bitmap.setInfo(SkImageInfo::Make(sampler.scaledWidth(), sampler.scaledHeight(), colorType, + kAlpha_8_SkColorType == colorType ? + kPremul_SkAlphaType : kOpaque_SkAlphaType)); // Check ahead of time if the swap(dest, src) is possible or not. // If yes, then we will stick to AllocPixelRef since it's cheaper with the @@ -869,10 +862,8 @@ bool SkJPEGImageDecoder::onDecodeSubset(SkBitmap* bm, const SkIRect& region) { a significant performance boost. */ if (skiaSampleSize == 1 && - ((config == SkBitmap::kARGB_8888_Config && - cinfo->out_color_space == JCS_RGBA_8888) || - (config == SkBitmap::kRGB_565_Config && - cinfo->out_color_space == JCS_RGB_565))) + ((kN32_SkColorType == colorType && cinfo->out_color_space == JCS_RGBA_8888) || + (kRGB_565_SkColorType == colorType && cinfo->out_color_space == JCS_RGB_565))) { JSAMPLE* rowptr = (JSAMPLE*)bitmap.getPixels(); INT32 const bpr = bitmap.rowBytes(); @@ -1116,14 +1107,14 @@ static void Write_Index_YUV(uint8_t* SK_RESTRICT dst, } static WriteScanline ChooseWriter(const SkBitmap& bm) { - switch (bm.config()) { - case SkBitmap::kARGB_8888_Config: + switch (bm.colorType()) { + case kN32_SkColorType: return Write_32_YUV; - case SkBitmap::kRGB_565_Config: + case kRGB_565_SkColorType: return Write_16_YUV; - case SkBitmap::kARGB_4444_Config: + case kARGB_4444_SkColorType: return Write_4444_YUV; - case SkBitmap::kIndex8_Config: + case kIndex_8_SkColorType: return Write_Index_YUV; default: return NULL; diff --git a/src/images/SkImageDecoder_libpng.cpp b/src/images/SkImageDecoder_libpng.cpp index cd09f5f980..70cc1b9f75 100644 --- a/src/images/SkImageDecoder_libpng.cpp +++ b/src/images/SkImageDecoder_libpng.cpp @@ -1,4 +1,3 @@ - /* * Copyright 2006 The Android Open Source Project * @@ -6,7 +5,6 @@ * found in the LICENSE file. */ - #include "SkImageDecoder.h" #include "SkImageEncoder.h" #include "SkColor.h" @@ -59,7 +57,7 @@ public: : fStream(stream) , fPng_ptr(png_ptr) , fInfo_ptr(info_ptr) - , fConfig(SkBitmap::kNo_Config) { + , fColorType(kUnknown_SkColorType) { SkASSERT(stream != NULL); stream->ref(); } @@ -72,7 +70,7 @@ public: SkAutoTUnref<SkStreamRewindable> fStream; png_structp fPng_ptr; png_infop fInfo_ptr; - SkBitmap::Config fConfig; + SkColorType fColorType; }; class SkPNGImageDecoder : public SkImageDecoder { @@ -102,9 +100,8 @@ private: bool decodePalette(png_structp png_ptr, png_infop info_ptr, bool * SK_RESTRICT hasAlphap, bool *reallyHasAlphap, SkColorTable **colorTablep); - bool getBitmapConfig(png_structp png_ptr, png_infop info_ptr, - SkBitmap::Config *config, bool *hasAlpha, - SkPMColor *theTranspColor); + bool getBitmapConfig(png_structp, png_infop, SkColorType*, bool* hasAlpha, + SkPMColor* theTranspColor); typedef SkImageDecoder INHERITED; }; @@ -186,13 +183,12 @@ static bool substituteTranspColor(SkBitmap* bm, SkPMColor match) { return reallyHasAlpha; } -static bool canUpscalePaletteToConfig(SkBitmap::Config dstConfig, - bool srcHasAlpha) { - switch (dstConfig) { - case SkBitmap::kARGB_8888_Config: - case SkBitmap::kARGB_4444_Config: +static bool canUpscalePaletteToConfig(SkColorType dstColorType, bool srcHasAlpha) { + switch (dstColorType) { + case kN32_SkColorType: + case kARGB_4444_SkColorType: return true; - case SkBitmap::kRGB_565_Config: + case kRGB_565_SkColorType: // only return true if the src is opaque (since 565 is opaque) return !srcHasAlpha; default: @@ -317,26 +313,24 @@ bool SkPNGImageDecoder::onDecode(SkStream* sk_stream, SkBitmap* decodedBitmap, } png_uint_32 origWidth, origHeight; - int bitDepth, colorType, interlaceType; + int bitDepth, pngColorType, interlaceType; png_get_IHDR(png_ptr, info_ptr, &origWidth, &origHeight, &bitDepth, - &colorType, &interlaceType, int_p_NULL, int_p_NULL); + &pngColorType, &interlaceType, int_p_NULL, int_p_NULL); - SkBitmap::Config config; + SkColorType colorType; bool hasAlpha = false; SkPMColor theTranspColor = 0; // 0 tells us not to try to match - if (!this->getBitmapConfig(png_ptr, info_ptr, &config, &hasAlpha, &theTranspColor)) { + if (!this->getBitmapConfig(png_ptr, info_ptr, &colorType, &hasAlpha, &theTranspColor)) { return false; } + SkAlphaType alphaType = this->getRequireUnpremultipliedColors() ? + kUnpremul_SkAlphaType : kPremul_SkAlphaType; const int sampleSize = this->getSampleSize(); SkScaledBitmapSampler sampler(origWidth, origHeight, sampleSize); - decodedBitmap->setConfig(config, sampler.scaledWidth(), sampler.scaledHeight()); - - // we should communicate alphaType, even if we early-return in bounds-only-mode. - if (this->getRequireUnpremultipliedColors()) { - decodedBitmap->setAlphaType(kUnpremul_SkAlphaType); - } + decodedBitmap->setInfo(SkImageInfo::Make(sampler.scaledWidth(), sampler.scaledHeight(), + colorType, alphaType)); if (SkImageDecoder::kDecodeBounds_Mode == mode) { return true; @@ -350,14 +344,14 @@ bool SkPNGImageDecoder::onDecode(SkStream* sk_stream, SkBitmap* decodedBitmap, bool reallyHasAlpha = false; SkColorTable* colorTable = NULL; - if (colorType == PNG_COLOR_TYPE_PALETTE) { + if (pngColorType == PNG_COLOR_TYPE_PALETTE) { decodePalette(png_ptr, info_ptr, &hasAlpha, &reallyHasAlpha, &colorTable); } SkAutoUnref aur(colorTable); if (!this->allocPixelRef(decodedBitmap, - SkBitmap::kIndex8_Config == config ? colorTable : NULL)) { + kIndex_8_SkColorType == colorType ? colorTable : NULL)) { return false; } @@ -376,15 +370,15 @@ bool SkPNGImageDecoder::onDecode(SkStream* sk_stream, SkBitmap* decodedBitmap, */ png_read_update_info(png_ptr, info_ptr); - if ((SkBitmap::kA8_Config == config || SkBitmap::kIndex8_Config == config) - && 1 == sampleSize) { - if (SkBitmap::kA8_Config == config) { + if ((kAlpha_8_SkColorType == colorType || kIndex_8_SkColorType == colorType) && + 1 == sampleSize) { + if (kAlpha_8_SkColorType == colorType) { // For an A8 bitmap, we assume there is an alpha for speed. It is // possible the bitmap is opaque, but that is an unlikely use case // since it would not be very interesting. reallyHasAlpha = true; // A8 is only allowed if the original was GRAY. - SkASSERT(PNG_COLOR_TYPE_GRAY == colorType); + SkASSERT(PNG_COLOR_TYPE_GRAY == pngColorType); } for (int i = 0; i < number_passes; i++) { for (png_uint_32 y = 0; y < origHeight; y++) { @@ -399,9 +393,9 @@ bool SkPNGImageDecoder::onDecode(SkStream* sk_stream, SkBitmap* decodedBitmap, if (colorTable != NULL) { sc = SkScaledBitmapSampler::kIndex; srcBytesPerPixel = 1; - } else if (SkBitmap::kA8_Config == config) { + } else if (kAlpha_8_SkColorType == colorType) { // A8 is only allowed if the original was GRAY. - SkASSERT(PNG_COLOR_TYPE_GRAY == colorType); + SkASSERT(PNG_COLOR_TYPE_GRAY == pngColorType); sc = SkScaledBitmapSampler::kGray; srcBytesPerPixel = 1; } else if (hasAlpha) { @@ -492,8 +486,8 @@ bool SkPNGImageDecoder::onDecode(SkStream* sk_stream, SkBitmap* decodedBitmap, bool SkPNGImageDecoder::getBitmapConfig(png_structp png_ptr, png_infop info_ptr, - SkBitmap::Config* SK_RESTRICT configp, - bool* SK_RESTRICT hasAlphap, + SkColorType* colorTypep, + bool* hasAlphap, SkPMColor* SK_RESTRICT theTranspColorp) { png_uint_32 origWidth, origHeight; int bitDepth, colorType; @@ -518,10 +512,10 @@ bool SkPNGImageDecoder::getBitmapConfig(png_structp png_ptr, png_infop info_ptr, if (colorType == PNG_COLOR_TYPE_PALETTE) { bool paletteHasAlpha = hasTransparencyInPalette(png_ptr, info_ptr); - *configp = this->getPrefConfig(kIndex_SrcDepth, paletteHasAlpha); + *colorTypep = this->getPrefColorType(kIndex_SrcDepth, paletteHasAlpha); // now see if we can upscale to their requested config - if (!canUpscalePaletteToConfig(*configp, paletteHasAlpha)) { - *configp = SkBitmap::kIndex8_Config; + if (!canUpscalePaletteToConfig(*colorTypep, paletteHasAlpha)) { + *colorTypep = kIndex_8_SkColorType; } } else { png_color_16p transpColor = NULL; @@ -585,21 +579,21 @@ bool SkPNGImageDecoder::getBitmapConfig(png_structp png_ptr, png_infop info_ptr, //SkASSERT(!*hasAlphap); } - *configp = this->getPrefConfig(srcDepth, *hasAlphap); + *colorTypep = this->getPrefColorType(srcDepth, *hasAlphap); // now match the request against our capabilities if (*hasAlphap) { - if (*configp != SkBitmap::kARGB_4444_Config) { - *configp = SkBitmap::kARGB_8888_Config; + if (*colorTypep != kARGB_4444_SkColorType) { + *colorTypep = kN32_SkColorType; } } else { - if (SkBitmap::kA8_Config == *configp) { + if (kAlpha_8_SkColorType == *colorTypep) { if (k8BitGray_SrcDepth != srcDepth) { // Converting a non grayscale image to A8 is not currently supported. - *configp = SkBitmap::kARGB_8888_Config; + *colorTypep = kN32_SkColorType; } - } else if (*configp != SkBitmap::kRGB_565_Config && - *configp != SkBitmap::kARGB_4444_Config) { - *configp = SkBitmap::kARGB_8888_Config; + } else if (*colorTypep != kRGB_565_SkColorType && + *colorTypep != kARGB_4444_SkColorType) { + *colorTypep = kN32_SkColorType; } } } @@ -613,30 +607,29 @@ bool SkPNGImageDecoder::getBitmapConfig(png_structp png_ptr, png_infop info_ptr, } } - if (!this->chooseFromOneChoice(*configp, origWidth, origHeight)) { + if (!this->chooseFromOneChoice(*colorTypep, origWidth, origHeight)) { return false; } // If the image has alpha and the decoder wants unpremultiplied // colors, the only supported config is 8888. if (this->getRequireUnpremultipliedColors() && *hasAlphap) { - *configp = SkBitmap::kARGB_8888_Config; + *colorTypep = kN32_SkColorType; } if (fImageIndex != NULL) { - if (SkBitmap::kNo_Config == fImageIndex->fConfig) { + if (kUnknown_SkColorType == fImageIndex->fColorType) { // This is the first time for this subset decode. From now on, // all decodes must be in the same config. - fImageIndex->fConfig = *configp; - } else if (fImageIndex->fConfig != *configp) { - // Requesting a different config for a subsequent decode is not + fImageIndex->fColorType = *colorTypep; + } else if (fImageIndex->fColorType != *colorTypep) { + // Requesting a different colortype for a subsequent decode is not // supported. Report failure before we make changes to png_ptr. return false; } } - bool convertGrayToRGB = PNG_COLOR_TYPE_GRAY == colorType - && *configp != SkBitmap::kA8_Config; + bool convertGrayToRGB = PNG_COLOR_TYPE_GRAY == colorType && *colorTypep != kAlpha_8_SkColorType; // Unless the user is requesting A8, convert a grayscale image into RGB. // GRAY_ALPHA will always be converted to RGB @@ -774,9 +767,9 @@ bool SkPNGImageDecoder::onDecodeSubset(SkBitmap* bm, const SkIRect& region) { } png_uint_32 origWidth, origHeight; - int bitDepth, colorType, interlaceType; + int bitDepth, pngColorType, interlaceType; png_get_IHDR(png_ptr, info_ptr, &origWidth, &origHeight, &bitDepth, - &colorType, &interlaceType, int_p_NULL, int_p_NULL); + &pngColorType, &interlaceType, int_p_NULL, int_p_NULL); SkIRect rect = SkIRect::MakeWH(origWidth, origHeight); @@ -786,11 +779,11 @@ bool SkPNGImageDecoder::onDecodeSubset(SkBitmap* bm, const SkIRect& region) { return false; } - SkBitmap::Config config; + SkColorType colorType; bool hasAlpha = false; SkPMColor theTranspColor = 0; // 0 tells us not to try to match - if (!this->getBitmapConfig(png_ptr, info_ptr, &config, &hasAlpha, &theTranspColor)) { + if (!this->getBitmapConfig(png_ptr, info_ptr, &colorType, &hasAlpha, &theTranspColor)) { return false; } @@ -798,7 +791,8 @@ bool SkPNGImageDecoder::onDecodeSubset(SkBitmap* bm, const SkIRect& region) { SkScaledBitmapSampler sampler(origWidth, rect.height(), sampleSize); SkBitmap decodedBitmap; - decodedBitmap.setConfig(config, sampler.scaledWidth(), sampler.scaledHeight()); + decodedBitmap.setInfo(SkImageInfo::Make(sampler.scaledWidth(), sampler.scaledHeight(), + colorType, kPremul_SkAlphaType)); // from here down we are concerned with colortables and pixels @@ -808,7 +802,7 @@ bool SkPNGImageDecoder::onDecodeSubset(SkBitmap* bm, const SkIRect& region) { bool reallyHasAlpha = false; SkColorTable* colorTable = NULL; - if (colorType == PNG_COLOR_TYPE_PALETTE) { + if (pngColorType == PNG_COLOR_TYPE_PALETTE) { decodePalette(png_ptr, info_ptr, &hasAlpha, &reallyHasAlpha, &colorTable); } @@ -821,7 +815,7 @@ bool SkPNGImageDecoder::onDecodeSubset(SkBitmap* bm, const SkIRect& region) { int h = rect.height() / sampleSize; const bool swapOnly = (rect == region) && (w == decodedBitmap.width()) && (h == decodedBitmap.height()) && bm->isNull(); - const bool needColorTable = SkBitmap::kIndex8_Config == config; + const bool needColorTable = kIndex_8_SkColorType == colorType; if (swapOnly) { if (!this->allocPixelRef(&decodedBitmap, needColorTable ? colorTable : NULL)) { return false; @@ -856,15 +850,15 @@ bool SkPNGImageDecoder::onDecodeSubset(SkBitmap* bm, const SkIRect& region) { int actualTop = rect.fTop; - if ((SkBitmap::kA8_Config == config || SkBitmap::kIndex8_Config == config) + if ((kAlpha_8_SkColorType == colorType || kIndex_8_SkColorType == colorType) && 1 == sampleSize) { - if (SkBitmap::kA8_Config == config) { + if (kAlpha_8_SkColorType == colorType) { // For an A8 bitmap, we assume there is an alpha for speed. It is // possible the bitmap is opaque, but that is an unlikely use case // since it would not be very interesting. reallyHasAlpha = true; // A8 is only allowed if the original was GRAY. - SkASSERT(PNG_COLOR_TYPE_GRAY == colorType); + SkASSERT(PNG_COLOR_TYPE_GRAY == pngColorType); } for (int i = 0; i < number_passes; i++) { @@ -886,9 +880,9 @@ bool SkPNGImageDecoder::onDecodeSubset(SkBitmap* bm, const SkIRect& region) { if (colorTable != NULL) { sc = SkScaledBitmapSampler::kIndex; srcBytesPerPixel = 1; - } else if (SkBitmap::kA8_Config == config) { + } else if (kAlpha_8_SkColorType == colorType) { // A8 is only allowed if the original was GRAY. - SkASSERT(PNG_COLOR_TYPE_GRAY == colorType); + SkASSERT(PNG_COLOR_TYPE_GRAY == pngColorType); sc = SkScaledBitmapSampler::kGray; srcBytesPerPixel = 1; } else if (hasAlpha) { @@ -957,11 +951,11 @@ bool SkPNGImageDecoder::onDecodeSubset(SkBitmap* bm, const SkIRect& region) { reallyHasAlpha |= substituteTranspColor(&decodedBitmap, theTranspColor); } if (reallyHasAlpha && this->getRequireUnpremultipliedColors()) { - switch (decodedBitmap.config()) { - case SkBitmap::kIndex8_Config: + switch (decodedBitmap.colorType()) { + case kIndex_8_SkColorType: // Fall through. - case SkBitmap::kARGB_4444_Config: - // We have chosen not to support unpremul for these configs. + case kARGB_4444_SkColorType: + // We have chosen not to support unpremul for these colortypess. return false; default: { // Fall through to finish the decode. This config either diff --git a/src/images/SkImageDecoder_libwebp.cpp b/src/images/SkImageDecoder_libwebp.cpp index 353eabf015..8baa10c454 100644 --- a/src/images/SkImageDecoder_libwebp.cpp +++ b/src/images/SkImageDecoder_libwebp.cpp @@ -278,40 +278,33 @@ static bool webp_get_config_resize_crop(WebPDecoderConfig* config, return true; } -bool SkWEBPImageDecoder::setDecodeConfig(SkBitmap* decodedBitmap, - int width, int height) { - SkBitmap::Config config = this->getPrefConfig(k32Bit_SrcDepth, SkToBool(fHasAlpha)); +bool SkWEBPImageDecoder::setDecodeConfig(SkBitmap* decodedBitmap, int width, int height) { + SkColorType colorType = this->getPrefColorType(k32Bit_SrcDepth, SkToBool(fHasAlpha)); // YUV converter supports output in RGB565, RGBA4444 and RGBA8888 formats. if (fHasAlpha) { - if (config != SkBitmap::kARGB_4444_Config) { - config = SkBitmap::kARGB_8888_Config; + if (colorType != kARGB_4444_SkColorType) { + colorType = kN32_SkColorType; } } else { - if (config != SkBitmap::kRGB_565_Config && - config != SkBitmap::kARGB_4444_Config) { - config = SkBitmap::kARGB_8888_Config; + if (colorType != kRGB_565_SkColorType && colorType != kARGB_4444_SkColorType) { + colorType = kN32_SkColorType; } } - if (!this->chooseFromOneChoice(config, width, height)) { + if (!this->chooseFromOneChoice(colorType, width, height)) { return false; } - SkImageInfo info; - info.fWidth = width; - info.fHeight = height; - info.fColorType = SkBitmapConfigToColorType(config); + SkAlphaType alphaType = kOpaque_SkAlphaType; if (SkToBool(fHasAlpha)) { if (this->getRequireUnpremultipliedColors()) { - info.fAlphaType = kUnpremul_SkAlphaType; + alphaType = kUnpremul_SkAlphaType; } else { - info.fAlphaType = kPremul_SkAlphaType; + alphaType = kPremul_SkAlphaType; } - } else { - info.fAlphaType = kOpaque_SkAlphaType; } - return decodedBitmap->setInfo(info); + return decodedBitmap->setInfo(SkImageInfo::Make(width, height, colorType, alphaType)); } bool SkWEBPImageDecoder::onBuildTileIndex(SkStreamRewindable* stream, @@ -389,7 +382,7 @@ bool SkWEBPImageDecoder::onDecodeSubset(SkBitmap* decodedBitmap, } else { // This is also called in setDecodeConfig in above block. // i.e., when bitmap->isNull() is true. - if (!chooseFromOneChoice(bitmap->config(), width, height)) { + if (!chooseFromOneChoice(bitmap->colorType(), width, height)) { return false; } } diff --git a/src/images/SkImageDecoder_pkm.cpp b/src/images/SkImageDecoder_pkm.cpp index c299c23548..79da8da51a 100644 --- a/src/images/SkImageDecoder_pkm.cpp +++ b/src/images/SkImageDecoder_pkm.cpp @@ -47,7 +47,7 @@ bool SkPKMImageDecoder::onDecode(SkStream* stream, SkBitmap* bm, Mode mode) { const unsigned short height = etc1_pkm_get_height(buf); // should we allow the Chooser (if present) to pick a config for us??? - if (!this->chooseFromOneChoice(SkBitmap::kARGB_8888_Config, width, height)) { + if (!this->chooseFromOneChoice(kN32_SkColorType, width, height)) { return false; } @@ -55,8 +55,8 @@ bool SkPKMImageDecoder::onDecode(SkStream* stream, SkBitmap* bm, Mode mode) { SkScaledBitmapSampler sampler(width, height, this->getSampleSize()); // Set the config... - bm->setConfig(SkBitmap::kARGB_8888_Config, sampler.scaledWidth(), sampler.scaledHeight(), - 0, kOpaque_SkAlphaType); + bm->setInfo(SkImageInfo::MakeN32(sampler.scaledWidth(), sampler.scaledHeight(), + kOpaque_SkAlphaType)); if (SkImageDecoder::kDecodeBounds_Mode == mode) { return true; } diff --git a/src/images/SkImageDecoder_wbmp.cpp b/src/images/SkImageDecoder_wbmp.cpp index 8dce62cdf0..0bf138940d 100644 --- a/src/images/SkImageDecoder_wbmp.cpp +++ b/src/images/SkImageDecoder_wbmp.cpp @@ -111,8 +111,8 @@ bool SkWBMPImageDecoder::onDecode(SkStream* stream, SkBitmap* decodedBitmap, int width = head.fWidth; int height = head.fHeight; - decodedBitmap->setConfig(SkBitmap::kIndex8_Config, width, height, 0, - kOpaque_SkAlphaType); + decodedBitmap->setInfo(SkImageInfo::Make(width, height, + kIndex_8_SkColorType, kOpaque_SkAlphaType)); if (SkImageDecoder::kDecodeBounds_Mode == mode) { return true; diff --git a/src/images/SkScaledBitmapSampler.cpp b/src/images/SkScaledBitmapSampler.cpp index ba8ce4614f..7fd8718beb 100644 --- a/src/images/SkScaledBitmapSampler.cpp +++ b/src/images/SkScaledBitmapSampler.cpp @@ -842,17 +842,23 @@ protected: void test_row_proc_choice(); void test_row_proc_choice() { + const SkColorType colorTypes[] = { + kAlpha_8_SkColorType, kIndex_8_SkColorType, kRGB_565_SkColorType, kARGB_4444_SkColorType, + kN32_SkColorType + }; + SkBitmap dummyBitmap; DummyDecoder dummyDecoder; size_t procCounter = 0; for (int sc = SkScaledBitmapSampler::kGray; sc <= SkScaledBitmapSampler::kRGB_565; ++sc) { - for (int c = SkBitmap::kA8_Config; c <= SkBitmap::kARGB_8888_Config; ++c) { + for (size_t c = 0; c < SK_ARRAY_COUNT(colorTypes); ++c) { for (int unpremul = 0; unpremul <= 1; ++unpremul) { for (int dither = 0; dither <= 1; ++dither) { // Arbitrary width/height/sampleSize to allow SkScaledBitmapSampler to // be considered valid. SkScaledBitmapSampler sampler(10, 10, 1); - dummyBitmap.setConfig((SkBitmap::Config) c, 10, 10); + dummyBitmap.setInfo(SkImageInfo::Make(10, 10, + colorTypes[c], kPremul_SkAlphaType)); dummyDecoder.setDitherImage(SkToBool(dither)); dummyDecoder.setRequireUnpremultipliedColors(SkToBool(unpremul)); sampler.begin(&dummyBitmap, (SkScaledBitmapSampler::SrcConfig) sc, diff --git a/src/ports/SkFontHost_FreeType_common.cpp b/src/ports/SkFontHost_FreeType_common.cpp index e4323d81a1..b27ae96fff 100644 --- a/src/ports/SkFontHost_FreeType_common.cpp +++ b/src/ports/SkFontHost_FreeType_common.cpp @@ -295,11 +295,11 @@ static void packA8ToA1(const SkMask& mask, const uint8_t* src, size_t srcRB) { } } -inline SkMask::Format SkMaskFormat_for_SkBitmapConfig(SkBitmap::Config config) { - switch (config) { - case SkBitmap::kA8_Config: +inline SkMask::Format SkMaskFormat_for_SkColorType(SkColorType colorType) { + switch (colorType) { + case kAlpha_8_SkColorType: return SkMask::kA8_Format; - case SkBitmap::kARGB_8888_Config: + case kN32_SkColorType: return SkMask::kARGB32_Format; default: SkDEBUGFAIL("unsupported SkBitmap::Config"); @@ -307,30 +307,30 @@ inline SkMask::Format SkMaskFormat_for_SkBitmapConfig(SkBitmap::Config config) { } } -inline SkBitmap::Config SkBitmapConfig_for_FTPixelMode(FT_Pixel_Mode pixel_mode) { +inline SkColorType SkColorType_for_FTPixelMode(FT_Pixel_Mode pixel_mode) { switch (pixel_mode) { case FT_PIXEL_MODE_MONO: case FT_PIXEL_MODE_GRAY: - return SkBitmap::kA8_Config; + return kAlpha_8_SkColorType; case FT_PIXEL_MODE_BGRA: - return SkBitmap::kARGB_8888_Config; + return kN32_SkColorType; default: SkDEBUGFAIL("unsupported FT_PIXEL_MODE"); - return SkBitmap::kA8_Config; + return kAlpha_8_SkColorType; } } -inline SkBitmap::Config SkBitmapConfig_for_SkMaskFormat(SkMask::Format format) { +inline SkColorType SkColorType_for_SkMaskFormat(SkMask::Format format) { switch (format) { case SkMask::kBW_Format: case SkMask::kA8_Format: case SkMask::kLCD16_Format: - return SkBitmap::kA8_Config; + return kAlpha_8_SkColorType; case SkMask::kARGB32_Format: - return SkBitmap::kARGB_8888_Config; + return kN32_SkColorType; default: SkDEBUGFAIL("unsupported destination SkBitmap::Config"); - return SkBitmap::kA8_Config; + return kAlpha_8_SkColorType; } } @@ -426,15 +426,16 @@ void SkScalerContext_FreeType_Base::generateGlyphImage(FT_Face face, const SkGly // Copy the FT_Bitmap into an SkBitmap (either A8 or ARGB) SkBitmap unscaledBitmap; - unscaledBitmap.setConfig(SkBitmapConfig_for_FTPixelMode(pixel_mode), - face->glyph->bitmap.width, face->glyph->bitmap.rows); - unscaledBitmap.allocPixels(); + unscaledBitmap.allocPixels(SkImageInfo::Make(face->glyph->bitmap.width, + face->glyph->bitmap.rows, + SkColorType_for_FTPixelMode(pixel_mode), + kPremul_SkAlphaType)); SkMask unscaledBitmapAlias; unscaledBitmapAlias.fImage = reinterpret_cast<uint8_t*>(unscaledBitmap.getPixels()); unscaledBitmapAlias.fBounds.set(0, 0, unscaledBitmap.width(), unscaledBitmap.height()); unscaledBitmapAlias.fRowBytes = unscaledBitmap.rowBytes(); - unscaledBitmapAlias.fFormat = SkMaskFormat_for_SkBitmapConfig(unscaledBitmap.config()); + unscaledBitmapAlias.fFormat = SkMaskFormat_for_SkColorType(unscaledBitmap.colorType()); copyFTBitmap(face->glyph->bitmap, unscaledBitmapAlias); // Wrap the glyph's mask in a bitmap, unless the glyph's mask is BW or LCD. @@ -446,8 +447,10 @@ void SkScalerContext_FreeType_Base::generateGlyphImage(FT_Face face, const SkGly bitmapRowBytes = glyph.rowBytes(); } SkBitmap dstBitmap; - dstBitmap.setConfig(SkBitmapConfig_for_SkMaskFormat(maskFormat), - glyph.fWidth, glyph.fHeight, bitmapRowBytes); + dstBitmap.setInfo(SkImageInfo::Make(glyph.fWidth, glyph.fHeight, + SkColorType_for_SkMaskFormat(maskFormat), + kPremul_SkAlphaType), + bitmapRowBytes); if (SkMask::kBW_Format == maskFormat || SkMask::kLCD16_Format == maskFormat) { dstBitmap.allocPixels(); } else { diff --git a/src/ports/SkImageDecoder_CG.cpp b/src/ports/SkImageDecoder_CG.cpp index a21536b111..8545ac8678 100644 --- a/src/ports/SkImageDecoder_CG.cpp +++ b/src/ports/SkImageDecoder_CG.cpp @@ -68,9 +68,8 @@ bool SkImageDecoder_CG::onDecode(SkStream* stream, SkBitmap* bm, Mode mode) { const int width = SkToInt(CGImageGetWidth(image)); const int height = SkToInt(CGImageGetHeight(image)); - SkImageInfo skinfo = SkImageInfo::MakeN32Premul(width, height); - bm->setInfo(skinfo); + bm->setInfo(SkImageInfo::MakeN32Premul(width, height)); if (SkImageDecoder::kDecodeBounds_Mode == mode) { return true; } diff --git a/src/ports/SkImageDecoder_empty.cpp b/src/ports/SkImageDecoder_empty.cpp index a3503e42bd..d8f3315d2b 100644 --- a/src/ports/SkImageDecoder_empty.cpp +++ b/src/ports/SkImageDecoder_empty.cpp @@ -94,7 +94,7 @@ bool SkImageDecoder::cropBitmap(SkBitmap*, SkBitmap*, int, int, int, int, int, return false; } -bool SkImageDecoder::chooseFromOneChoice(SkBitmap::Config, int, int) const { +bool SkImageDecoder::chooseFromOneChoice(SkColorType, int, int) const { return false; } @@ -102,11 +102,6 @@ bool SkImageDecoder::allocPixelRef(SkBitmap*, SkColorTable*) const { return false; } -SkBitmap::Config SkImageDecoder::getPrefConfig(SrcDepth, bool) const { - return SkBitmap::kNo_Config; -} - - ///////////////////////////////////////////////////////////////////////// // Empty implementation for SkMovie. diff --git a/tests/ARGBImageEncoderTest.cpp b/tests/ARGBImageEncoderTest.cpp index 7101165547..18f315fca9 100644 --- a/tests/ARGBImageEncoderTest.cpp +++ b/tests/ARGBImageEncoderTest.cpp @@ -12,9 +12,9 @@ #include "SkStream.h" #include "Test.h" -static SkBitmap::Config configs[] = { - SkBitmap::kRGB_565_Config, - SkBitmap::kARGB_8888_Config, +static SkColorType gColorTypes[] = { + kRGB_565_SkColorType, + kN32_SkColorType, }; DEF_TEST(ARGBImageEncoder, reporter) { @@ -31,13 +31,13 @@ DEF_TEST(ARGBImageEncoder, reporter) { }; SkAutoTDelete<SkImageEncoder> enc(CreateARGBImageEncoder()); - for (size_t configIndex = 0; configIndex < SK_ARRAY_COUNT(configs); ++configIndex) { + for (size_t ctIndex = 0; ctIndex < SK_ARRAY_COUNT(gColorTypes); ++ctIndex) { // A bitmap that should generate the above bytes: SkBitmap bitmap; { - bitmap.setConfig(configs[configIndex], kWidth, kHeight); - REPORTER_ASSERT(reporter, bitmap.allocPixels()); - bitmap.setAlphaType(kOpaque_SkAlphaType); + bool success = bitmap.allocPixels(SkImageInfo::Make(kWidth, kHeight, + gColorTypes[ctIndex], kOpaque_SkAlphaType)); + REPORTER_ASSERT(reporter, success); bitmap.eraseColor(SK_ColorBLUE); // Change rows [0,1] from blue to [red,green]. SkCanvas canvas(bitmap); diff --git a/tests/CachedDecodingPixelRefTest.cpp b/tests/CachedDecodingPixelRefTest.cpp index eff77e215d..8de7da79a2 100644 --- a/tests/CachedDecodingPixelRefTest.cpp +++ b/tests/CachedDecodingPixelRefTest.cpp @@ -23,10 +23,8 @@ * Fill this bitmap with some color. */ static void make_test_image(SkBitmap* bm) { - static const int W = 50, H = 50; - static const SkBitmap::Config config = SkBitmap::kARGB_8888_Config; - bm->setConfig(config, W, H); - bm->allocPixels(); + const int W = 50, H = 50; + bm->allocN32Pixels(W, H); bm->eraseColor(SK_ColorBLACK); SkCanvas canvas(*bm); SkPaint paint; diff --git a/tests/KtxTest.cpp b/tests/KtxTest.cpp index ee6a17dabd..94a4c22e03 100644 --- a/tests/KtxTest.cpp +++ b/tests/KtxTest.cpp @@ -27,9 +27,7 @@ DEF_TEST(KtxReadWrite, reporter) { SkRandom rand(0x1005cbad); SkBitmap bm8888; - bm8888.setConfig(SkBitmap::kARGB_8888_Config, 128, 128); - - bool pixelsAllocated = bm8888.allocPixels(); + bool pixelsAllocated = bm8888.allocN32Pixels(128, 128); REPORTER_ASSERT(reporter, pixelsAllocated); uint8_t *pixels = reinterpret_cast<uint8_t*>(bm8888.getPixels()); diff --git a/tools/picture_utils.cpp b/tools/picture_utils.cpp index c698a69835..4e6c81e417 100644 --- a/tools/picture_utils.cpp +++ b/tools/picture_utils.cpp @@ -97,8 +97,7 @@ namespace sk_tools { } void setup_bitmap(SkBitmap* bitmap, int width, int height) { - bitmap->setConfig(SkBitmap::kARGB_8888_Config, width, height); - bitmap->allocPixels(); + bitmap->allocN32Pixels(width, height); bitmap->eraseColor(SK_ColorTRANSPARENT); } diff --git a/tools/skdiff_utils.cpp b/tools/skdiff_utils.cpp index 5ca3d8085d..5c9aae275a 100644 --- a/tools/skdiff_utils.cpp +++ b/tools/skdiff_utils.cpp @@ -144,11 +144,9 @@ void create_and_write_diff_image(DiffRecord* drp, if (w != drp->fComparison.fBitmap.width() || h != drp->fComparison.fBitmap.height()) { drp->fResult = DiffRecord::kDifferentSizes_Result; } else { - drp->fDifference.fBitmap.setConfig(SkBitmap::kARGB_8888_Config, w, h); - drp->fDifference.fBitmap.allocPixels(); + drp->fDifference.fBitmap.allocN32Pixels(w, h); - drp->fWhite.fBitmap.setConfig(SkBitmap::kARGB_8888_Config, w, h); - drp->fWhite.fBitmap.allocPixels(); + drp->fWhite.fBitmap.allocN32Pixels(w, h); SkASSERT(DiffRecord::kUnknown_Result == drp->fResult); compute_diff(drp, dmp, colorThreshold); diff --git a/tools/skpdiff/SkDifferentPixelsMetric_cpu.cpp b/tools/skpdiff/SkDifferentPixelsMetric_cpu.cpp index 27c7a135d7..768bfc7d21 100644 --- a/tools/skpdiff/SkDifferentPixelsMetric_cpu.cpp +++ b/tools/skpdiff/SkDifferentPixelsMetric_cpu.cpp @@ -30,9 +30,7 @@ bool SkDifferentPixelsMetric::diff(SkBitmap* baseline, SkBitmap* test, bool comp // Prepare the POI alpha mask if needed if (computeMask) { - result->poiAlphaMask.setConfig(SkBitmap::kA8_Config, width, height); - result->poiAlphaMask.allocPixels(); - result->poiAlphaMask.lockPixels(); + result->poiAlphaMask.allocPixels(SkImageInfo::MakeA8(width, height)); result->poiAlphaMask.eraseARGB(SK_AlphaOPAQUE, 0, 0, 0); } |