SkBlitMask_opts.h 8.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231
  1. /*
  2. * Copyright 2015 Google Inc.
  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 SkBlitMask_opts_DEFINED
  8. #define SkBlitMask_opts_DEFINED
  9. #include "src/core/Sk4px.h"
  10. namespace SK_OPTS_NS {
  11. #if defined(SK_ARM_HAS_NEON)
  12. // The Sk4px versions below will work fine with NEON, but we have had many indications
  13. // that it doesn't perform as well as this NEON-specific code. TODO(mtklein): why?
  14. #define NEON_A (SK_A32_SHIFT / 8)
  15. #define NEON_R (SK_R32_SHIFT / 8)
  16. #define NEON_G (SK_G32_SHIFT / 8)
  17. #define NEON_B (SK_B32_SHIFT / 8)
  18. static inline uint16x8_t SkAlpha255To256_neon8(uint8x8_t alpha) {
  19. return vaddw_u8(vdupq_n_u16(1), alpha);
  20. }
  21. static inline uint8x8_t SkAlphaMul_neon8(uint8x8_t color, uint16x8_t scale) {
  22. return vshrn_n_u16(vmovl_u8(color) * scale, 8);
  23. }
  24. static inline uint8x8x4_t SkAlphaMulQ_neon8(uint8x8x4_t color, uint16x8_t scale) {
  25. uint8x8x4_t ret;
  26. ret.val[0] = SkAlphaMul_neon8(color.val[0], scale);
  27. ret.val[1] = SkAlphaMul_neon8(color.val[1], scale);
  28. ret.val[2] = SkAlphaMul_neon8(color.val[2], scale);
  29. ret.val[3] = SkAlphaMul_neon8(color.val[3], scale);
  30. return ret;
  31. }
  32. template <bool isColor>
  33. static void D32_A8_Opaque_Color_neon(void* SK_RESTRICT dst, size_t dstRB,
  34. const void* SK_RESTRICT maskPtr, size_t maskRB,
  35. SkColor color, int width, int height) {
  36. SkPMColor pmc = SkPreMultiplyColor(color);
  37. SkPMColor* SK_RESTRICT device = (SkPMColor*)dst;
  38. const uint8_t* SK_RESTRICT mask = (const uint8_t*)maskPtr;
  39. uint8x8x4_t vpmc;
  40. maskRB -= width;
  41. dstRB -= (width << 2);
  42. if (width >= 8) {
  43. vpmc.val[NEON_A] = vdup_n_u8(SkGetPackedA32(pmc));
  44. vpmc.val[NEON_R] = vdup_n_u8(SkGetPackedR32(pmc));
  45. vpmc.val[NEON_G] = vdup_n_u8(SkGetPackedG32(pmc));
  46. vpmc.val[NEON_B] = vdup_n_u8(SkGetPackedB32(pmc));
  47. }
  48. do {
  49. int w = width;
  50. while (w >= 8) {
  51. uint8x8_t vmask = vld1_u8(mask);
  52. uint16x8_t vscale, vmask256 = SkAlpha255To256_neon8(vmask);
  53. if (isColor) {
  54. vscale = vsubw_u8(vdupq_n_u16(256),
  55. SkAlphaMul_neon8(vpmc.val[NEON_A], vmask256));
  56. } else {
  57. vscale = vsubw_u8(vdupq_n_u16(256), vmask);
  58. }
  59. uint8x8x4_t vdev = vld4_u8((uint8_t*)device);
  60. vdev.val[NEON_A] = SkAlphaMul_neon8(vpmc.val[NEON_A], vmask256)
  61. + SkAlphaMul_neon8(vdev.val[NEON_A], vscale);
  62. vdev.val[NEON_R] = SkAlphaMul_neon8(vpmc.val[NEON_R], vmask256)
  63. + SkAlphaMul_neon8(vdev.val[NEON_R], vscale);
  64. vdev.val[NEON_G] = SkAlphaMul_neon8(vpmc.val[NEON_G], vmask256)
  65. + SkAlphaMul_neon8(vdev.val[NEON_G], vscale);
  66. vdev.val[NEON_B] = SkAlphaMul_neon8(vpmc.val[NEON_B], vmask256)
  67. + SkAlphaMul_neon8(vdev.val[NEON_B], vscale);
  68. vst4_u8((uint8_t*)device, vdev);
  69. mask += 8;
  70. device += 8;
  71. w -= 8;
  72. }
  73. while (w--) {
  74. unsigned aa = *mask++;
  75. if (isColor) {
  76. *device = SkBlendARGB32(pmc, *device, aa);
  77. } else {
  78. *device = SkAlphaMulQ(pmc, SkAlpha255To256(aa))
  79. + SkAlphaMulQ(*device, SkAlpha255To256(255 - aa));
  80. }
  81. device += 1;
  82. }
  83. device = (uint32_t*)((char*)device + dstRB);
  84. mask += maskRB;
  85. } while (--height != 0);
  86. }
  87. static void blit_mask_d32_a8_general(SkPMColor* dst, size_t dstRB,
  88. const SkAlpha* mask, size_t maskRB,
  89. SkColor color, int w, int h) {
  90. D32_A8_Opaque_Color_neon<true>(dst, dstRB, mask, maskRB, color, w, h);
  91. }
  92. // As above, but made slightly simpler by requiring that color is opaque.
  93. static void blit_mask_d32_a8_opaque(SkPMColor* dst, size_t dstRB,
  94. const SkAlpha* mask, size_t maskRB,
  95. SkColor color, int w, int h) {
  96. D32_A8_Opaque_Color_neon<false>(dst, dstRB, mask, maskRB, color, w, h);
  97. }
  98. // Same as _opaque, but assumes color == SK_ColorBLACK, a very common and even simpler case.
  99. static void blit_mask_d32_a8_black(SkPMColor* dst, size_t dstRB,
  100. const SkAlpha* maskPtr, size_t maskRB,
  101. int width, int height) {
  102. SkPMColor* SK_RESTRICT device = (SkPMColor*)dst;
  103. const uint8_t* SK_RESTRICT mask = (const uint8_t*)maskPtr;
  104. maskRB -= width;
  105. dstRB -= (width << 2);
  106. do {
  107. int w = width;
  108. while (w >= 8) {
  109. uint8x8_t vmask = vld1_u8(mask);
  110. uint16x8_t vscale = vsubw_u8(vdupq_n_u16(256), vmask);
  111. uint8x8x4_t vdevice = vld4_u8((uint8_t*)device);
  112. vdevice = SkAlphaMulQ_neon8(vdevice, vscale);
  113. vdevice.val[NEON_A] += vmask;
  114. vst4_u8((uint8_t*)device, vdevice);
  115. mask += 8;
  116. device += 8;
  117. w -= 8;
  118. }
  119. while (w-- > 0) {
  120. unsigned aa = *mask++;
  121. *device = (aa << SK_A32_SHIFT)
  122. + SkAlphaMulQ(*device, SkAlpha255To256(255 - aa));
  123. device += 1;
  124. }
  125. device = (uint32_t*)((char*)device + dstRB);
  126. mask += maskRB;
  127. } while (--height != 0);
  128. }
  129. #else
  130. static void blit_mask_d32_a8_general(SkPMColor* dst, size_t dstRB,
  131. const SkAlpha* mask, size_t maskRB,
  132. SkColor color, int w, int h) {
  133. auto s = Sk4px::DupPMColor(SkPreMultiplyColor(color));
  134. auto fn = [&](const Sk4px& d, const Sk4px& aa) {
  135. // = (s + d(1-sa))aa + d(1-aa)
  136. // = s*aa + d(1-sa*aa)
  137. auto left = s.approxMulDiv255(aa),
  138. right = d.approxMulDiv255(left.alphas().inv());
  139. return left + right; // This does not overflow (exhaustively checked).
  140. };
  141. while (h --> 0) {
  142. Sk4px::MapDstAlpha(w, dst, mask, fn);
  143. dst += dstRB / sizeof(*dst);
  144. mask += maskRB / sizeof(*mask);
  145. }
  146. }
  147. // As above, but made slightly simpler by requiring that color is opaque.
  148. static void blit_mask_d32_a8_opaque(SkPMColor* dst, size_t dstRB,
  149. const SkAlpha* mask, size_t maskRB,
  150. SkColor color, int w, int h) {
  151. SkASSERT(SkColorGetA(color) == 0xFF);
  152. auto s = Sk4px::DupPMColor(SkPreMultiplyColor(color));
  153. auto fn = [&](const Sk4px& d, const Sk4px& aa) {
  154. // = (s + d(1-sa))aa + d(1-aa)
  155. // = s*aa + d(1-sa*aa)
  156. // ~~~>
  157. // = s*aa + d(1-aa)
  158. return s.approxMulDiv255(aa) + d.approxMulDiv255(aa.inv());
  159. };
  160. while (h --> 0) {
  161. Sk4px::MapDstAlpha(w, dst, mask, fn);
  162. dst += dstRB / sizeof(*dst);
  163. mask += maskRB / sizeof(*mask);
  164. }
  165. }
  166. // Same as _opaque, but assumes color == SK_ColorBLACK, a very common and even simpler case.
  167. static void blit_mask_d32_a8_black(SkPMColor* dst, size_t dstRB,
  168. const SkAlpha* mask, size_t maskRB,
  169. int w, int h) {
  170. auto fn = [](const Sk4px& d, const Sk4px& aa) {
  171. // = (s + d(1-sa))aa + d(1-aa)
  172. // = s*aa + d(1-sa*aa)
  173. // ~~~>
  174. // a = 1*aa + d(1-1*aa) = aa + d(1-aa)
  175. // c = 0*aa + d(1-1*aa) = d(1-aa)
  176. return Sk4px(Sk16b(aa) & Sk16b(0,0,0,255, 0,0,0,255, 0,0,0,255, 0,0,0,255))
  177. + d.approxMulDiv255(aa.inv());
  178. };
  179. while (h --> 0) {
  180. Sk4px::MapDstAlpha(w, dst, mask, fn);
  181. dst += dstRB / sizeof(*dst);
  182. mask += maskRB / sizeof(*mask);
  183. }
  184. }
  185. #endif
  186. /*not static*/ inline void blit_mask_d32_a8(SkPMColor* dst, size_t dstRB,
  187. const SkAlpha* mask, size_t maskRB,
  188. SkColor color, int w, int h) {
  189. if (color == SK_ColorBLACK) {
  190. blit_mask_d32_a8_black(dst, dstRB, mask, maskRB, w, h);
  191. } else if (SkColorGetA(color) == 0xFF) {
  192. blit_mask_d32_a8_opaque(dst, dstRB, mask, maskRB, color, w, h);
  193. } else {
  194. blit_mask_d32_a8_general(dst, dstRB, mask, maskRB, color, w, h);
  195. }
  196. }
  197. } // SK_OPTS_NS
  198. #endif//SkBlitMask_opts_DEFINED