SkColorData.h 15 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444
  1. /*
  2. * Copyright 2006 The Android Open Source Project
  3. *
  4. * Use of this source code is governed by a BSD-style license that can be
  5. * found in the LICENSE file.
  6. */
  7. #ifndef SkColorData_DEFINED
  8. #define SkColorData_DEFINED
  9. #include "include/core/SkColor.h"
  10. #include "include/core/SkColorPriv.h"
  11. #include "include/private/SkNx.h"
  12. #include "include/private/SkTo.h"
  13. ////////////////////////////////////////////////////////////////////////////////////////////
  14. // Convert a 16bit pixel to a 32bit pixel
  15. #define SK_R16_BITS 5
  16. #define SK_G16_BITS 6
  17. #define SK_B16_BITS 5
  18. #define SK_R16_SHIFT (SK_B16_BITS + SK_G16_BITS)
  19. #define SK_G16_SHIFT (SK_B16_BITS)
  20. #define SK_B16_SHIFT 0
  21. #define SK_R16_MASK ((1 << SK_R16_BITS) - 1)
  22. #define SK_G16_MASK ((1 << SK_G16_BITS) - 1)
  23. #define SK_B16_MASK ((1 << SK_B16_BITS) - 1)
  24. #define SkGetPackedR16(color) (((unsigned)(color) >> SK_R16_SHIFT) & SK_R16_MASK)
  25. #define SkGetPackedG16(color) (((unsigned)(color) >> SK_G16_SHIFT) & SK_G16_MASK)
  26. #define SkGetPackedB16(color) (((unsigned)(color) >> SK_B16_SHIFT) & SK_B16_MASK)
  27. static inline unsigned SkR16ToR32(unsigned r) {
  28. return (r << (8 - SK_R16_BITS)) | (r >> (2 * SK_R16_BITS - 8));
  29. }
  30. static inline unsigned SkG16ToG32(unsigned g) {
  31. return (g << (8 - SK_G16_BITS)) | (g >> (2 * SK_G16_BITS - 8));
  32. }
  33. static inline unsigned SkB16ToB32(unsigned b) {
  34. return (b << (8 - SK_B16_BITS)) | (b >> (2 * SK_B16_BITS - 8));
  35. }
  36. #define SkPacked16ToR32(c) SkR16ToR32(SkGetPackedR16(c))
  37. #define SkPacked16ToG32(c) SkG16ToG32(SkGetPackedG16(c))
  38. #define SkPacked16ToB32(c) SkB16ToB32(SkGetPackedB16(c))
  39. //////////////////////////////////////////////////////////////////////////////
  40. #define SkASSERT_IS_BYTE(x) SkASSERT(0 == ((x) & ~0xFF))
  41. // Reverse the bytes coorsponding to RED and BLUE in a packed pixels. Note the
  42. // pair of them are in the same 2 slots in both RGBA and BGRA, thus there is
  43. // no need to pass in the colortype to this function.
  44. static inline uint32_t SkSwizzle_RB(uint32_t c) {
  45. static const uint32_t kRBMask = (0xFF << SK_R32_SHIFT) | (0xFF << SK_B32_SHIFT);
  46. unsigned c0 = (c >> SK_R32_SHIFT) & 0xFF;
  47. unsigned c1 = (c >> SK_B32_SHIFT) & 0xFF;
  48. return (c & ~kRBMask) | (c0 << SK_B32_SHIFT) | (c1 << SK_R32_SHIFT);
  49. }
  50. static inline uint32_t SkPackARGB_as_RGBA(U8CPU a, U8CPU r, U8CPU g, U8CPU b) {
  51. SkASSERT_IS_BYTE(a);
  52. SkASSERT_IS_BYTE(r);
  53. SkASSERT_IS_BYTE(g);
  54. SkASSERT_IS_BYTE(b);
  55. return (a << SK_RGBA_A32_SHIFT) | (r << SK_RGBA_R32_SHIFT) |
  56. (g << SK_RGBA_G32_SHIFT) | (b << SK_RGBA_B32_SHIFT);
  57. }
  58. static inline uint32_t SkPackARGB_as_BGRA(U8CPU a, U8CPU r, U8CPU g, U8CPU b) {
  59. SkASSERT_IS_BYTE(a);
  60. SkASSERT_IS_BYTE(r);
  61. SkASSERT_IS_BYTE(g);
  62. SkASSERT_IS_BYTE(b);
  63. return (a << SK_BGRA_A32_SHIFT) | (r << SK_BGRA_R32_SHIFT) |
  64. (g << SK_BGRA_G32_SHIFT) | (b << SK_BGRA_B32_SHIFT);
  65. }
  66. static inline SkPMColor SkSwizzle_RGBA_to_PMColor(uint32_t c) {
  67. #ifdef SK_PMCOLOR_IS_RGBA
  68. return c;
  69. #else
  70. return SkSwizzle_RB(c);
  71. #endif
  72. }
  73. static inline SkPMColor SkSwizzle_BGRA_to_PMColor(uint32_t c) {
  74. #ifdef SK_PMCOLOR_IS_BGRA
  75. return c;
  76. #else
  77. return SkSwizzle_RB(c);
  78. #endif
  79. }
  80. //////////////////////////////////////////////////////////////////////////////
  81. ///@{
  82. /** See ITU-R Recommendation BT.709 at http://www.itu.int/rec/R-REC-BT.709/ .*/
  83. #define SK_ITU_BT709_LUM_COEFF_R (0.2126f)
  84. #define SK_ITU_BT709_LUM_COEFF_G (0.7152f)
  85. #define SK_ITU_BT709_LUM_COEFF_B (0.0722f)
  86. ///@}
  87. ///@{
  88. /** A float value which specifies this channel's contribution to luminance. */
  89. #define SK_LUM_COEFF_R SK_ITU_BT709_LUM_COEFF_R
  90. #define SK_LUM_COEFF_G SK_ITU_BT709_LUM_COEFF_G
  91. #define SK_LUM_COEFF_B SK_ITU_BT709_LUM_COEFF_B
  92. ///@}
  93. /** Computes the luminance from the given r, g, and b in accordance with
  94. SK_LUM_COEFF_X. For correct results, r, g, and b should be in linear space.
  95. */
  96. static inline U8CPU SkComputeLuminance(U8CPU r, U8CPU g, U8CPU b) {
  97. //The following is
  98. //r * SK_LUM_COEFF_R + g * SK_LUM_COEFF_G + b * SK_LUM_COEFF_B
  99. //with SK_LUM_COEFF_X in 1.8 fixed point (rounding adjusted to sum to 256).
  100. return (r * 54 + g * 183 + b * 19) >> 8;
  101. }
  102. /** Calculates 256 - (value * alpha256) / 255 in range [0,256],
  103. * for [0,255] value and [0,256] alpha256.
  104. */
  105. static inline U16CPU SkAlphaMulInv256(U16CPU value, U16CPU alpha256) {
  106. unsigned prod = 0xFFFF - value * alpha256;
  107. return (prod + (prod >> 8)) >> 8;
  108. }
  109. // The caller may want negative values, so keep all params signed (int)
  110. // so we don't accidentally slip into unsigned math and lose the sign
  111. // extension when we shift (in SkAlphaMul)
  112. static inline int SkAlphaBlend(int src, int dst, int scale256) {
  113. SkASSERT((unsigned)scale256 <= 256);
  114. return dst + SkAlphaMul(src - dst, scale256);
  115. }
  116. static inline uint16_t SkPackRGB16(unsigned r, unsigned g, unsigned b) {
  117. SkASSERT(r <= SK_R16_MASK);
  118. SkASSERT(g <= SK_G16_MASK);
  119. SkASSERT(b <= SK_B16_MASK);
  120. return SkToU16((r << SK_R16_SHIFT) | (g << SK_G16_SHIFT) | (b << SK_B16_SHIFT));
  121. }
  122. #define SK_R16_MASK_IN_PLACE (SK_R16_MASK << SK_R16_SHIFT)
  123. #define SK_G16_MASK_IN_PLACE (SK_G16_MASK << SK_G16_SHIFT)
  124. #define SK_B16_MASK_IN_PLACE (SK_B16_MASK << SK_B16_SHIFT)
  125. ///////////////////////////////////////////////////////////////////////////////
  126. /**
  127. * Abstract 4-byte interpolation, implemented on top of SkPMColor
  128. * utility functions. Third parameter controls blending of the first two:
  129. * (src, dst, 0) returns dst
  130. * (src, dst, 0xFF) returns src
  131. * srcWeight is [0..256], unlike SkFourByteInterp which takes [0..255]
  132. */
  133. static inline SkPMColor SkFourByteInterp256(SkPMColor src, SkPMColor dst,
  134. unsigned scale) {
  135. unsigned a = SkAlphaBlend(SkGetPackedA32(src), SkGetPackedA32(dst), scale);
  136. unsigned r = SkAlphaBlend(SkGetPackedR32(src), SkGetPackedR32(dst), scale);
  137. unsigned g = SkAlphaBlend(SkGetPackedG32(src), SkGetPackedG32(dst), scale);
  138. unsigned b = SkAlphaBlend(SkGetPackedB32(src), SkGetPackedB32(dst), scale);
  139. return SkPackARGB32(a, r, g, b);
  140. }
  141. /**
  142. * Abstract 4-byte interpolation, implemented on top of SkPMColor
  143. * utility functions. Third parameter controls blending of the first two:
  144. * (src, dst, 0) returns dst
  145. * (src, dst, 0xFF) returns src
  146. */
  147. static inline SkPMColor SkFourByteInterp(SkPMColor src, SkPMColor dst,
  148. U8CPU srcWeight) {
  149. unsigned scale = SkAlpha255To256(srcWeight);
  150. return SkFourByteInterp256(src, dst, scale);
  151. }
  152. /**
  153. * 0xAARRGGBB -> 0x00AA00GG, 0x00RR00BB
  154. */
  155. static inline void SkSplay(uint32_t color, uint32_t* ag, uint32_t* rb) {
  156. const uint32_t mask = 0x00FF00FF;
  157. *ag = (color >> 8) & mask;
  158. *rb = color & mask;
  159. }
  160. /**
  161. * 0xAARRGGBB -> 0x00AA00GG00RR00BB
  162. * (note, ARGB -> AGRB)
  163. */
  164. static inline uint64_t SkSplay(uint32_t color) {
  165. const uint32_t mask = 0x00FF00FF;
  166. uint64_t agrb = (color >> 8) & mask; // 0x0000000000AA00GG
  167. agrb <<= 32; // 0x00AA00GG00000000
  168. agrb |= color & mask; // 0x00AA00GG00RR00BB
  169. return agrb;
  170. }
  171. /**
  172. * 0xAAxxGGxx, 0xRRxxBBxx-> 0xAARRGGBB
  173. */
  174. static inline uint32_t SkUnsplay(uint32_t ag, uint32_t rb) {
  175. const uint32_t mask = 0xFF00FF00;
  176. return (ag & mask) | ((rb & mask) >> 8);
  177. }
  178. /**
  179. * 0xAAxxGGxxRRxxBBxx -> 0xAARRGGBB
  180. * (note, AGRB -> ARGB)
  181. */
  182. static inline uint32_t SkUnsplay(uint64_t agrb) {
  183. const uint32_t mask = 0xFF00FF00;
  184. return SkPMColor(
  185. ((agrb & mask) >> 8) | // 0x00RR00BB
  186. ((agrb >> 32) & mask)); // 0xAARRGGBB
  187. }
  188. static inline SkPMColor SkFastFourByteInterp256_32(SkPMColor src, SkPMColor dst, unsigned scale) {
  189. SkASSERT(scale <= 256);
  190. // Two 8-bit blends per two 32-bit registers, with space to make sure the math doesn't collide.
  191. uint32_t src_ag, src_rb, dst_ag, dst_rb;
  192. SkSplay(src, &src_ag, &src_rb);
  193. SkSplay(dst, &dst_ag, &dst_rb);
  194. const uint32_t ret_ag = src_ag * scale + (256 - scale) * dst_ag;
  195. const uint32_t ret_rb = src_rb * scale + (256 - scale) * dst_rb;
  196. return SkUnsplay(ret_ag, ret_rb);
  197. }
  198. static inline SkPMColor SkFastFourByteInterp256_64(SkPMColor src, SkPMColor dst, unsigned scale) {
  199. SkASSERT(scale <= 256);
  200. // Four 8-bit blends in one 64-bit register, with space to make sure the math doesn't collide.
  201. return SkUnsplay(SkSplay(src) * scale + (256-scale) * SkSplay(dst));
  202. }
  203. // TODO(mtklein): Replace slow versions with fast versions, using scale + (scale>>7) everywhere.
  204. /**
  205. * Same as SkFourByteInterp256, but faster.
  206. */
  207. static inline SkPMColor SkFastFourByteInterp256(SkPMColor src, SkPMColor dst, unsigned scale) {
  208. // On a 64-bit machine, _64 is about 10% faster than _32, but ~40% slower on a 32-bit machine.
  209. if (sizeof(void*) == 4) {
  210. return SkFastFourByteInterp256_32(src, dst, scale);
  211. } else {
  212. return SkFastFourByteInterp256_64(src, dst, scale);
  213. }
  214. }
  215. /**
  216. * Nearly the same as SkFourByteInterp, but faster and a touch more accurate, due to better
  217. * srcWeight scaling to [0, 256].
  218. */
  219. static inline SkPMColor SkFastFourByteInterp(SkPMColor src,
  220. SkPMColor dst,
  221. U8CPU srcWeight) {
  222. SkASSERT(srcWeight <= 255);
  223. // scale = srcWeight + (srcWeight >> 7) is more accurate than
  224. // scale = srcWeight + 1, but 7% slower
  225. return SkFastFourByteInterp256(src, dst, srcWeight + (srcWeight >> 7));
  226. }
  227. /**
  228. * Interpolates between colors src and dst using [0,256] scale.
  229. */
  230. static inline SkPMColor SkPMLerp(SkPMColor src, SkPMColor dst, unsigned scale) {
  231. return SkFastFourByteInterp256(src, dst, scale);
  232. }
  233. static inline SkPMColor SkBlendARGB32(SkPMColor src, SkPMColor dst, U8CPU aa) {
  234. SkASSERT((unsigned)aa <= 255);
  235. unsigned src_scale = SkAlpha255To256(aa);
  236. unsigned dst_scale = SkAlphaMulInv256(SkGetPackedA32(src), src_scale);
  237. const uint32_t mask = 0xFF00FF;
  238. uint32_t src_rb = (src & mask) * src_scale;
  239. uint32_t src_ag = ((src >> 8) & mask) * src_scale;
  240. uint32_t dst_rb = (dst & mask) * dst_scale;
  241. uint32_t dst_ag = ((dst >> 8) & mask) * dst_scale;
  242. return (((src_rb + dst_rb) >> 8) & mask) | ((src_ag + dst_ag) & ~mask);
  243. }
  244. ////////////////////////////////////////////////////////////////////////////////////////////
  245. // Convert a 32bit pixel to a 16bit pixel (no dither)
  246. #define SkR32ToR16_MACRO(r) ((unsigned)(r) >> (SK_R32_BITS - SK_R16_BITS))
  247. #define SkG32ToG16_MACRO(g) ((unsigned)(g) >> (SK_G32_BITS - SK_G16_BITS))
  248. #define SkB32ToB16_MACRO(b) ((unsigned)(b) >> (SK_B32_BITS - SK_B16_BITS))
  249. #ifdef SK_DEBUG
  250. static inline unsigned SkR32ToR16(unsigned r) {
  251. SkR32Assert(r);
  252. return SkR32ToR16_MACRO(r);
  253. }
  254. static inline unsigned SkG32ToG16(unsigned g) {
  255. SkG32Assert(g);
  256. return SkG32ToG16_MACRO(g);
  257. }
  258. static inline unsigned SkB32ToB16(unsigned b) {
  259. SkB32Assert(b);
  260. return SkB32ToB16_MACRO(b);
  261. }
  262. #else
  263. #define SkR32ToR16(r) SkR32ToR16_MACRO(r)
  264. #define SkG32ToG16(g) SkG32ToG16_MACRO(g)
  265. #define SkB32ToB16(b) SkB32ToB16_MACRO(b)
  266. #endif
  267. static inline U16CPU SkPixel32ToPixel16(SkPMColor c) {
  268. unsigned r = ((c >> (SK_R32_SHIFT + (8 - SK_R16_BITS))) & SK_R16_MASK) << SK_R16_SHIFT;
  269. unsigned g = ((c >> (SK_G32_SHIFT + (8 - SK_G16_BITS))) & SK_G16_MASK) << SK_G16_SHIFT;
  270. unsigned b = ((c >> (SK_B32_SHIFT + (8 - SK_B16_BITS))) & SK_B16_MASK) << SK_B16_SHIFT;
  271. return r | g | b;
  272. }
  273. static inline U16CPU SkPack888ToRGB16(U8CPU r, U8CPU g, U8CPU b) {
  274. return (SkR32ToR16(r) << SK_R16_SHIFT) |
  275. (SkG32ToG16(g) << SK_G16_SHIFT) |
  276. (SkB32ToB16(b) << SK_B16_SHIFT);
  277. }
  278. /////////////////////////////////////////////////////////////////////////////////////////
  279. /* SrcOver the 32bit src color with the 16bit dst, returning a 16bit value
  280. (with dirt in the high 16bits, so caller beware).
  281. */
  282. static inline U16CPU SkSrcOver32To16(SkPMColor src, uint16_t dst) {
  283. unsigned sr = SkGetPackedR32(src);
  284. unsigned sg = SkGetPackedG32(src);
  285. unsigned sb = SkGetPackedB32(src);
  286. unsigned dr = SkGetPackedR16(dst);
  287. unsigned dg = SkGetPackedG16(dst);
  288. unsigned db = SkGetPackedB16(dst);
  289. unsigned isa = 255 - SkGetPackedA32(src);
  290. dr = (sr + SkMul16ShiftRound(dr, isa, SK_R16_BITS)) >> (8 - SK_R16_BITS);
  291. dg = (sg + SkMul16ShiftRound(dg, isa, SK_G16_BITS)) >> (8 - SK_G16_BITS);
  292. db = (sb + SkMul16ShiftRound(db, isa, SK_B16_BITS)) >> (8 - SK_B16_BITS);
  293. return SkPackRGB16(dr, dg, db);
  294. }
  295. static inline SkColor SkPixel16ToColor(U16CPU src) {
  296. SkASSERT(src == SkToU16(src));
  297. unsigned r = SkPacked16ToR32(src);
  298. unsigned g = SkPacked16ToG32(src);
  299. unsigned b = SkPacked16ToB32(src);
  300. SkASSERT((r >> (8 - SK_R16_BITS)) == SkGetPackedR16(src));
  301. SkASSERT((g >> (8 - SK_G16_BITS)) == SkGetPackedG16(src));
  302. SkASSERT((b >> (8 - SK_B16_BITS)) == SkGetPackedB16(src));
  303. return SkColorSetRGB(r, g, b);
  304. }
  305. ///////////////////////////////////////////////////////////////////////////////
  306. typedef uint16_t SkPMColor16;
  307. // Put in OpenGL order (r g b a)
  308. #define SK_A4444_SHIFT 0
  309. #define SK_R4444_SHIFT 12
  310. #define SK_G4444_SHIFT 8
  311. #define SK_B4444_SHIFT 4
  312. static inline U8CPU SkReplicateNibble(unsigned nib) {
  313. SkASSERT(nib <= 0xF);
  314. return (nib << 4) | nib;
  315. }
  316. #define SkGetPackedA4444(c) (((unsigned)(c) >> SK_A4444_SHIFT) & 0xF)
  317. #define SkGetPackedR4444(c) (((unsigned)(c) >> SK_R4444_SHIFT) & 0xF)
  318. #define SkGetPackedG4444(c) (((unsigned)(c) >> SK_G4444_SHIFT) & 0xF)
  319. #define SkGetPackedB4444(c) (((unsigned)(c) >> SK_B4444_SHIFT) & 0xF)
  320. #define SkPacked4444ToA32(c) SkReplicateNibble(SkGetPackedA4444(c))
  321. static inline SkPMColor SkPixel4444ToPixel32(U16CPU c) {
  322. uint32_t d = (SkGetPackedA4444(c) << SK_A32_SHIFT) |
  323. (SkGetPackedR4444(c) << SK_R32_SHIFT) |
  324. (SkGetPackedG4444(c) << SK_G32_SHIFT) |
  325. (SkGetPackedB4444(c) << SK_B32_SHIFT);
  326. return d | (d << 4);
  327. }
  328. static inline Sk4f swizzle_rb(const Sk4f& x) {
  329. return SkNx_shuffle<2, 1, 0, 3>(x);
  330. }
  331. static inline Sk4f swizzle_rb_if_bgra(const Sk4f& x) {
  332. #ifdef SK_PMCOLOR_IS_BGRA
  333. return swizzle_rb(x);
  334. #else
  335. return x;
  336. #endif
  337. }
  338. static inline Sk4f Sk4f_fromL32(uint32_t px) {
  339. return SkNx_cast<float>(Sk4b::Load(&px)) * (1 / 255.0f);
  340. }
  341. static inline uint32_t Sk4f_toL32(const Sk4f& px) {
  342. Sk4f v = px;
  343. #if !defined(SKNX_NO_SIMD) && SK_CPU_SSE_LEVEL >= SK_CPU_SSE_LEVEL_SSE2
  344. // SkNx_cast<uint8_t, int32_t>() pins, and we don't anticipate giant floats
  345. #elif !defined(SKNX_NO_SIMD) && defined(SK_ARM_HAS_NEON)
  346. // SkNx_cast<uint8_t, int32_t>() pins, and so does Sk4f_round().
  347. #else
  348. // No guarantee of a pin.
  349. v = Sk4f::Max(0, Sk4f::Min(v, 1));
  350. #endif
  351. uint32_t l32;
  352. SkNx_cast<uint8_t>(Sk4f_round(v * 255.0f)).store(&l32);
  353. return l32;
  354. }
  355. using SkPMColor4f = SkRGBA4f<kPremul_SkAlphaType>;
  356. constexpr SkPMColor4f SK_PMColor4fTRANSPARENT = { 0, 0, 0, 0 };
  357. constexpr SkPMColor4f SK_PMColor4fWHITE = { 1, 1, 1, 1 };
  358. constexpr SkPMColor4f SK_PMColor4fILLEGAL = { SK_FloatNegativeInfinity,
  359. SK_FloatNegativeInfinity,
  360. SK_FloatNegativeInfinity,
  361. SK_FloatNegativeInfinity };
  362. #endif