AuroraMiddleware/skia2
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

replace config() with colorType()

Browse Source 
BUG=skia:
R=robertphillips@google.com

Author: reed@google.com

Review URL: https://codereview.chromium.org/303543009

git-svn-id: http://skia.googlecode.com/svn/trunk@14959 2bbb7eff-a529-9590-31e7-b0007b416f81
This commit is contained in:
commit-bot@chromium.org 2014-05-29 15:57:47 +00:00
parent 00f8d6c75d
commit cba73780bb
15 changed files with 109 additions and 92 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
gm/gm_expectations.h
View File

@ -158,7 +158,7 @@ namespace skiagm {
* than a single bitmap), returns NULL.
*/
const SkBitmap *asBitmap() const {
return (SkBitmap::kNo_Config == fBitmap.config()) ? NULL : &fBitmap;
return (kUnknown_SkColorType == fBitmap.colorType()) ? NULL : &fBitmap;
}
#ifdef SK_BUILD_JSON_WRITER

2
include/core/SkBlitRow.h
View File

@ -36,7 +36,7 @@ public:
const SkPMColor* src,
int count, U8CPU alpha, int x, int y);
static Proc Factory(unsigned flags, SkBitmap::Config);
static Proc Factory(unsigned flags, SkColorType);
///////////// D32 version

58
src/core/SkBitmap.cpp
View File

@ -646,29 +646,29 @@ SkColor SkBitmap::getColor(int x, int y) const {
SkASSERT((unsigned)x < (unsigned)this->width());
SkASSERT((unsigned)y < (unsigned)this->height());
switch (this->config()) {
case SkBitmap::kA8_Config: {
switch (this->colorType()) {
case kAlpha_8_SkColorType: {
uint8_t* addr = this->getAddr8(x, y);
return SkColorSetA(0, addr[0]);
}
case SkBitmap::kIndex8_Config: {
case kIndex_8_SkColorType: {
SkPMColor c = this->getIndex8Color(x, y);
return SkUnPreMultiply::PMColorToColor(c);
}
case SkBitmap::kRGB_565_Config: {
case kRGB_565_SkColorType: {
uint16_t* addr = this->getAddr16(x, y);
return SkPixel16ToColor(addr[0]);
}
case SkBitmap::kARGB_4444_Config: {
case kARGB_4444_SkColorType: {
uint16_t* addr = this->getAddr16(x, y);
SkPMColor c = SkPixel4444ToPixel32(addr[0]);
return SkUnPreMultiply::PMColorToColor(c);
}
case SkBitmap::kARGB_8888_Config: {
case kBGRA_8888_SkColorType:
case kRGBA_8888_SkColorType: {
uint32_t* addr = this->getAddr32(x, y);
return SkUnPreMultiply::PMColorToColor(addr[0]);
}
case kNo_Config:
default:
SkASSERT(false);
return 0;
@ -686,8 +686,8 @@ bool SkBitmap::ComputeIsOpaque(const SkBitmap& bm) {
const int height = bm.height();
const int width = bm.width();
switch (bm.config()) {
case SkBitmap::kA8_Config: {
switch (bm.colorType()) {
case kAlpha_8_SkColorType: {
unsigned a = 0xFF;
for (int y = 0; y < height; ++y) {
const uint8_t* row = bm.getAddr8(0, y);
@ -700,7 +700,7 @@ bool SkBitmap::ComputeIsOpaque(const SkBitmap& bm) {
}
return true;
} break;
case SkBitmap::kIndex8_Config: {
case kIndex_8_SkColorType: {
SkAutoLockColors alc(bm);
const SkPMColor* table = alc.colors();
if (!table) {
@ -712,10 +712,10 @@ bool SkBitmap::ComputeIsOpaque(const SkBitmap& bm) {
}
return 0xFF == SkGetPackedA32(c);
} break;
case SkBitmap::kRGB_565_Config:
case kRGB_565_SkColorType:
return true;
break;
case SkBitmap::kARGB_4444_Config: {
case kARGB_4444_SkColorType: {
unsigned c = 0xFFFF;
for (int y = 0; y < height; ++y) {
const SkPMColor16* row = bm.getAddr16(0, y);
@ -728,7 +728,8 @@ bool SkBitmap::ComputeIsOpaque(const SkBitmap& bm) {
}
return true;
} break;
case SkBitmap::kARGB_8888_Config: {
case kBGRA_8888_SkColorType:
case kRGBA_8888_SkColorType: {
SkPMColor c = (SkPMColor)~0;
for (int y = 0; y < height; ++y) {
const SkPMColor* row = bm.getAddr32(0, y);
@ -883,8 +884,8 @@ bool SkBitmap::extractSubset(SkBitmap* result, const SkIRect& subset) const {
SkPixelRef* pixelRef = fPixelRef->deepCopy(this->config(), &subset);
if (pixelRef != NULL) {
SkBitmap dst;
dst.setConfig(this->config(), subset.width(), subset.height(), 0,
this->alphaType());
dst.setConfig(SkImageInfo::Make(subset.width(), subset.height(),
this->colorType(), this->alphaType()));
dst.setIsVolatile(this->isVolatile());
dst.setPixelRef(pixelRef)->unref();
SkDEBUGCODE(dst.validate());
@ -899,8 +900,8 @@ bool SkBitmap::extractSubset(SkBitmap* result, const SkIRect& subset) const {
SkASSERT(static_cast<unsigned>(r.fTop) < static_cast<unsigned>(this->height()));
SkBitmap dst;
dst.setConfig(this->config(), r.width(), r.height(), this->rowBytes(),
this->alphaType());
dst.setConfig(SkImageInfo::Make(r.width(), r.height(), this->colorType(), this->alphaType()),
this->rowBytes());
dst.setIsVolatile(this->isVolatile());
if (fPixelRef) {
@ -1129,7 +1130,7 @@ static bool GetBitmapAlpha(const SkBitmap& src, uint8_t* SK_RESTRICT alpha,
SkASSERT(alpha != NULL);
SkASSERT(alphaRowBytes >= src.width());
SkBitmap::Config config = src.config();
SkColorType colorType = src.colorType();
int w = src.width();
int h = src.height();
size_t rb = src.rowBytes();
@ -1144,14 +1145,14 @@ static bool GetBitmapAlpha(const SkBitmap& src, uint8_t* SK_RESTRICT alpha,
return false;
}
if (SkBitmap::kA8_Config == config && !src.isOpaque()) {
if (kAlpha_8_SkColorType == colorType && !src.isOpaque()) {
const uint8_t* s = src.getAddr8(0, 0);
while (--h >= 0) {
memcpy(alpha, s, w);
s += rb;
alpha += alphaRowBytes;
}
} else if (SkBitmap::kARGB_8888_Config == config && !src.isOpaque()) {
} else if (kN32_SkColorType == colorType && !src.isOpaque()) {
const SkPMColor* SK_RESTRICT s = src.getAddr32(0, 0);
while (--h >= 0) {
for (int x = 0; x < w; x++) {
@ -1160,7 +1161,7 @@ static bool GetBitmapAlpha(const SkBitmap& src, uint8_t* SK_RESTRICT alpha,
s = (const SkPMColor*)((const char*)s + rb);
alpha += alphaRowBytes;
}
} else if (SkBitmap::kARGB_4444_Config == config && !src.isOpaque()) {
} else if (kARGB_4444_SkColorType == colorType && !src.isOpaque()) {
const SkPMColor16* SK_RESTRICT s = src.getAddr16(0, 0);
while (--h >= 0) {
for (int x = 0; x < w; x++) {
@ -1169,7 +1170,7 @@ static bool GetBitmapAlpha(const SkBitmap& src, uint8_t* SK_RESTRICT alpha,
s = (const SkPMColor16*)((const char*)s + rb);
alpha += alphaRowBytes;
}
} else if (SkBitmap::kIndex8_Config == config && !src.isOpaque()) {
} else if (kIndex_8_SkColorType == colorType && !src.isOpaque()) {
SkColorTable* ct = src.getColorTable();
if (ct) {
const SkPMColor* SK_RESTRICT table = ct->lockColors();
@ -1217,8 +1218,7 @@ bool SkBitmap::extractAlpha(SkBitmap* dst, const SkPaint* paint,
dstM.fRowBytes = SkAlign4(dstM.fBounds.width());
} else {
NO_FILTER_CASE:
tmpBitmap.setConfig(SkBitmap::kA8_Config, this->width(), this->height(),
srcM.fRowBytes);
tmpBitmap.setConfig(SkImageInfo::MakeA8(this->width(), this->height()), srcM.fRowBytes);
if (!tmpBitmap.allocPixels(allocator, NULL)) {
// Allocation of pixels for alpha bitmap failed.
SkDebugf("extractAlpha failed to allocate (%d,%d) alpha bitmap\n",
@ -1241,8 +1241,8 @@ bool SkBitmap::extractAlpha(SkBitmap* dst, const SkPaint* paint,
}
SkAutoMaskFreeImage dstCleanup(dstM.fImage);
tmpBitmap.setConfig(SkBitmap::kA8_Config, dstM.fBounds.width(),
dstM.fBounds.height(), dstM.fRowBytes);
tmpBitmap.setConfig(SkImageInfo::MakeA8(dstM.fBounds.width(), dstM.fBounds.height()),
dstM.fRowBytes);
if (!tmpBitmap.allocPixels(allocator, NULL)) {
// Allocation of pixels for alpha bitmap failed.
SkDebugf("extractAlpha failed to allocate (%d,%d) alpha bitmap\n",
@ -1435,12 +1435,12 @@ void SkBitmap::validate() const {
#ifndef SK_IGNORE_TO_STRING
void SkBitmap::toString(SkString* str) const {
static const char* gConfigNames[kConfigCount] = {
"NONE", "A8", "INDEX8", "565", "4444", "8888"
static const char* gColorTypeNames[kLastEnum_SkColorType + 1] = {
"UNKNOWN", "A8", "565", "4444", "RGBA", "BGRA", "INDEX8",
};
str->appendf("bitmap: ((%d, %d) %s", this->width(), this->height(),
gConfigNames[this->config()]);
gColorTypeNames[this->colorType()]);
str->append(" (");
if (this->isOpaque()) {

2
src/core/SkBitmapDevice.cpp
View File

@ -461,7 +461,7 @@ bool SkBitmapDevice::filterTextFlags(const SkPaint& paint, TextFlags* flags) {
return false;
}
if (SkBitmap::kARGB_8888_Config != fBitmap.config() ||
if (kN32_SkColorType != fBitmap.colorType() ||
paint.getRasterizer() ||
paint.getPathEffect() ||
paint.isFakeBoldText() ||

24
src/core/SkBitmapProcState.cpp
View File

@ -147,7 +147,7 @@ bool SkBitmapProcState::possiblyScaleImage() {
if (SkPaint::kHigh_FilterLevel == fFilterLevel &&
fInvMatrix.getType() <= (SkMatrix::kScale_Mask | SkMatrix::kTranslate_Mask) &&
fOrigBitmap.config() == SkBitmap::kARGB_8888_Config) {
kN32_SkColorType == fOrigBitmap.colorType()) {
SkScalar invScaleX = fInvMatrix.getScaleX();
SkScalar invScaleY = fInvMatrix.getScaleY();
@ -285,10 +285,10 @@ bool SkBitmapProcState::possiblyScaleImage() {
SkScalar invScaleFixup = level.fScale;
fInvMatrix.postScale(invScaleFixup, invScaleFixup);
fScaledBitmap.setConfig(fOrigBitmap.config(),
level.fWidth, level.fHeight,
level.fRowBytes);
fScaledBitmap.setPixels(level.fPixels);
SkImageInfo info = fOrigBitmap.info();
info.fWidth = level.fWidth;
info.fHeight = level.fHeight;
fScaledBitmap.installPixels(info, level.fPixels, level.fRowBytes);
fBitmap = &fScaledBitmap;
fFilterLevel = SkPaint::kLow_FilterLevel;
unlocker.release();
@ -508,20 +508,20 @@ bool SkBitmapProcState::chooseProcs(const SkMatrix& inv, const SkPaint& paint) {
index |= 4;
}
// bits 3,4,5 encoding the source bitmap format
switch (fBitmap->config()) {
case SkBitmap::kARGB_8888_Config:
switch (fBitmap->colorType()) {
case kN32_SkColorType:
index |= 0;
break;
case SkBitmap::kRGB_565_Config:
case kRGB_565_SkColorType:
index |= 8;
break;
case SkBitmap::kIndex8_Config:
case kIndex_8_SkColorType:
index |= 16;
break;
case SkBitmap::kARGB_4444_Config:
case kARGB_4444_SkColorType:
index |= 24;
break;
case SkBitmap::kA8_Config:
case kAlpha_8_SkColorType:
index |= 32;
fPaintPMColor = SkPreMultiplyColor(paint.getColor());
break;
@ -886,7 +886,7 @@ bool SkBitmapProcState::setupForTranslate() {
SkBitmapProcState::ShaderProc32 SkBitmapProcState::chooseShaderProc32() {
if (SkBitmap::kARGB_8888_Config != fBitmap->config()) {
if (kN32_SkColorType != fBitmap->colorType()) {
return NULL;
}

30
src/core/SkBitmapProcState_procs.h
View File

@ -90,7 +90,7 @@ static inline U8CPU Filter_8(unsigned x, unsigned y,
#define MAKENAME(suffix) NAME_WRAP(S32_opaque_D32 ## suffix)
#define DSTSIZE 32
#define SRCTYPE SkPMColor
#define CHECKSTATE(state) SkASSERT(state.fBitmap->config() == SkBitmap::kARGB_8888_Config); \
#define CHECKSTATE(state) SkASSERT(4 == state.fBitmap->bytesPerPixel()); \
SkASSERT(state.fAlphaScale == 256)
#define RETURNDST(src) src
#define SRC_TO_FILTER(src) src
@ -102,7 +102,7 @@ static inline U8CPU Filter_8(unsigned x, unsigned y,
#define MAKENAME(suffix) NAME_WRAP(S32_alpha_D32 ## suffix)
#define DSTSIZE 32
#define SRCTYPE SkPMColor
#define CHECKSTATE(state) SkASSERT(state.fBitmap->config() == SkBitmap::kARGB_8888_Config); \
#define CHECKSTATE(state) SkASSERT(4 == state.fBitmap->bytesPerPixel()); \
SkASSERT(state.fAlphaScale < 256)
#define PREAMBLE(state) unsigned alphaScale = state.fAlphaScale
#define RETURNDST(src) SkAlphaMulQ(src, alphaScale)
@ -121,7 +121,7 @@ static inline U8CPU Filter_8(unsigned x, unsigned y,
#define MAKENAME(suffix) NAME_WRAP(S16_opaque_D32 ## suffix)
#define DSTSIZE 32
#define SRCTYPE uint16_t
#define CHECKSTATE(state) SkASSERT(state.fBitmap->config() == SkBitmap::kRGB_565_Config); \
#define CHECKSTATE(state) SkASSERT(kRGB_565_SkColorType == state.fBitmap->colorType()); \
SkASSERT(state.fAlphaScale == 256)
#define RETURNDST(src) SkPixel16ToPixel32(src)
#define SRC_TO_FILTER(src) src
@ -137,7 +137,7 @@ static inline U8CPU Filter_8(unsigned x, unsigned y,
#define MAKENAME(suffix) NAME_WRAP(S16_alpha_D32 ## suffix)
#define DSTSIZE 32
#define SRCTYPE uint16_t
#define CHECKSTATE(state) SkASSERT(state.fBitmap->config() == SkBitmap::kRGB_565_Config); \
#define CHECKSTATE(state) SkASSERT(kRGB_565_SkColorType == state.fBitmap->colorType()); \
SkASSERT(state.fAlphaScale < 256)
#define PREAMBLE(state) unsigned alphaScale = state.fAlphaScale
#define RETURNDST(src) SkAlphaMulQ(SkPixel16ToPixel32(src), alphaScale)
@ -152,7 +152,7 @@ static inline U8CPU Filter_8(unsigned x, unsigned y,
#define MAKENAME(suffix) NAME_WRAP(SI8_opaque_D32 ## suffix)
#define DSTSIZE 32
#define SRCTYPE uint8_t
#define CHECKSTATE(state) SkASSERT(state.fBitmap->config() == SkBitmap::kIndex8_Config); \
#define CHECKSTATE(state) SkASSERT(kIndex_8_SkColorType == state.fBitmap->colorType()); \
SkASSERT(state.fAlphaScale == 256)
#define PREAMBLE(state) const SkPMColor* SK_RESTRICT table = state.fBitmap->getColorTable()->lockColors()
#define RETURNDST(src) table[src]
@ -166,7 +166,7 @@ static inline U8CPU Filter_8(unsigned x, unsigned y,
#define MAKENAME(suffix) NAME_WRAP(SI8_alpha_D32 ## suffix)
#define DSTSIZE 32
#define SRCTYPE uint8_t
#define CHECKSTATE(state) SkASSERT(state.fBitmap->config() == SkBitmap::kIndex8_Config); \
#define CHECKSTATE(state) SkASSERT(kIndex_8_SkColorType == state.fBitmap->colorType()); \
SkASSERT(state.fAlphaScale < 256)
#define PREAMBLE(state) unsigned alphaScale = state.fAlphaScale; \
const SkPMColor* SK_RESTRICT table = state.fBitmap->getColorTable()->lockColors()
@ -183,7 +183,7 @@ static inline U8CPU Filter_8(unsigned x, unsigned y,
#define MAKENAME(suffix) NAME_WRAP(S4444_opaque_D32 ## suffix)
#define DSTSIZE 32
#define SRCTYPE SkPMColor16
#define CHECKSTATE(state) SkASSERT(state.fBitmap->config() == SkBitmap::kARGB_4444_Config); \
#define CHECKSTATE(state) SkASSERT(kARGB_4444_SkColorType == state.fBitmap->colorType()); \
SkASSERT(state.fAlphaScale == 256)
#define RETURNDST(src) SkPixel4444ToPixel32(src)
#define SRC_TO_FILTER(src) src
@ -199,7 +199,7 @@ static inline U8CPU Filter_8(unsigned x, unsigned y,
#define MAKENAME(suffix) NAME_WRAP(S4444_alpha_D32 ## suffix)
#define DSTSIZE 32
#define SRCTYPE SkPMColor16
#define CHECKSTATE(state) SkASSERT(state.fBitmap->config() == SkBitmap::kARGB_4444_Config); \
#define CHECKSTATE(state) SkASSERT(kARGB_4444_SkColorType == state.fBitmap->colorType()); \
SkASSERT(state.fAlphaScale < 256)
#define PREAMBLE(state) unsigned alphaScale = state.fAlphaScale
#define RETURNDST(src) SkAlphaMulQ(SkPixel4444ToPixel32(src), alphaScale)
@ -218,7 +218,7 @@ static inline U8CPU Filter_8(unsigned x, unsigned y,
#define MAKENAME(suffix) NAME_WRAP(SA8_alpha_D32 ## suffix)
#define DSTSIZE 32
#define SRCTYPE uint8_t
#define CHECKSTATE(state) SkASSERT(state.fBitmap->config() == SkBitmap::kA8_Config);
#define CHECKSTATE(state) SkASSERT(kAlpha_8_SkColorType == state.fBitmap->colorType());
#define PREAMBLE(state) const SkPMColor pmColor = state.fPaintPMColor;
#define RETURNDST(src) SkAlphaMulQ(pmColor, SkAlpha255To256(src))
#define SRC_TO_FILTER(src) src
@ -243,7 +243,7 @@ static inline U8CPU Filter_8(unsigned x, unsigned y,
#define MAKENAME(suffix) NAME_WRAP(S32_D16 ## suffix)
#define DSTSIZE 16
#define SRCTYPE SkPMColor
#define CHECKSTATE(state) SkASSERT(state.fBitmap->config() == SkBitmap::kARGB_8888_Config); \
#define CHECKSTATE(state) SkASSERT(4 == state.fBitmap->bytesPerPixel()); \
SkASSERT(state.fBitmap->isOpaque())
#define RETURNDST(src) SkPixel32ToPixel16(src)
#define SRC_TO_FILTER(src) src
@ -261,7 +261,7 @@ static inline U8CPU Filter_8(unsigned x, unsigned y,
#define MAKENAME(suffix) NAME_WRAP(S16_D16 ## suffix)
#define DSTSIZE 16
#define SRCTYPE uint16_t
#define CHECKSTATE(state) SkASSERT(state.fBitmap->config() == SkBitmap::kRGB_565_Config)
#define CHECKSTATE(state) SkASSERT(kRGB_565_SkColorType == state.fBitmap->colorType())
#define RETURNDST(src) src
#define SRC_TO_FILTER(src) src
#include "SkBitmapProcState_sample.h"
@ -278,7 +278,7 @@ static inline U8CPU Filter_8(unsigned x, unsigned y,
#define MAKENAME(suffix) NAME_WRAP(SI8_D16 ## suffix)
#define DSTSIZE 16
#define SRCTYPE uint8_t
#define CHECKSTATE(state) SkASSERT(state.fBitmap->config() == SkBitmap::kIndex8_Config); \
#define CHECKSTATE(state) SkASSERT(kIndex_8_SkColorType == state.fBitmap->colorType()); \
SkASSERT(state.fBitmap->isOpaque())
#define PREAMBLE(state) const uint16_t* SK_RESTRICT table = state.fBitmap->getColorTable()->lock16BitCache()
#define RETURNDST(src) table[src]
@ -306,7 +306,7 @@ static inline U8CPU Filter_8(unsigned x, unsigned y,
#define MAKENAME(suffix) NAME_WRAP(Clamp_S16_D16 ## suffix)
#define SRCTYPE uint16_t
#define DSTTYPE uint16_t
#define CHECKSTATE(state) SkASSERT(state.fBitmap->config() == SkBitmap::kRGB_565_Config)
#define CHECKSTATE(state) SkASSERT(kRGB_565_SkColorType == state.fBitmap->colorType())
#define SRC_TO_FILTER(src) src
#include "SkBitmapProcState_shaderproc.h"
@ -319,7 +319,7 @@ static inline U8CPU Filter_8(unsigned x, unsigned y,
#define MAKENAME(suffix) NAME_WRAP(Repeat_S16_D16 ## suffix)
#define SRCTYPE uint16_t
#define DSTTYPE uint16_t
#define CHECKSTATE(state) SkASSERT(state.fBitmap->config() == SkBitmap::kRGB_565_Config)
#define CHECKSTATE(state) SkASSERT(kRGB_565_SkColorType == state.fBitmap->colorType())
#define SRC_TO_FILTER(src) src
#include "SkBitmapProcState_shaderproc.h"
@ -334,7 +334,7 @@ static inline U8CPU Filter_8(unsigned x, unsigned y,
#define MAKENAME(suffix) NAME_WRAP(Clamp_SI8_opaque_D32 ## suffix)
#define SRCTYPE uint8_t
#define DSTTYPE uint32_t
#define CHECKSTATE(state) SkASSERT(state.fBitmap->config() == SkBitmap::kIndex8_Config)
#define CHECKSTATE(state) SkASSERT(kIndex_8_SkColorType == state.fBitmap->colorType())
#define PREAMBLE(state) const SkPMColor* SK_RESTRICT table = state.fBitmap->getColorTable()->lockColors()
#define SRC_TO_FILTER(src) table[src]
#define POSTAMBLE(state) state.fBitmap->getColorTable()->unlockColors()

8
src/core/SkBlitMask.h
View File

@ -51,13 +51,13 @@ public:
* Public entry-point to return a blitmask ColorProc.
* May return NULL if config or format are not supported.
*/
static ColorProc ColorFactory(SkBitmap::Config, SkMask::Format, SkColor);
static ColorProc ColorFactory(SkColorType, SkMask::Format, SkColor);
/**
* Return either platform specific optimized blitmask ColorProc,
* or NULL if no optimized routine is available.
*/
static ColorProc PlatformColorProcs(SkBitmap::Config, SkMask::Format, SkColor);
static ColorProc PlatformColorProcs(SkColorType, SkMask::Format, SkColor);
/**
* Public entry-point to return a blitcolor BlitLCD16RowProc.
@ -78,13 +78,13 @@ public:
* Public entry-point to return a blitmask RowProc.
* May return NULL if config or format are not supported.
*/
static RowProc RowFactory(SkBitmap::Config, SkMask::Format, RowFlags);
static RowProc RowFactory(SkColorType, SkMask::Format, RowFlags);
/**
* Return either platform specific optimized blitmask RowProc,
* or NULL if no optimized routine is available.
*/
static RowProc PlatformRowProcs(SkBitmap::Config, SkMask::Format, RowFlags);
static RowProc PlatformRowProcs(SkColorType, SkMask::Format, RowFlags);
};
#endif

25
src/core/SkBlitMask_D32.cpp
View File

@ -1,3 +1,10 @@
/*
* Copyright 2014 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "SkBlitMask.h"
#include "SkColor.h"
#include "SkColorPriv.h"
@ -230,16 +237,16 @@ static SkBlitMask::ColorProc D32_LCD32_Factory(SkColor color) {
return (0xFF == SkColorGetA(color)) ? D32_LCD32_Opaque : D32_LCD32_Blend;
}
SkBlitMask::ColorProc SkBlitMask::ColorFactory(SkBitmap::Config config,
SkBlitMask::ColorProc SkBlitMask::ColorFactory(SkColorType ct,
SkMask::Format format,
SkColor color) {
ColorProc proc = PlatformColorProcs(config, format, color);
ColorProc proc = PlatformColorProcs(ct, format, color);
if (proc) {
return proc;
}
switch (config) {
case SkBitmap::kARGB_8888_Config:
switch (ct) {
case kN32_SkColorType:
switch (format) {
case SkMask::kA8_Format:
return D32_A8_Factory(color);
@ -259,7 +266,7 @@ SkBlitMask::ColorProc SkBlitMask::ColorFactory(SkBitmap::Config config,
bool SkBlitMask::BlitColor(const SkBitmap& device, const SkMask& mask,
const SkIRect& clip, SkColor color) {
ColorProc proc = ColorFactory(device.config(), mask.fFormat, color);
ColorProc proc = ColorFactory(device.colorType(), mask.fFormat, color);
if (proc) {
int x = clip.fLeft;
int y = clip.fTop;
@ -548,11 +555,11 @@ static void LCD32_RowProc_Opaque(SkPMColor* SK_RESTRICT dst,
}
}
SkBlitMask::RowProc SkBlitMask::RowFactory(SkBitmap::Config config,
SkBlitMask::RowProc SkBlitMask::RowFactory(SkColorType ct,
SkMask::Format format,
RowFlags flags) {
// make this opt-in until chrome can rebaseline
RowProc proc = PlatformRowProcs(config, format, flags);
RowProc proc = PlatformRowProcs(ct, format, flags);
if (proc) {
return proc;
}
@ -567,8 +574,8 @@ SkBlitMask::RowProc SkBlitMask::RowFactory(SkBitmap::Config config,
};
int index;
switch (config) {
case SkBitmap::kARGB_8888_Config:
switch (ct) {
case kN32_SkColorType:
switch (format) {
case SkMask::kBW_Format: index = 0; break;
case SkMask::kA8_Format: index = 2; break;

6
src/core/SkBlitRow_D16.cpp
View File

@ -224,15 +224,15 @@ static const SkBlitRow::Proc gDefault_565_Procs[] = {
S32A_D565_Blend_Dither
};
SkBlitRow::Proc SkBlitRow::Factory(unsigned flags, SkBitmap::Config config) {
SkBlitRow::Proc SkBlitRow::Factory(unsigned flags, SkColorType ct) {
SkASSERT(flags < SK_ARRAY_COUNT(gDefault_565_Procs));
// just so we don't crash
flags &= kFlags16_Mask;
SkBlitRow::Proc proc = NULL;
switch (config) {
case SkBitmap::kRGB_565_Config:
switch (ct) {
case kRGB_565_SkColorType:
proc = PlatformProcs565(flags);
if (NULL == proc) {
proc = gDefault_565_Procs[flags];

2
src/core/SkBlitter_ARGB32.cpp
View File

@ -500,7 +500,7 @@ void SkARGB32_Shader_Blitter::blitMask(const SkMask& mask, const SkIRect& clip)
if (shaderContext->getFlags() & SkShader::kOpaqueAlpha_Flag) {
flags |= SkBlitMask::kSrcIsOpaque_RowFlag;
}
proc = SkBlitMask::RowFactory(SkBitmap::kARGB_8888_Config, mask.fFormat,
proc = SkBlitMask::RowFactory(kN32_SkColorType, mask.fFormat,
(SkBlitMask::RowFlags)flags);
if (NULL == proc) {
this->INHERITED::blitMask(mask, clip);

4
src/core/SkBlitter_RGB16.cpp
View File

@ -826,10 +826,10 @@ SkRGB16_Shader_Blitter::SkRGB16_Shader_Blitter(const SkBitmap& device,
flags |= SkBlitRow::kDither_Flag;
}
// used when we know our global alpha is 0xFF
fOpaqueProc = SkBlitRow::Factory(flags, SkBitmap::kRGB_565_Config);
fOpaqueProc = SkBlitRow::Factory(flags, kRGB_565_SkColorType);
// used when we know our global alpha is < 0xFF
fAlphaProc = SkBlitRow::Factory(flags | SkBlitRow::kGlobalAlpha_Flag,
SkBitmap::kRGB_565_Config);
kRGB_565_SkColorType);
}
SkRGB16_Shader_Blitter::~SkRGB16_Shader_Blitter() {

2
src/core/SkSpriteBlitter_RGB16.cpp
View File

@ -278,7 +278,7 @@ public:
if (paint.isDither()) {
flags |= SkBlitRow::kDither_Flag;
}
fProc = SkBlitRow::Factory(flags, SkBitmap::kRGB_565_Config);
fProc = SkBlitRow::Factory(flags, kRGB_565_SkColorType);
}
virtual void blitRect(int x, int y, int width, int height) {

10
src/opts/SkBlitMask_opts_arm.cpp
View File

@ -1,3 +1,9 @@
/*
* Copyright 2014 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "SkColor.h"
#include "SkColorPriv.h"
@ -5,7 +11,7 @@
#include "SkUtilsArm.h"
#include "SkBlitMask_opts_arm_neon.h"
SkBlitMask::ColorProc SkBlitMask::PlatformColorProcs(SkBitmap::Config dstConfig,
SkBlitMask::ColorProc SkBlitMask::PlatformColorProcs(SkColorType dstCT,
SkMask::Format maskFormat,
SkColor color) {
#if SK_ARM_NEON_IS_NONE
@ -39,7 +45,7 @@ SkBlitMask::BlitLCD16RowProc SkBlitMask::PlatformBlitRowProcs16(bool isOpaque) {
}
}
SkBlitMask::RowProc SkBlitMask::PlatformRowProcs(SkBitmap::Config dstConfig,
SkBlitMask::RowProc SkBlitMask::PlatformRowProcs(SkColorType dstCT,
SkMask::Format maskFormat,
RowFlags flags) {
return NULL;

10
src/opts/SkBlitMask_opts_none.cpp
View File

@ -1,7 +1,13 @@
/*
* Copyright 2014 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "SkBlitMask.h"
SkBlitMask::ColorProc SkBlitMask::PlatformColorProcs(SkBitmap::Config dstConfig,
SkBlitMask::ColorProc SkBlitMask::PlatformColorProcs(SkColorType dstCT,
SkMask::Format maskFormat,
SkColor color) {
return NULL;
@ -11,7 +17,7 @@ SkBlitMask::BlitLCD16RowProc SkBlitMask::PlatformBlitRowProcs16(bool isOpaque) {
return NULL;
}
SkBlitMask::RowProc SkBlitMask::PlatformRowProcs(SkBitmap::Config dstConfig,
SkBlitMask::RowProc SkBlitMask::PlatformRowProcs(SkColorType dstCT,
SkMask::Format maskFormat,
RowFlags flags) {
return NULL;

10
src/opts/opts_check_x86.cpp
View File

@ -244,7 +244,7 @@ SkBlitRow::ColorRectProc PlatformColorRectProcFactory() {
////////////////////////////////////////////////////////////////////////////////
SkBlitMask::ColorProc SkBlitMask::PlatformColorProcs(SkBitmap::Config dstConfig,
SkBlitMask::ColorProc SkBlitMask::PlatformColorProcs(SkColorType dstCT,
SkMask::Format maskFormat,
SkColor color) {
if (SkMask::kA8_Format != maskFormat) {
@ -253,8 +253,8 @@ SkBlitMask::ColorProc SkBlitMask::PlatformColorProcs(SkBitmap::Config dstConfig,
ColorProc proc = NULL;
if (supports_simd(SK_CPU_SSE_LEVEL_SSE2)) {
switch (dstConfig) {
case SkBitmap::kARGB_8888_Config:
switch (dstCT) {
case kN32_SkColorType:
// The SSE2 version is not (yet) faster for black, so we check
// for that.
if (SK_ColorBLACK != color) {
@ -281,9 +281,7 @@ SkBlitMask::BlitLCD16RowProc SkBlitMask::PlatformBlitRowProcs16(bool isOpaque) {
}
SkBlitMask::RowProc SkBlitMask::PlatformRowProcs(SkBitmap::Config dstConfig,
SkMask::Format maskFormat,
RowFlags flags) {
SkBlitMask::RowProc SkBlitMask::PlatformRowProcs(SkColorType, SkMask::Format, RowFlags) {
return NULL;
}