diff options
Diffstat (limited to 'chromium/third_party/skia/include/core/SkColorPriv.h')
| -rw-r--r-- | chromium/third_party/skia/include/core/SkColorPriv.h | 159 |
1 files changed, 151 insertions, 8 deletions
diff --git a/chromium/third_party/skia/include/core/SkColorPriv.h b/chromium/third_party/skia/include/core/SkColorPriv.h index 7a74c4a034b..21e17836dd0 100644 --- a/chromium/third_party/skia/include/core/SkColorPriv.h +++ b/chromium/third_party/skia/include/core/SkColorPriv.h @@ -1,4 +1,3 @@ - /* * Copyright 2006 The Android Open Source Project * @@ -6,7 +5,6 @@ * found in the LICENSE file. */ - #ifndef SkColorPriv_DEFINED #define SkColorPriv_DEFINED @@ -18,6 +16,134 @@ #include "SkColor.h" #include "SkMath.h" +////////////////////////////////////////////////////////////////////////////// + +#define SkASSERT_IS_BYTE(x) SkASSERT(0 == ((x) & ~0xFF)) + +/* + * Skia's 32bit backend only supports 1 sizzle order at a time (compile-time). + * This is specified by 4 defines SK_A32_SHIFT, SK_R32_SHIFT, ... for G and B. + * + * For easier compatibility with Skia's GPU backend, we further restrict these + * to either (in memory-byte-order) RGBA or BGRA. Note that this "order" does + * not directly correspond to the same shift-order, since we have to take endianess + * into account. + * + * Here we enforce this constraint. + */ + +#ifdef SK_CPU_BENDIAN + #define SK_RGBA_R32_SHIFT 24 + #define SK_RGBA_G32_SHIFT 16 + #define SK_RGBA_B32_SHIFT 8 + #define SK_RGBA_A32_SHIFT 0 + + #define SK_BGRA_B32_SHIFT 24 + #define SK_BGRA_G32_SHIFT 16 + #define SK_BGRA_R32_SHIFT 8 + #define SK_BGRA_A32_SHIFT 0 +#else + #define SK_RGBA_R32_SHIFT 0 + #define SK_RGBA_G32_SHIFT 8 + #define SK_RGBA_B32_SHIFT 16 + #define SK_RGBA_A32_SHIFT 24 + + #define SK_BGRA_B32_SHIFT 0 + #define SK_BGRA_G32_SHIFT 8 + #define SK_BGRA_R32_SHIFT 16 + #define SK_BGRA_A32_SHIFT 24 +#endif + +#if defined(SK_PMCOLOR_IS_RGBA) && defined(SK_PMCOLOR_IS_BGRA) + #error "can't define PMCOLOR to be RGBA and BGRA" +#endif + +#define LOCAL_PMCOLOR_SHIFTS_EQUIVALENT_TO_RGBA \ + (SK_A32_SHIFT == SK_RGBA_A32_SHIFT && \ + SK_R32_SHIFT == SK_RGBA_R32_SHIFT && \ + SK_G32_SHIFT == SK_RGBA_G32_SHIFT && \ + SK_B32_SHIFT == SK_RGBA_B32_SHIFT) + +#define LOCAL_PMCOLOR_SHIFTS_EQUIVALENT_TO_BGRA \ + (SK_A32_SHIFT == SK_BGRA_A32_SHIFT && \ + SK_R32_SHIFT == SK_BGRA_R32_SHIFT && \ + SK_G32_SHIFT == SK_BGRA_G32_SHIFT && \ + SK_B32_SHIFT == SK_BGRA_B32_SHIFT) + + +#if defined(SK_PMCOLOR_IS_RGBA) && !LOCAL_PMCOLOR_SHIFTS_EQUIVALENT_TO_RGBA + #error "SK_PMCOLOR_IS_RGBA does not match SK_*32_SHIFT values" +#endif + +#if defined(SK_PMCOLOR_IS_BGRA) && !LOCAL_PMCOLOR_SHIFTS_EQUIVALENT_TO_BGRA + #error "SK_PMCOLOR_IS_BGRA does not match SK_*32_SHIFT values" +#endif + +#if !defined(SK_PMCOLOR_IS_RGBA) && !defined(SK_PMCOLOR_IS_RGBA) + // deduce which to define from the _SHIFT defines + + #if LOCAL_PMCOLOR_SHIFTS_EQUIVALENT_TO_RGBA + #define SK_PMCOLOR_IS_RGBA + #elif LOCAL_PMCOLOR_SHIFTS_EQUIVALENT_TO_BGRA + #define SK_PMCOLOR_IS_BGRA + #else + #error "need 32bit packing to be either RGBA or BGRA" + #endif +#endif + +// hide these now that we're done +#undef LOCAL_PMCOLOR_SHIFTS_EQUIVALENT_TO_RGBA +#undef LOCAL_PMCOLOR_SHIFTS_EQUIVALENT_TO_BGRA + +////////////////////////////////////////////////////////////////////////////// + +// Reverse the bytes coorsponding to RED and BLUE in a packed pixels. Note the +// pair of them are in the same 2 slots in both RGBA and BGRA, thus there is +// no need to pass in the colortype to this function. +static inline uint32_t SkSwizzle_RB(uint32_t c) { + static const uint32_t kRBMask = (0xFF << SK_R32_SHIFT) | (0xFF << SK_B32_SHIFT); + + unsigned c0 = (c >> SK_R32_SHIFT) & 0xFF; + unsigned c1 = (c >> SK_B32_SHIFT) & 0xFF; + return (c & ~kRBMask) | (c0 << SK_B32_SHIFT) | (c1 << SK_R32_SHIFT); +} + +static inline uint32_t SkPackARGB_as_RGBA(U8CPU a, U8CPU r, U8CPU g, U8CPU b) { + SkASSERT_IS_BYTE(a); + SkASSERT_IS_BYTE(r); + SkASSERT_IS_BYTE(g); + SkASSERT_IS_BYTE(b); + return (a << SK_RGBA_A32_SHIFT) | (r << SK_RGBA_R32_SHIFT) | + (g << SK_RGBA_G32_SHIFT) | (b << SK_RGBA_B32_SHIFT); +} + +static inline uint32_t SkPackARGB_as_BGRA(U8CPU a, U8CPU r, U8CPU g, U8CPU b) { + SkASSERT_IS_BYTE(a); + SkASSERT_IS_BYTE(r); + SkASSERT_IS_BYTE(g); + SkASSERT_IS_BYTE(b); + return (a << SK_BGRA_A32_SHIFT) | (r << SK_BGRA_R32_SHIFT) | + (g << SK_BGRA_G32_SHIFT) | (b << SK_BGRA_B32_SHIFT); +} + +static inline SkPMColor SkSwizzle_RGBA_to_PMColor(uint32_t c) { +#ifdef SK_PMCOLOR_IS_RGBA + return c; +#else + return SkSwizzle_RB(c); +#endif +} + +static inline SkPMColor SkSwizzle_BGRA_to_PMColor(uint32_t c) { +#ifdef SK_PMCOLOR_IS_BGRA + return c; +#else + return SkSwizzle_RB(c); +#endif +} + +////////////////////////////////////////////////////////////////////////////// + ///@{ /** See ITU-R Recommendation BT.709 at http://www.itu.int/rec/R-REC-BT.709/ .*/ #define SK_ITU_BT709_LUM_COEFF_R (0.2126f) @@ -55,6 +181,15 @@ static inline unsigned SkAlpha255To256(U8CPU alpha) { return alpha + 1; } +/** + * Turn a 0..255 value into a 0..256 value, rounding up if the value is >= 0x80. + * This is slightly more accurate than SkAlpha255To256. + */ +static inline unsigned Sk255To256(U8CPU value) { + SkASSERT(SkToU8(value) == value); + return value + (value >> 7); +} + /** Multiplify value by 0..256, and shift the result down 8 (i.e. return (value * alpha256) >> 8) */ @@ -239,6 +374,16 @@ static inline SkPMColor SkPackARGB32(U8CPU a, U8CPU r, U8CPU g, U8CPU b) { (g << SK_G32_SHIFT) | (b << SK_B32_SHIFT); } +static inline uint32_t SkPackPMColor_as_RGBA(SkPMColor c) { + return SkPackARGB_as_RGBA(SkGetPackedA32(c), SkGetPackedR32(c), + SkGetPackedG32(c), SkGetPackedB32(c)); +} + +static inline uint32_t SkPackPMColor_as_BGRA(SkPMColor c) { + return SkPackARGB_as_BGRA(SkGetPackedA32(c), SkGetPackedR32(c), + SkGetPackedG32(c), SkGetPackedB32(c)); +} + /** * Abstract 4-byte interpolation, implemented on top of SkPMColor * utility functions. Third parameter controls blending of the first two: @@ -379,10 +524,10 @@ SkPMColor SkPremultiplyARGBInline(U8CPU a, U8CPU r, U8CPU g, U8CPU b) { return SkPackARGB32(a, r, g, b); } -SK_API extern const uint32_t gMask_00FF00FF; - -static inline uint32_t SkAlphaMulQ(uint32_t c, unsigned scale) { - uint32_t mask = gMask_00FF00FF; +// When Android is compiled optimizing for size, SkAlphaMulQ doesn't get +// inlined; forcing inlining significantly improves performance. +static SK_ALWAYS_INLINE uint32_t SkAlphaMulQ(uint32_t c, unsigned scale) { + uint32_t mask = 0xFF00FF; uint32_t rb = ((c & mask) * scale) >> 8; uint32_t ag = ((c >> 8) & mask) * scale; @@ -642,8 +787,6 @@ static inline SkPMColor16 SkPackARGB4444(unsigned a, unsigned r, (g << SK_G4444_SHIFT) | (b << SK_B4444_SHIFT)); } -extern const uint16_t gMask_0F0F; - static inline U16CPU SkAlphaMulQ4(U16CPU c, unsigned scale) { SkASSERT(scale <= 16); |