SkColor.cpp 4.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149
  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. #include "include/core/SkColor.h"
  8. #include "include/private/SkColorData.h"
  9. #include "include/private/SkFixed.h"
  10. SkPMColor SkPreMultiplyARGB(U8CPU a, U8CPU r, U8CPU g, U8CPU b) {
  11. return SkPremultiplyARGBInline(a, r, g, b);
  12. }
  13. SkPMColor SkPreMultiplyColor(SkColor c) {
  14. return SkPremultiplyARGBInline(SkColorGetA(c), SkColorGetR(c),
  15. SkColorGetG(c), SkColorGetB(c));
  16. }
  17. ///////////////////////////////////////////////////////////////////////////////
  18. static inline SkScalar ByteToScalar(U8CPU x) {
  19. SkASSERT(x <= 255);
  20. return SkIntToScalar(x) / 255;
  21. }
  22. static inline SkScalar ByteDivToScalar(int numer, U8CPU denom) {
  23. // cast to keep the answer signed
  24. return SkIntToScalar(numer) / (int)denom;
  25. }
  26. void SkRGBToHSV(U8CPU r, U8CPU g, U8CPU b, SkScalar hsv[3]) {
  27. SkASSERT(hsv);
  28. unsigned min = SkMin32(r, SkMin32(g, b));
  29. unsigned max = SkMax32(r, SkMax32(g, b));
  30. unsigned delta = max - min;
  31. SkScalar v = ByteToScalar(max);
  32. SkASSERT(v >= 0 && v <= SK_Scalar1);
  33. if (0 == delta) { // we're a shade of gray
  34. hsv[0] = 0;
  35. hsv[1] = 0;
  36. hsv[2] = v;
  37. return;
  38. }
  39. SkScalar s = ByteDivToScalar(delta, max);
  40. SkASSERT(s >= 0 && s <= SK_Scalar1);
  41. SkScalar h;
  42. if (r == max) {
  43. h = ByteDivToScalar(g - b, delta);
  44. } else if (g == max) {
  45. h = SkIntToScalar(2) + ByteDivToScalar(b - r, delta);
  46. } else { // b == max
  47. h = SkIntToScalar(4) + ByteDivToScalar(r - g, delta);
  48. }
  49. h *= 60;
  50. if (h < 0) {
  51. h += SkIntToScalar(360);
  52. }
  53. SkASSERT(h >= 0 && h < SkIntToScalar(360));
  54. hsv[0] = h;
  55. hsv[1] = s;
  56. hsv[2] = v;
  57. }
  58. SkColor SkHSVToColor(U8CPU a, const SkScalar hsv[3]) {
  59. SkASSERT(hsv);
  60. SkScalar s = SkScalarPin(hsv[1], 0, 1);
  61. SkScalar v = SkScalarPin(hsv[2], 0, 1);
  62. U8CPU v_byte = SkScalarRoundToInt(v * 255);
  63. if (SkScalarNearlyZero(s)) { // shade of gray
  64. return SkColorSetARGB(a, v_byte, v_byte, v_byte);
  65. }
  66. SkScalar hx = (hsv[0] < 0 || hsv[0] >= SkIntToScalar(360)) ? 0 : hsv[0]/60;
  67. SkScalar w = SkScalarFloorToScalar(hx);
  68. SkScalar f = hx - w;
  69. unsigned p = SkScalarRoundToInt((SK_Scalar1 - s) * v * 255);
  70. unsigned q = SkScalarRoundToInt((SK_Scalar1 - (s * f)) * v * 255);
  71. unsigned t = SkScalarRoundToInt((SK_Scalar1 - (s * (SK_Scalar1 - f))) * v * 255);
  72. unsigned r, g, b;
  73. SkASSERT((unsigned)(w) < 6);
  74. switch ((unsigned)(w)) {
  75. case 0: r = v_byte; g = t; b = p; break;
  76. case 1: r = q; g = v_byte; b = p; break;
  77. case 2: r = p; g = v_byte; b = t; break;
  78. case 3: r = p; g = q; b = v_byte; break;
  79. case 4: r = t; g = p; b = v_byte; break;
  80. default: r = v_byte; g = p; b = q; break;
  81. }
  82. return SkColorSetARGB(a, r, g, b);
  83. }
  84. ///////////////////////////////////////////////////////////////////////////////////////////////////
  85. template <>
  86. SkColor4f SkColor4f::FromColor(SkColor bgra) {
  87. SkColor4f rgba;
  88. swizzle_rb(Sk4f_fromL32(bgra)).store(rgba.vec());
  89. return rgba;
  90. }
  91. template <>
  92. SkColor SkColor4f::toSkColor() const {
  93. return Sk4f_toL32(swizzle_rb(Sk4f::Load(this->vec())));
  94. }
  95. template <>
  96. uint32_t SkColor4f::toBytes_RGBA() const {
  97. return Sk4f_toL32(Sk4f::Load(this->vec()));
  98. }
  99. template <>
  100. SkColor4f SkColor4f::FromBytes_RGBA(uint32_t c) {
  101. SkColor4f color;
  102. Sk4f_fromL32(c).store(&color);
  103. return color;
  104. }
  105. template <>
  106. SkPMColor4f SkPMColor4f::FromPMColor(SkPMColor c) {
  107. SkPMColor4f color;
  108. swizzle_rb_if_bgra(Sk4f_fromL32(c)).store(&color);
  109. return color;
  110. }
  111. template <>
  112. uint32_t SkPMColor4f::toBytes_RGBA() const {
  113. return Sk4f_toL32(Sk4f::Load(this->vec()));
  114. }
  115. template <>
  116. SkPMColor4f SkPMColor4f::FromBytes_RGBA(uint32_t c) {
  117. SkPMColor4f color;
  118. Sk4f_fromL32(c).store(&color);
  119. return color;
  120. }