SkBlitter_ARGB32.cpp 53 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441
  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/SkShader.h"
  8. #include "include/private/SkColorData.h"
  9. #include "include/private/SkVx.h"
  10. #include "src/core/SkCoreBlitters.h"
  11. #include "src/core/SkUtils.h"
  12. #include "src/core/SkXfermodePriv.h"
  13. static inline int upscale_31_to_32(int value) {
  14. SkASSERT((unsigned)value <= 31);
  15. return value + (value >> 4);
  16. }
  17. static inline int blend_32(int src, int dst, int scale) {
  18. SkASSERT((unsigned)src <= 0xFF);
  19. SkASSERT((unsigned)dst <= 0xFF);
  20. SkASSERT((unsigned)scale <= 32);
  21. return dst + ((src - dst) * scale >> 5);
  22. }
  23. static inline SkPMColor blend_lcd16(int srcA, int srcR, int srcG, int srcB,
  24. SkPMColor dst, uint16_t mask) {
  25. if (mask == 0) {
  26. return dst;
  27. }
  28. /* We want all of these in 5bits, hence the shifts in case one of them
  29. * (green) is 6bits.
  30. */
  31. int maskR = SkGetPackedR16(mask) >> (SK_R16_BITS - 5);
  32. int maskG = SkGetPackedG16(mask) >> (SK_G16_BITS - 5);
  33. int maskB = SkGetPackedB16(mask) >> (SK_B16_BITS - 5);
  34. // Now upscale them to 0..32, so we can use blend32
  35. maskR = upscale_31_to_32(maskR);
  36. maskG = upscale_31_to_32(maskG);
  37. maskB = upscale_31_to_32(maskB);
  38. // srcA has been upscaled to 256 before passed into this function
  39. maskR = maskR * srcA >> 8;
  40. maskG = maskG * srcA >> 8;
  41. maskB = maskB * srcA >> 8;
  42. int dstR = SkGetPackedR32(dst);
  43. int dstG = SkGetPackedG32(dst);
  44. int dstB = SkGetPackedB32(dst);
  45. // LCD blitting is only supported if the dst is known/required
  46. // to be opaque
  47. return SkPackARGB32(0xFF,
  48. blend_32(srcR, dstR, maskR),
  49. blend_32(srcG, dstG, maskG),
  50. blend_32(srcB, dstB, maskB));
  51. }
  52. static inline SkPMColor blend_lcd16_opaque(int srcR, int srcG, int srcB,
  53. SkPMColor dst, uint16_t mask,
  54. SkPMColor opaqueDst) {
  55. if (mask == 0) {
  56. return dst;
  57. }
  58. if (0xFFFF == mask) {
  59. return opaqueDst;
  60. }
  61. /* We want all of these in 5bits, hence the shifts in case one of them
  62. * (green) is 6bits.
  63. */
  64. int maskR = SkGetPackedR16(mask) >> (SK_R16_BITS - 5);
  65. int maskG = SkGetPackedG16(mask) >> (SK_G16_BITS - 5);
  66. int maskB = SkGetPackedB16(mask) >> (SK_B16_BITS - 5);
  67. // Now upscale them to 0..32, so we can use blend32
  68. maskR = upscale_31_to_32(maskR);
  69. maskG = upscale_31_to_32(maskG);
  70. maskB = upscale_31_to_32(maskB);
  71. int dstR = SkGetPackedR32(dst);
  72. int dstG = SkGetPackedG32(dst);
  73. int dstB = SkGetPackedB32(dst);
  74. // LCD blitting is only supported if the dst is known/required
  75. // to be opaque
  76. return SkPackARGB32(0xFF,
  77. blend_32(srcR, dstR, maskR),
  78. blend_32(srcG, dstG, maskG),
  79. blend_32(srcB, dstB, maskB));
  80. }
  81. // TODO: rewrite at least the SSE code here. It's miserable.
  82. #if SK_CPU_SSE_LEVEL >= SK_CPU_SSE_LEVEL_SSE2
  83. #include <emmintrin.h>
  84. // The following (left) shifts cause the top 5 bits of the mask components to
  85. // line up with the corresponding components in an SkPMColor.
  86. // Note that the mask's RGB16 order may differ from the SkPMColor order.
  87. #define SK_R16x5_R32x5_SHIFT (SK_R32_SHIFT - SK_R16_SHIFT - SK_R16_BITS + 5)
  88. #define SK_G16x5_G32x5_SHIFT (SK_G32_SHIFT - SK_G16_SHIFT - SK_G16_BITS + 5)
  89. #define SK_B16x5_B32x5_SHIFT (SK_B32_SHIFT - SK_B16_SHIFT - SK_B16_BITS + 5)
  90. #if SK_R16x5_R32x5_SHIFT == 0
  91. #define SkPackedR16x5ToUnmaskedR32x5_SSE2(x) (x)
  92. #elif SK_R16x5_R32x5_SHIFT > 0
  93. #define SkPackedR16x5ToUnmaskedR32x5_SSE2(x) (_mm_slli_epi32(x, SK_R16x5_R32x5_SHIFT))
  94. #else
  95. #define SkPackedR16x5ToUnmaskedR32x5_SSE2(x) (_mm_srli_epi32(x, -SK_R16x5_R32x5_SHIFT))
  96. #endif
  97. #if SK_G16x5_G32x5_SHIFT == 0
  98. #define SkPackedG16x5ToUnmaskedG32x5_SSE2(x) (x)
  99. #elif SK_G16x5_G32x5_SHIFT > 0
  100. #define SkPackedG16x5ToUnmaskedG32x5_SSE2(x) (_mm_slli_epi32(x, SK_G16x5_G32x5_SHIFT))
  101. #else
  102. #define SkPackedG16x5ToUnmaskedG32x5_SSE2(x) (_mm_srli_epi32(x, -SK_G16x5_G32x5_SHIFT))
  103. #endif
  104. #if SK_B16x5_B32x5_SHIFT == 0
  105. #define SkPackedB16x5ToUnmaskedB32x5_SSE2(x) (x)
  106. #elif SK_B16x5_B32x5_SHIFT > 0
  107. #define SkPackedB16x5ToUnmaskedB32x5_SSE2(x) (_mm_slli_epi32(x, SK_B16x5_B32x5_SHIFT))
  108. #else
  109. #define SkPackedB16x5ToUnmaskedB32x5_SSE2(x) (_mm_srli_epi32(x, -SK_B16x5_B32x5_SHIFT))
  110. #endif
  111. static __m128i blend_lcd16_sse2(__m128i &src, __m128i &dst, __m128i &mask, __m128i &srcA) {
  112. // In the following comments, the components of src, dst and mask are
  113. // abbreviated as (s)rc, (d)st, and (m)ask. Color components are marked
  114. // by an R, G, B, or A suffix. Components of one of the four pixels that
  115. // are processed in parallel are marked with 0, 1, 2, and 3. "d1B", for
  116. // example is the blue channel of the second destination pixel. Memory
  117. // layout is shown for an ARGB byte order in a color value.
  118. // src and srcA store 8-bit values interleaved with zeros.
  119. // src = (0xFF, 0, sR, 0, sG, 0, sB, 0, 0xFF, 0, sR, 0, sG, 0, sB, 0)
  120. // srcA = (srcA, 0, srcA, 0, srcA, 0, srcA, 0,
  121. // srcA, 0, srcA, 0, srcA, 0, srcA, 0)
  122. // mask stores 16-bit values (compressed three channels) interleaved with zeros.
  123. // Lo and Hi denote the low and high bytes of a 16-bit value, respectively.
  124. // mask = (m0RGBLo, m0RGBHi, 0, 0, m1RGBLo, m1RGBHi, 0, 0,
  125. // m2RGBLo, m2RGBHi, 0, 0, m3RGBLo, m3RGBHi, 0, 0)
  126. // Get the R,G,B of each 16bit mask pixel, we want all of them in 5 bits.
  127. // r = (0, m0R, 0, 0, 0, m1R, 0, 0, 0, m2R, 0, 0, 0, m3R, 0, 0)
  128. __m128i r = _mm_and_si128(SkPackedR16x5ToUnmaskedR32x5_SSE2(mask),
  129. _mm_set1_epi32(0x1F << SK_R32_SHIFT));
  130. // g = (0, 0, m0G, 0, 0, 0, m1G, 0, 0, 0, m2G, 0, 0, 0, m3G, 0)
  131. __m128i g = _mm_and_si128(SkPackedG16x5ToUnmaskedG32x5_SSE2(mask),
  132. _mm_set1_epi32(0x1F << SK_G32_SHIFT));
  133. // b = (0, 0, 0, m0B, 0, 0, 0, m1B, 0, 0, 0, m2B, 0, 0, 0, m3B)
  134. __m128i b = _mm_and_si128(SkPackedB16x5ToUnmaskedB32x5_SSE2(mask),
  135. _mm_set1_epi32(0x1F << SK_B32_SHIFT));
  136. // Pack the 4 16bit mask pixels into 4 32bit pixels, (p0, p1, p2, p3)
  137. // Each component (m0R, m0G, etc.) is then a 5-bit value aligned to an
  138. // 8-bit position
  139. // mask = (0, m0R, m0G, m0B, 0, m1R, m1G, m1B,
  140. // 0, m2R, m2G, m2B, 0, m3R, m3G, m3B)
  141. mask = _mm_or_si128(_mm_or_si128(r, g), b);
  142. // Interleave R,G,B into the lower byte of word.
  143. // i.e. split the sixteen 8-bit values from mask into two sets of eight
  144. // 16-bit values, padded by zero.
  145. __m128i maskLo, maskHi;
  146. // maskLo = (0, 0, m0R, 0, m0G, 0, m0B, 0, 0, 0, m1R, 0, m1G, 0, m1B, 0)
  147. maskLo = _mm_unpacklo_epi8(mask, _mm_setzero_si128());
  148. // maskHi = (0, 0, m2R, 0, m2G, 0, m2B, 0, 0, 0, m3R, 0, m3G, 0, m3B, 0)
  149. maskHi = _mm_unpackhi_epi8(mask, _mm_setzero_si128());
  150. // Upscale from 0..31 to 0..32
  151. // (allows to replace division by left-shift further down)
  152. // Left-shift each component by 4 and add the result back to that component,
  153. // mapping numbers in the range 0..15 to 0..15, and 16..31 to 17..32
  154. maskLo = _mm_add_epi16(maskLo, _mm_srli_epi16(maskLo, 4));
  155. maskHi = _mm_add_epi16(maskHi, _mm_srli_epi16(maskHi, 4));
  156. // Multiply each component of maskLo and maskHi by srcA
  157. maskLo = _mm_mullo_epi16(maskLo, srcA);
  158. maskHi = _mm_mullo_epi16(maskHi, srcA);
  159. // Left shift mask components by 8 (divide by 256)
  160. maskLo = _mm_srli_epi16(maskLo, 8);
  161. maskHi = _mm_srli_epi16(maskHi, 8);
  162. // Interleave R,G,B into the lower byte of the word
  163. // dstLo = (0, 0, d0R, 0, d0G, 0, d0B, 0, 0, 0, d1R, 0, d1G, 0, d1B, 0)
  164. __m128i dstLo = _mm_unpacklo_epi8(dst, _mm_setzero_si128());
  165. // dstLo = (0, 0, d2R, 0, d2G, 0, d2B, 0, 0, 0, d3R, 0, d3G, 0, d3B, 0)
  166. __m128i dstHi = _mm_unpackhi_epi8(dst, _mm_setzero_si128());
  167. // mask = (src - dst) * mask
  168. maskLo = _mm_mullo_epi16(maskLo, _mm_sub_epi16(src, dstLo));
  169. maskHi = _mm_mullo_epi16(maskHi, _mm_sub_epi16(src, dstHi));
  170. // mask = (src - dst) * mask >> 5
  171. maskLo = _mm_srai_epi16(maskLo, 5);
  172. maskHi = _mm_srai_epi16(maskHi, 5);
  173. // Add two pixels into result.
  174. // result = dst + ((src - dst) * mask >> 5)
  175. __m128i resultLo = _mm_add_epi16(dstLo, maskLo);
  176. __m128i resultHi = _mm_add_epi16(dstHi, maskHi);
  177. // Pack into 4 32bit dst pixels.
  178. // resultLo and resultHi contain eight 16-bit components (two pixels) each.
  179. // Merge into one SSE regsiter with sixteen 8-bit values (four pixels),
  180. // clamping to 255 if necessary.
  181. return _mm_packus_epi16(resultLo, resultHi);
  182. }
  183. static __m128i blend_lcd16_opaque_sse2(__m128i &src, __m128i &dst, __m128i &mask) {
  184. // In the following comments, the components of src, dst and mask are
  185. // abbreviated as (s)rc, (d)st, and (m)ask. Color components are marked
  186. // by an R, G, B, or A suffix. Components of one of the four pixels that
  187. // are processed in parallel are marked with 0, 1, 2, and 3. "d1B", for
  188. // example is the blue channel of the second destination pixel. Memory
  189. // layout is shown for an ARGB byte order in a color value.
  190. // src and srcA store 8-bit values interleaved with zeros.
  191. // src = (0xFF, 0, sR, 0, sG, 0, sB, 0, 0xFF, 0, sR, 0, sG, 0, sB, 0)
  192. // mask stores 16-bit values (shown as high and low bytes) interleaved with
  193. // zeros
  194. // mask = (m0RGBLo, m0RGBHi, 0, 0, m1RGBLo, m1RGBHi, 0, 0,
  195. // m2RGBLo, m2RGBHi, 0, 0, m3RGBLo, m3RGBHi, 0, 0)
  196. // Get the R,G,B of each 16bit mask pixel, we want all of them in 5 bits.
  197. // r = (0, m0R, 0, 0, 0, m1R, 0, 0, 0, m2R, 0, 0, 0, m3R, 0, 0)
  198. __m128i r = _mm_and_si128(SkPackedR16x5ToUnmaskedR32x5_SSE2(mask),
  199. _mm_set1_epi32(0x1F << SK_R32_SHIFT));
  200. // g = (0, 0, m0G, 0, 0, 0, m1G, 0, 0, 0, m2G, 0, 0, 0, m3G, 0)
  201. __m128i g = _mm_and_si128(SkPackedG16x5ToUnmaskedG32x5_SSE2(mask),
  202. _mm_set1_epi32(0x1F << SK_G32_SHIFT));
  203. // b = (0, 0, 0, m0B, 0, 0, 0, m1B, 0, 0, 0, m2B, 0, 0, 0, m3B)
  204. __m128i b = _mm_and_si128(SkPackedB16x5ToUnmaskedB32x5_SSE2(mask),
  205. _mm_set1_epi32(0x1F << SK_B32_SHIFT));
  206. // Pack the 4 16bit mask pixels into 4 32bit pixels, (p0, p1, p2, p3)
  207. // Each component (m0R, m0G, etc.) is then a 5-bit value aligned to an
  208. // 8-bit position
  209. // mask = (0, m0R, m0G, m0B, 0, m1R, m1G, m1B,
  210. // 0, m2R, m2G, m2B, 0, m3R, m3G, m3B)
  211. mask = _mm_or_si128(_mm_or_si128(r, g), b);
  212. // Interleave R,G,B into the lower byte of word.
  213. // i.e. split the sixteen 8-bit values from mask into two sets of eight
  214. // 16-bit values, padded by zero.
  215. __m128i maskLo, maskHi;
  216. // maskLo = (0, 0, m0R, 0, m0G, 0, m0B, 0, 0, 0, m1R, 0, m1G, 0, m1B, 0)
  217. maskLo = _mm_unpacklo_epi8(mask, _mm_setzero_si128());
  218. // maskHi = (0, 0, m2R, 0, m2G, 0, m2B, 0, 0, 0, m3R, 0, m3G, 0, m3B, 0)
  219. maskHi = _mm_unpackhi_epi8(mask, _mm_setzero_si128());
  220. // Upscale from 0..31 to 0..32
  221. // (allows to replace division by left-shift further down)
  222. // Left-shift each component by 4 and add the result back to that component,
  223. // mapping numbers in the range 0..15 to 0..15, and 16..31 to 17..32
  224. maskLo = _mm_add_epi16(maskLo, _mm_srli_epi16(maskLo, 4));
  225. maskHi = _mm_add_epi16(maskHi, _mm_srli_epi16(maskHi, 4));
  226. // Interleave R,G,B into the lower byte of the word
  227. // dstLo = (0, 0, d0R, 0, d0G, 0, d0B, 0, 0, 0, d1R, 0, d1G, 0, d1B, 0)
  228. __m128i dstLo = _mm_unpacklo_epi8(dst, _mm_setzero_si128());
  229. // dstLo = (0, 0, d2R, 0, d2G, 0, d2B, 0, 0, 0, d3R, 0, d3G, 0, d3B, 0)
  230. __m128i dstHi = _mm_unpackhi_epi8(dst, _mm_setzero_si128());
  231. // mask = (src - dst) * mask
  232. maskLo = _mm_mullo_epi16(maskLo, _mm_sub_epi16(src, dstLo));
  233. maskHi = _mm_mullo_epi16(maskHi, _mm_sub_epi16(src, dstHi));
  234. // mask = (src - dst) * mask >> 5
  235. maskLo = _mm_srai_epi16(maskLo, 5);
  236. maskHi = _mm_srai_epi16(maskHi, 5);
  237. // Add two pixels into result.
  238. // result = dst + ((src - dst) * mask >> 5)
  239. __m128i resultLo = _mm_add_epi16(dstLo, maskLo);
  240. __m128i resultHi = _mm_add_epi16(dstHi, maskHi);
  241. // Pack into 4 32bit dst pixels and force opaque.
  242. // resultLo and resultHi contain eight 16-bit components (two pixels) each.
  243. // Merge into one SSE regsiter with sixteen 8-bit values (four pixels),
  244. // clamping to 255 if necessary. Set alpha components to 0xFF.
  245. return _mm_or_si128(_mm_packus_epi16(resultLo, resultHi),
  246. _mm_set1_epi32(SK_A32_MASK << SK_A32_SHIFT));
  247. }
  248. void blit_row_lcd16(SkPMColor dst[], const uint16_t mask[], SkColor src, int width, SkPMColor) {
  249. if (width <= 0) {
  250. return;
  251. }
  252. int srcA = SkColorGetA(src);
  253. int srcR = SkColorGetR(src);
  254. int srcG = SkColorGetG(src);
  255. int srcB = SkColorGetB(src);
  256. srcA = SkAlpha255To256(srcA);
  257. if (width >= 4) {
  258. SkASSERT(((size_t)dst & 0x03) == 0);
  259. while (((size_t)dst & 0x0F) != 0) {
  260. *dst = blend_lcd16(srcA, srcR, srcG, srcB, *dst, *mask);
  261. mask++;
  262. dst++;
  263. width--;
  264. }
  265. __m128i *d = reinterpret_cast<__m128i*>(dst);
  266. // Set alpha to 0xFF and replicate source four times in SSE register.
  267. __m128i src_sse = _mm_set1_epi32(SkPackARGB32(0xFF, srcR, srcG, srcB));
  268. // Interleave with zeros to get two sets of four 16-bit values.
  269. src_sse = _mm_unpacklo_epi8(src_sse, _mm_setzero_si128());
  270. // Set srcA_sse to contain eight copies of srcA, padded with zero.
  271. // src_sse=(0xFF, 0, sR, 0, sG, 0, sB, 0, 0xFF, 0, sR, 0, sG, 0, sB, 0)
  272. __m128i srcA_sse = _mm_set1_epi16(srcA);
  273. while (width >= 4) {
  274. // Load four destination pixels into dst_sse.
  275. __m128i dst_sse = _mm_load_si128(d);
  276. // Load four 16-bit masks into lower half of mask_sse.
  277. __m128i mask_sse = _mm_loadl_epi64(
  278. reinterpret_cast<const __m128i*>(mask));
  279. // Check whether masks are equal to 0 and get the highest bit
  280. // of each byte of result, if masks are all zero, we will get
  281. // pack_cmp to 0xFFFF
  282. int pack_cmp = _mm_movemask_epi8(_mm_cmpeq_epi16(mask_sse,
  283. _mm_setzero_si128()));
  284. // if mask pixels are not all zero, we will blend the dst pixels
  285. if (pack_cmp != 0xFFFF) {
  286. // Unpack 4 16bit mask pixels to
  287. // mask_sse = (m0RGBLo, m0RGBHi, 0, 0, m1RGBLo, m1RGBHi, 0, 0,
  288. // m2RGBLo, m2RGBHi, 0, 0, m3RGBLo, m3RGBHi, 0, 0)
  289. mask_sse = _mm_unpacklo_epi16(mask_sse,
  290. _mm_setzero_si128());
  291. // Process 4 32bit dst pixels
  292. __m128i result = blend_lcd16_sse2(src_sse, dst_sse, mask_sse, srcA_sse);
  293. _mm_store_si128(d, result);
  294. }
  295. d++;
  296. mask += 4;
  297. width -= 4;
  298. }
  299. dst = reinterpret_cast<SkPMColor*>(d);
  300. }
  301. while (width > 0) {
  302. *dst = blend_lcd16(srcA, srcR, srcG, srcB, *dst, *mask);
  303. mask++;
  304. dst++;
  305. width--;
  306. }
  307. }
  308. void blit_row_lcd16_opaque(SkPMColor dst[], const uint16_t mask[],
  309. SkColor src, int width, SkPMColor opaqueDst) {
  310. if (width <= 0) {
  311. return;
  312. }
  313. int srcR = SkColorGetR(src);
  314. int srcG = SkColorGetG(src);
  315. int srcB = SkColorGetB(src);
  316. if (width >= 4) {
  317. SkASSERT(((size_t)dst & 0x03) == 0);
  318. while (((size_t)dst & 0x0F) != 0) {
  319. *dst = blend_lcd16_opaque(srcR, srcG, srcB, *dst, *mask, opaqueDst);
  320. mask++;
  321. dst++;
  322. width--;
  323. }
  324. __m128i *d = reinterpret_cast<__m128i*>(dst);
  325. // Set alpha to 0xFF and replicate source four times in SSE register.
  326. __m128i src_sse = _mm_set1_epi32(SkPackARGB32(0xFF, srcR, srcG, srcB));
  327. // Set srcA_sse to contain eight copies of srcA, padded with zero.
  328. // src_sse=(0xFF, 0, sR, 0, sG, 0, sB, 0, 0xFF, 0, sR, 0, sG, 0, sB, 0)
  329. src_sse = _mm_unpacklo_epi8(src_sse, _mm_setzero_si128());
  330. while (width >= 4) {
  331. // Load four destination pixels into dst_sse.
  332. __m128i dst_sse = _mm_load_si128(d);
  333. // Load four 16-bit masks into lower half of mask_sse.
  334. __m128i mask_sse = _mm_loadl_epi64(
  335. reinterpret_cast<const __m128i*>(mask));
  336. // Check whether masks are equal to 0 and get the highest bit
  337. // of each byte of result, if masks are all zero, we will get
  338. // pack_cmp to 0xFFFF
  339. int pack_cmp = _mm_movemask_epi8(_mm_cmpeq_epi16(mask_sse,
  340. _mm_setzero_si128()));
  341. // if mask pixels are not all zero, we will blend the dst pixels
  342. if (pack_cmp != 0xFFFF) {
  343. // Unpack 4 16bit mask pixels to
  344. // mask_sse = (m0RGBLo, m0RGBHi, 0, 0, m1RGBLo, m1RGBHi, 0, 0,
  345. // m2RGBLo, m2RGBHi, 0, 0, m3RGBLo, m3RGBHi, 0, 0)
  346. mask_sse = _mm_unpacklo_epi16(mask_sse,
  347. _mm_setzero_si128());
  348. // Process 4 32bit dst pixels
  349. __m128i result = blend_lcd16_opaque_sse2(src_sse, dst_sse, mask_sse);
  350. _mm_store_si128(d, result);
  351. }
  352. d++;
  353. mask += 4;
  354. width -= 4;
  355. }
  356. dst = reinterpret_cast<SkPMColor*>(d);
  357. }
  358. while (width > 0) {
  359. *dst = blend_lcd16_opaque(srcR, srcG, srcB, *dst, *mask, opaqueDst);
  360. mask++;
  361. dst++;
  362. width--;
  363. }
  364. }
  365. #elif defined(SK_ARM_HAS_NEON)
  366. #include <arm_neon.h>
  367. #define NEON_A (SK_A32_SHIFT / 8)
  368. #define NEON_R (SK_R32_SHIFT / 8)
  369. #define NEON_G (SK_G32_SHIFT / 8)
  370. #define NEON_B (SK_B32_SHIFT / 8)
  371. static inline uint8x8_t blend_32_neon(uint8x8_t src, uint8x8_t dst, uint16x8_t scale) {
  372. int16x8_t src_wide, dst_wide;
  373. src_wide = vreinterpretq_s16_u16(vmovl_u8(src));
  374. dst_wide = vreinterpretq_s16_u16(vmovl_u8(dst));
  375. src_wide = (src_wide - dst_wide) * vreinterpretq_s16_u16(scale);
  376. dst_wide += vshrq_n_s16(src_wide, 5);
  377. return vmovn_u16(vreinterpretq_u16_s16(dst_wide));
  378. }
  379. void blit_row_lcd16_opaque(SkPMColor dst[], const uint16_t src[],
  380. SkColor color, int width,
  381. SkPMColor opaqueDst) {
  382. int colR = SkColorGetR(color);
  383. int colG = SkColorGetG(color);
  384. int colB = SkColorGetB(color);
  385. uint8x8_t vcolR = vdup_n_u8(colR);
  386. uint8x8_t vcolG = vdup_n_u8(colG);
  387. uint8x8_t vcolB = vdup_n_u8(colB);
  388. uint8x8_t vopqDstA = vdup_n_u8(SkGetPackedA32(opaqueDst));
  389. uint8x8_t vopqDstR = vdup_n_u8(SkGetPackedR32(opaqueDst));
  390. uint8x8_t vopqDstG = vdup_n_u8(SkGetPackedG32(opaqueDst));
  391. uint8x8_t vopqDstB = vdup_n_u8(SkGetPackedB32(opaqueDst));
  392. while (width >= 8) {
  393. uint8x8x4_t vdst;
  394. uint16x8_t vmask;
  395. uint16x8_t vmaskR, vmaskG, vmaskB;
  396. uint8x8_t vsel_trans, vsel_opq;
  397. vdst = vld4_u8((uint8_t*)dst);
  398. vmask = vld1q_u16(src);
  399. // Prepare compare masks
  400. vsel_trans = vmovn_u16(vceqq_u16(vmask, vdupq_n_u16(0)));
  401. vsel_opq = vmovn_u16(vceqq_u16(vmask, vdupq_n_u16(0xFFFF)));
  402. // Get all the color masks on 5 bits
  403. vmaskR = vshrq_n_u16(vmask, SK_R16_SHIFT);
  404. vmaskG = vshrq_n_u16(vshlq_n_u16(vmask, SK_R16_BITS),
  405. SK_B16_BITS + SK_R16_BITS + 1);
  406. vmaskB = vmask & vdupq_n_u16(SK_B16_MASK);
  407. // Upscale to 0..32
  408. vmaskR = vmaskR + vshrq_n_u16(vmaskR, 4);
  409. vmaskG = vmaskG + vshrq_n_u16(vmaskG, 4);
  410. vmaskB = vmaskB + vshrq_n_u16(vmaskB, 4);
  411. vdst.val[NEON_A] = vbsl_u8(vsel_trans, vdst.val[NEON_A], vdup_n_u8(0xFF));
  412. vdst.val[NEON_A] = vbsl_u8(vsel_opq, vopqDstA, vdst.val[NEON_A]);
  413. vdst.val[NEON_R] = blend_32_neon(vcolR, vdst.val[NEON_R], vmaskR);
  414. vdst.val[NEON_G] = blend_32_neon(vcolG, vdst.val[NEON_G], vmaskG);
  415. vdst.val[NEON_B] = blend_32_neon(vcolB, vdst.val[NEON_B], vmaskB);
  416. vdst.val[NEON_R] = vbsl_u8(vsel_opq, vopqDstR, vdst.val[NEON_R]);
  417. vdst.val[NEON_G] = vbsl_u8(vsel_opq, vopqDstG, vdst.val[NEON_G]);
  418. vdst.val[NEON_B] = vbsl_u8(vsel_opq, vopqDstB, vdst.val[NEON_B]);
  419. vst4_u8((uint8_t*)dst, vdst);
  420. dst += 8;
  421. src += 8;
  422. width -= 8;
  423. }
  424. // Leftovers
  425. for (int i = 0; i < width; i++) {
  426. dst[i] = blend_lcd16_opaque(colR, colG, colB, dst[i], src[i], opaqueDst);
  427. }
  428. }
  429. void blit_row_lcd16(SkPMColor dst[], const uint16_t src[],
  430. SkColor color, int width, SkPMColor) {
  431. int colA = SkColorGetA(color);
  432. int colR = SkColorGetR(color);
  433. int colG = SkColorGetG(color);
  434. int colB = SkColorGetB(color);
  435. colA = SkAlpha255To256(colA);
  436. uint16x8_t vcolA = vdupq_n_u16(colA);
  437. uint8x8_t vcolR = vdup_n_u8(colR);
  438. uint8x8_t vcolG = vdup_n_u8(colG);
  439. uint8x8_t vcolB = vdup_n_u8(colB);
  440. while (width >= 8) {
  441. uint8x8x4_t vdst;
  442. uint16x8_t vmask;
  443. uint16x8_t vmaskR, vmaskG, vmaskB;
  444. vdst = vld4_u8((uint8_t*)dst);
  445. vmask = vld1q_u16(src);
  446. // Get all the color masks on 5 bits
  447. vmaskR = vshrq_n_u16(vmask, SK_R16_SHIFT);
  448. vmaskG = vshrq_n_u16(vshlq_n_u16(vmask, SK_R16_BITS),
  449. SK_B16_BITS + SK_R16_BITS + 1);
  450. vmaskB = vmask & vdupq_n_u16(SK_B16_MASK);
  451. // Upscale to 0..32
  452. vmaskR = vmaskR + vshrq_n_u16(vmaskR, 4);
  453. vmaskG = vmaskG + vshrq_n_u16(vmaskG, 4);
  454. vmaskB = vmaskB + vshrq_n_u16(vmaskB, 4);
  455. vmaskR = vshrq_n_u16(vmaskR * vcolA, 8);
  456. vmaskG = vshrq_n_u16(vmaskG * vcolA, 8);
  457. vmaskB = vshrq_n_u16(vmaskB * vcolA, 8);
  458. vdst.val[NEON_A] = vdup_n_u8(0xFF);
  459. vdst.val[NEON_R] = blend_32_neon(vcolR, vdst.val[NEON_R], vmaskR);
  460. vdst.val[NEON_G] = blend_32_neon(vcolG, vdst.val[NEON_G], vmaskG);
  461. vdst.val[NEON_B] = blend_32_neon(vcolB, vdst.val[NEON_B], vmaskB);
  462. vst4_u8((uint8_t*)dst, vdst);
  463. dst += 8;
  464. src += 8;
  465. width -= 8;
  466. }
  467. for (int i = 0; i < width; i++) {
  468. dst[i] = blend_lcd16(colA, colR, colG, colB, dst[i], src[i]);
  469. }
  470. }
  471. #else
  472. static inline void blit_row_lcd16(SkPMColor dst[], const uint16_t mask[],
  473. SkColor src, int width, SkPMColor) {
  474. int srcA = SkColorGetA(src);
  475. int srcR = SkColorGetR(src);
  476. int srcG = SkColorGetG(src);
  477. int srcB = SkColorGetB(src);
  478. srcA = SkAlpha255To256(srcA);
  479. for (int i = 0; i < width; i++) {
  480. dst[i] = blend_lcd16(srcA, srcR, srcG, srcB, dst[i], mask[i]);
  481. }
  482. }
  483. static inline void blit_row_lcd16_opaque(SkPMColor dst[], const uint16_t mask[],
  484. SkColor src, int width,
  485. SkPMColor opaqueDst) {
  486. int srcR = SkColorGetR(src);
  487. int srcG = SkColorGetG(src);
  488. int srcB = SkColorGetB(src);
  489. for (int i = 0; i < width; i++) {
  490. dst[i] = blend_lcd16_opaque(srcR, srcG, srcB, dst[i], mask[i], opaqueDst);
  491. }
  492. }
  493. #endif
  494. static bool blit_color(const SkPixmap& device,
  495. const SkMask& mask,
  496. const SkIRect& clip,
  497. SkColor color) {
  498. int x = clip.fLeft,
  499. y = clip.fTop;
  500. if (device.colorType() == kN32_SkColorType && mask.fFormat == SkMask::kA8_Format) {
  501. SkOpts::blit_mask_d32_a8(device.writable_addr32(x,y), device.rowBytes(),
  502. (const SkAlpha*)mask.getAddr(x,y), mask.fRowBytes,
  503. color, clip.width(), clip.height());
  504. return true;
  505. }
  506. if (device.colorType() == kN32_SkColorType && mask.fFormat == SkMask::kLCD16_Format) {
  507. auto dstRow = device.writable_addr32(x,y);
  508. auto maskRow = (const uint16_t*)mask.getAddr(x,y);
  509. auto blit_row = blit_row_lcd16;
  510. SkPMColor opaqueDst = 0; // ignored unless opaque
  511. if (0xff == SkColorGetA(color)) {
  512. blit_row = blit_row_lcd16_opaque;
  513. opaqueDst = SkPreMultiplyColor(color);
  514. }
  515. for (int height = clip.height(); height --> 0; ) {
  516. blit_row(dstRow, maskRow, color, clip.width(), opaqueDst);
  517. dstRow = (SkPMColor*) (( char*) dstRow + device.rowBytes());
  518. maskRow = (const uint16_t*)((const char*)maskRow + mask.fRowBytes);
  519. }
  520. return true;
  521. }
  522. return false;
  523. }
  524. ///////////////////////////////////////////////////////////////////////////////
  525. static void SkARGB32_Blit32(const SkPixmap& device, const SkMask& mask,
  526. const SkIRect& clip, SkPMColor srcColor) {
  527. U8CPU alpha = SkGetPackedA32(srcColor);
  528. unsigned flags = SkBlitRow::kSrcPixelAlpha_Flag32;
  529. if (alpha != 255) {
  530. flags |= SkBlitRow::kGlobalAlpha_Flag32;
  531. }
  532. SkBlitRow::Proc32 proc = SkBlitRow::Factory32(flags);
  533. int x = clip.fLeft;
  534. int y = clip.fTop;
  535. int width = clip.width();
  536. int height = clip.height();
  537. SkPMColor* dstRow = device.writable_addr32(x, y);
  538. const SkPMColor* srcRow = reinterpret_cast<const SkPMColor*>(mask.getAddr8(x, y));
  539. do {
  540. proc(dstRow, srcRow, width, alpha);
  541. dstRow = (SkPMColor*)((char*)dstRow + device.rowBytes());
  542. srcRow = (const SkPMColor*)((const char*)srcRow + mask.fRowBytes);
  543. } while (--height != 0);
  544. }
  545. //////////////////////////////////////////////////////////////////////////////////////
  546. SkARGB32_Blitter::SkARGB32_Blitter(const SkPixmap& device, const SkPaint& paint)
  547. : INHERITED(device) {
  548. SkColor color = paint.getColor();
  549. fColor = color;
  550. fSrcA = SkColorGetA(color);
  551. unsigned scale = SkAlpha255To256(fSrcA);
  552. fSrcR = SkAlphaMul(SkColorGetR(color), scale);
  553. fSrcG = SkAlphaMul(SkColorGetG(color), scale);
  554. fSrcB = SkAlphaMul(SkColorGetB(color), scale);
  555. fPMColor = SkPackARGB32(fSrcA, fSrcR, fSrcG, fSrcB);
  556. }
  557. const SkPixmap* SkARGB32_Blitter::justAnOpaqueColor(uint32_t* value) {
  558. if (255 == fSrcA) {
  559. *value = fPMColor;
  560. return &fDevice;
  561. }
  562. return nullptr;
  563. }
  564. #if defined _WIN32 // disable warning : local variable used without having been initialized
  565. #pragma warning ( push )
  566. #pragma warning ( disable : 4701 )
  567. #endif
  568. void SkARGB32_Blitter::blitH(int x, int y, int width) {
  569. SkASSERT(x >= 0 && y >= 0 && x + width <= fDevice.width());
  570. uint32_t* device = fDevice.writable_addr32(x, y);
  571. SkBlitRow::Color32(device, device, width, fPMColor);
  572. }
  573. void SkARGB32_Blitter::blitAntiH(int x, int y, const SkAlpha antialias[],
  574. const int16_t runs[]) {
  575. if (fSrcA == 0) {
  576. return;
  577. }
  578. uint32_t color = fPMColor;
  579. uint32_t* device = fDevice.writable_addr32(x, y);
  580. unsigned opaqueMask = fSrcA; // if fSrcA is 0xFF, then we will catch the fast opaque case
  581. for (;;) {
  582. int count = runs[0];
  583. SkASSERT(count >= 0);
  584. if (count <= 0) {
  585. return;
  586. }
  587. unsigned aa = antialias[0];
  588. if (aa) {
  589. if ((opaqueMask & aa) == 255) {
  590. sk_memset32(device, color, count);
  591. } else {
  592. uint32_t sc = SkAlphaMulQ(color, SkAlpha255To256(aa));
  593. SkBlitRow::Color32(device, device, count, sc);
  594. }
  595. }
  596. runs += count;
  597. antialias += count;
  598. device += count;
  599. }
  600. }
  601. void SkARGB32_Blitter::blitAntiH2(int x, int y, U8CPU a0, U8CPU a1) {
  602. uint32_t* device = fDevice.writable_addr32(x, y);
  603. SkDEBUGCODE((void)fDevice.writable_addr32(x + 1, y);)
  604. device[0] = SkBlendARGB32(fPMColor, device[0], a0);
  605. device[1] = SkBlendARGB32(fPMColor, device[1], a1);
  606. }
  607. void SkARGB32_Blitter::blitAntiV2(int x, int y, U8CPU a0, U8CPU a1) {
  608. uint32_t* device = fDevice.writable_addr32(x, y);
  609. SkDEBUGCODE((void)fDevice.writable_addr32(x, y + 1);)
  610. device[0] = SkBlendARGB32(fPMColor, device[0], a0);
  611. device = (uint32_t*)((char*)device + fDevice.rowBytes());
  612. device[0] = SkBlendARGB32(fPMColor, device[0], a1);
  613. }
  614. //////////////////////////////////////////////////////////////////////////////////////
  615. #define solid_8_pixels(mask, dst, color) \
  616. do { \
  617. if (mask & 0x80) dst[0] = color; \
  618. if (mask & 0x40) dst[1] = color; \
  619. if (mask & 0x20) dst[2] = color; \
  620. if (mask & 0x10) dst[3] = color; \
  621. if (mask & 0x08) dst[4] = color; \
  622. if (mask & 0x04) dst[5] = color; \
  623. if (mask & 0x02) dst[6] = color; \
  624. if (mask & 0x01) dst[7] = color; \
  625. } while (0)
  626. #define SK_BLITBWMASK_NAME SkARGB32_BlitBW
  627. #define SK_BLITBWMASK_ARGS , SkPMColor color
  628. #define SK_BLITBWMASK_BLIT8(mask, dst) solid_8_pixels(mask, dst, color)
  629. #define SK_BLITBWMASK_GETADDR writable_addr32
  630. #define SK_BLITBWMASK_DEVTYPE uint32_t
  631. #include "src/core/SkBlitBWMaskTemplate.h"
  632. #define blend_8_pixels(mask, dst, sc, dst_scale) \
  633. do { \
  634. if (mask & 0x80) { dst[0] = sc + SkAlphaMulQ(dst[0], dst_scale); } \
  635. if (mask & 0x40) { dst[1] = sc + SkAlphaMulQ(dst[1], dst_scale); } \
  636. if (mask & 0x20) { dst[2] = sc + SkAlphaMulQ(dst[2], dst_scale); } \
  637. if (mask & 0x10) { dst[3] = sc + SkAlphaMulQ(dst[3], dst_scale); } \
  638. if (mask & 0x08) { dst[4] = sc + SkAlphaMulQ(dst[4], dst_scale); } \
  639. if (mask & 0x04) { dst[5] = sc + SkAlphaMulQ(dst[5], dst_scale); } \
  640. if (mask & 0x02) { dst[6] = sc + SkAlphaMulQ(dst[6], dst_scale); } \
  641. if (mask & 0x01) { dst[7] = sc + SkAlphaMulQ(dst[7], dst_scale); } \
  642. } while (0)
  643. #define SK_BLITBWMASK_NAME SkARGB32_BlendBW
  644. #define SK_BLITBWMASK_ARGS , uint32_t sc, unsigned dst_scale
  645. #define SK_BLITBWMASK_BLIT8(mask, dst) blend_8_pixels(mask, dst, sc, dst_scale)
  646. #define SK_BLITBWMASK_GETADDR writable_addr32
  647. #define SK_BLITBWMASK_DEVTYPE uint32_t
  648. #include "src/core/SkBlitBWMaskTemplate.h"
  649. void SkARGB32_Blitter::blitMask(const SkMask& mask, const SkIRect& clip) {
  650. SkASSERT(mask.fBounds.contains(clip));
  651. SkASSERT(fSrcA != 0xFF);
  652. if (fSrcA == 0) {
  653. return;
  654. }
  655. if (blit_color(fDevice, mask, clip, fColor)) {
  656. return;
  657. }
  658. switch (mask.fFormat) {
  659. case SkMask::kBW_Format:
  660. SkARGB32_BlendBW(fDevice, mask, clip, fPMColor, SkAlpha255To256(255 - fSrcA));
  661. break;
  662. case SkMask::kARGB32_Format:
  663. SkARGB32_Blit32(fDevice, mask, clip, fPMColor);
  664. break;
  665. default:
  666. SK_ABORT("Mask format not handled.");
  667. }
  668. }
  669. void SkARGB32_Opaque_Blitter::blitMask(const SkMask& mask,
  670. const SkIRect& clip) {
  671. SkASSERT(mask.fBounds.contains(clip));
  672. if (blit_color(fDevice, mask, clip, fColor)) {
  673. return;
  674. }
  675. switch (mask.fFormat) {
  676. case SkMask::kBW_Format:
  677. SkARGB32_BlitBW(fDevice, mask, clip, fPMColor);
  678. break;
  679. case SkMask::kARGB32_Format:
  680. SkARGB32_Blit32(fDevice, mask, clip, fPMColor);
  681. break;
  682. default:
  683. SK_ABORT("Mask format not handled.");
  684. }
  685. }
  686. void SkARGB32_Opaque_Blitter::blitAntiH2(int x, int y, U8CPU a0, U8CPU a1) {
  687. uint32_t* device = fDevice.writable_addr32(x, y);
  688. SkDEBUGCODE((void)fDevice.writable_addr32(x + 1, y);)
  689. device[0] = SkFastFourByteInterp(fPMColor, device[0], a0);
  690. device[1] = SkFastFourByteInterp(fPMColor, device[1], a1);
  691. }
  692. void SkARGB32_Opaque_Blitter::blitAntiV2(int x, int y, U8CPU a0, U8CPU a1) {
  693. uint32_t* device = fDevice.writable_addr32(x, y);
  694. SkDEBUGCODE((void)fDevice.writable_addr32(x, y + 1);)
  695. device[0] = SkFastFourByteInterp(fPMColor, device[0], a0);
  696. device = (uint32_t*)((char*)device + fDevice.rowBytes());
  697. device[0] = SkFastFourByteInterp(fPMColor, device[0], a1);
  698. }
  699. ///////////////////////////////////////////////////////////////////////////////
  700. void SkARGB32_Blitter::blitV(int x, int y, int height, SkAlpha alpha) {
  701. if (alpha == 0 || fSrcA == 0) {
  702. return;
  703. }
  704. uint32_t* device = fDevice.writable_addr32(x, y);
  705. uint32_t color = fPMColor;
  706. if (alpha != 255) {
  707. color = SkAlphaMulQ(color, SkAlpha255To256(alpha));
  708. }
  709. unsigned dst_scale = SkAlpha255To256(255 - SkGetPackedA32(color));
  710. size_t rowBytes = fDevice.rowBytes();
  711. while (--height >= 0) {
  712. device[0] = color + SkAlphaMulQ(device[0], dst_scale);
  713. device = (uint32_t*)((char*)device + rowBytes);
  714. }
  715. }
  716. void SkARGB32_Blitter::blitRect(int x, int y, int width, int height) {
  717. SkASSERT(x >= 0 && y >= 0 && x + width <= fDevice.width() && y + height <= fDevice.height());
  718. if (fSrcA == 0) {
  719. return;
  720. }
  721. uint32_t* device = fDevice.writable_addr32(x, y);
  722. uint32_t color = fPMColor;
  723. size_t rowBytes = fDevice.rowBytes();
  724. if (SkGetPackedA32(fPMColor) == 0xFF) {
  725. SkOpts::rect_memset32(device, color, width, rowBytes, height);
  726. } else {
  727. while (height --> 0) {
  728. SkBlitRow::Color32(device, device, width, color);
  729. device = (uint32_t*)((char*)device + rowBytes);
  730. }
  731. }
  732. }
  733. #if defined _WIN32
  734. #pragma warning ( pop )
  735. #endif
  736. ///////////////////////////////////////////////////////////////////////
  737. void SkARGB32_Black_Blitter::blitAntiH(int x, int y, const SkAlpha antialias[],
  738. const int16_t runs[]) {
  739. uint32_t* device = fDevice.writable_addr32(x, y);
  740. SkPMColor black = (SkPMColor)(SK_A32_MASK << SK_A32_SHIFT);
  741. for (;;) {
  742. int count = runs[0];
  743. SkASSERT(count >= 0);
  744. if (count <= 0) {
  745. return;
  746. }
  747. unsigned aa = antialias[0];
  748. if (aa) {
  749. if (aa == 255) {
  750. sk_memset32(device, black, count);
  751. } else {
  752. SkPMColor src = aa << SK_A32_SHIFT;
  753. unsigned dst_scale = 256 - aa;
  754. int n = count;
  755. do {
  756. --n;
  757. device[n] = src + SkAlphaMulQ(device[n], dst_scale);
  758. } while (n > 0);
  759. }
  760. }
  761. runs += count;
  762. antialias += count;
  763. device += count;
  764. }
  765. }
  766. void SkARGB32_Black_Blitter::blitAntiH2(int x, int y, U8CPU a0, U8CPU a1) {
  767. uint32_t* device = fDevice.writable_addr32(x, y);
  768. SkDEBUGCODE((void)fDevice.writable_addr32(x + 1, y);)
  769. device[0] = (a0 << SK_A32_SHIFT) + SkAlphaMulQ(device[0], 256 - a0);
  770. device[1] = (a1 << SK_A32_SHIFT) + SkAlphaMulQ(device[1], 256 - a1);
  771. }
  772. void SkARGB32_Black_Blitter::blitAntiV2(int x, int y, U8CPU a0, U8CPU a1) {
  773. uint32_t* device = fDevice.writable_addr32(x, y);
  774. SkDEBUGCODE((void)fDevice.writable_addr32(x, y + 1);)
  775. device[0] = (a0 << SK_A32_SHIFT) + SkAlphaMulQ(device[0], 256 - a0);
  776. device = (uint32_t*)((char*)device + fDevice.rowBytes());
  777. device[0] = (a1 << SK_A32_SHIFT) + SkAlphaMulQ(device[0], 256 - a1);
  778. }
  779. ///////////////////////////////////////////////////////////////////////////////
  780. // Special version of SkBlitRow::Factory32 that knows we're in kSrc_Mode,
  781. // instead of kSrcOver_Mode
  782. static void blend_srcmode(SkPMColor* SK_RESTRICT device,
  783. const SkPMColor* SK_RESTRICT span,
  784. int count, U8CPU aa) {
  785. int aa256 = SkAlpha255To256(aa);
  786. for (int i = 0; i < count; ++i) {
  787. device[i] = SkFourByteInterp256(span[i], device[i], aa256);
  788. }
  789. }
  790. SkARGB32_Shader_Blitter::SkARGB32_Shader_Blitter(const SkPixmap& device,
  791. const SkPaint& paint, SkShaderBase::Context* shaderContext)
  792. : INHERITED(device, paint, shaderContext)
  793. {
  794. fBuffer = (SkPMColor*)sk_malloc_throw(device.width() * (sizeof(SkPMColor)));
  795. fXfermode = SkXfermode::Peek(paint.getBlendMode());
  796. int flags = 0;
  797. if (!(shaderContext->getFlags() & SkShaderBase::kOpaqueAlpha_Flag)) {
  798. flags |= SkBlitRow::kSrcPixelAlpha_Flag32;
  799. }
  800. // we call this on the output from the shader
  801. fProc32 = SkBlitRow::Factory32(flags);
  802. // we call this on the output from the shader + alpha from the aa buffer
  803. fProc32Blend = SkBlitRow::Factory32(flags | SkBlitRow::kGlobalAlpha_Flag32);
  804. fShadeDirectlyIntoDevice = false;
  805. if (fXfermode == nullptr) {
  806. if (shaderContext->getFlags() & SkShaderBase::kOpaqueAlpha_Flag) {
  807. fShadeDirectlyIntoDevice = true;
  808. }
  809. } else {
  810. if (SkBlendMode::kSrc == paint.getBlendMode()) {
  811. fShadeDirectlyIntoDevice = true;
  812. fProc32Blend = blend_srcmode;
  813. }
  814. }
  815. fConstInY = SkToBool(shaderContext->getFlags() & SkShaderBase::kConstInY32_Flag);
  816. }
  817. SkARGB32_Shader_Blitter::~SkARGB32_Shader_Blitter() {
  818. sk_free(fBuffer);
  819. }
  820. void SkARGB32_Shader_Blitter::blitH(int x, int y, int width) {
  821. SkASSERT(x >= 0 && y >= 0 && x + width <= fDevice.width());
  822. uint32_t* device = fDevice.writable_addr32(x, y);
  823. if (fShadeDirectlyIntoDevice) {
  824. fShaderContext->shadeSpan(x, y, device, width);
  825. } else {
  826. SkPMColor* span = fBuffer;
  827. fShaderContext->shadeSpan(x, y, span, width);
  828. if (fXfermode) {
  829. fXfermode->xfer32(device, span, width, nullptr);
  830. } else {
  831. fProc32(device, span, width, 255);
  832. }
  833. }
  834. }
  835. void SkARGB32_Shader_Blitter::blitRect(int x, int y, int width, int height) {
  836. SkASSERT(x >= 0 && y >= 0 &&
  837. x + width <= fDevice.width() && y + height <= fDevice.height());
  838. uint32_t* device = fDevice.writable_addr32(x, y);
  839. size_t deviceRB = fDevice.rowBytes();
  840. auto* shaderContext = fShaderContext;
  841. SkPMColor* span = fBuffer;
  842. if (fConstInY) {
  843. if (fShadeDirectlyIntoDevice) {
  844. // shade the first row directly into the device
  845. shaderContext->shadeSpan(x, y, device, width);
  846. span = device;
  847. while (--height > 0) {
  848. device = (uint32_t*)((char*)device + deviceRB);
  849. memcpy(device, span, width << 2);
  850. }
  851. } else {
  852. shaderContext->shadeSpan(x, y, span, width);
  853. SkXfermode* xfer = fXfermode;
  854. if (xfer) {
  855. do {
  856. xfer->xfer32(device, span, width, nullptr);
  857. y += 1;
  858. device = (uint32_t*)((char*)device + deviceRB);
  859. } while (--height > 0);
  860. } else {
  861. SkBlitRow::Proc32 proc = fProc32;
  862. do {
  863. proc(device, span, width, 255);
  864. y += 1;
  865. device = (uint32_t*)((char*)device + deviceRB);
  866. } while (--height > 0);
  867. }
  868. }
  869. return;
  870. }
  871. if (fShadeDirectlyIntoDevice) {
  872. do {
  873. shaderContext->shadeSpan(x, y, device, width);
  874. y += 1;
  875. device = (uint32_t*)((char*)device + deviceRB);
  876. } while (--height > 0);
  877. } else {
  878. SkXfermode* xfer = fXfermode;
  879. if (xfer) {
  880. do {
  881. shaderContext->shadeSpan(x, y, span, width);
  882. xfer->xfer32(device, span, width, nullptr);
  883. y += 1;
  884. device = (uint32_t*)((char*)device + deviceRB);
  885. } while (--height > 0);
  886. } else {
  887. SkBlitRow::Proc32 proc = fProc32;
  888. do {
  889. shaderContext->shadeSpan(x, y, span, width);
  890. proc(device, span, width, 255);
  891. y += 1;
  892. device = (uint32_t*)((char*)device + deviceRB);
  893. } while (--height > 0);
  894. }
  895. }
  896. }
  897. void SkARGB32_Shader_Blitter::blitAntiH(int x, int y, const SkAlpha antialias[],
  898. const int16_t runs[]) {
  899. SkPMColor* span = fBuffer;
  900. uint32_t* device = fDevice.writable_addr32(x, y);
  901. auto* shaderContext = fShaderContext;
  902. if (fXfermode && !fShadeDirectlyIntoDevice) {
  903. for (;;) {
  904. SkXfermode* xfer = fXfermode;
  905. int count = *runs;
  906. if (count <= 0)
  907. break;
  908. int aa = *antialias;
  909. if (aa) {
  910. shaderContext->shadeSpan(x, y, span, count);
  911. if (aa == 255) {
  912. xfer->xfer32(device, span, count, nullptr);
  913. } else {
  914. // count is almost always 1
  915. for (int i = count - 1; i >= 0; --i) {
  916. xfer->xfer32(&device[i], &span[i], 1, antialias);
  917. }
  918. }
  919. }
  920. device += count;
  921. runs += count;
  922. antialias += count;
  923. x += count;
  924. }
  925. } else if (fShadeDirectlyIntoDevice ||
  926. (shaderContext->getFlags() & SkShaderBase::kOpaqueAlpha_Flag)) {
  927. for (;;) {
  928. int count = *runs;
  929. if (count <= 0) {
  930. break;
  931. }
  932. int aa = *antialias;
  933. if (aa) {
  934. if (aa == 255) {
  935. // cool, have the shader draw right into the device
  936. shaderContext->shadeSpan(x, y, device, count);
  937. } else {
  938. shaderContext->shadeSpan(x, y, span, count);
  939. fProc32Blend(device, span, count, aa);
  940. }
  941. }
  942. device += count;
  943. runs += count;
  944. antialias += count;
  945. x += count;
  946. }
  947. } else {
  948. for (;;) {
  949. int count = *runs;
  950. if (count <= 0) {
  951. break;
  952. }
  953. int aa = *antialias;
  954. if (aa) {
  955. shaderContext->shadeSpan(x, y, span, count);
  956. if (aa == 255) {
  957. fProc32(device, span, count, 255);
  958. } else {
  959. fProc32Blend(device, span, count, aa);
  960. }
  961. }
  962. device += count;
  963. runs += count;
  964. antialias += count;
  965. x += count;
  966. }
  967. }
  968. }
  969. #ifndef SK_SUPPORT_LEGACY_A8_MASKBLITTER
  970. using U32 = skvx::Vec< 4, uint32_t>;
  971. using U8x4 = skvx::Vec<16, uint8_t>;
  972. using U8 = skvx::Vec< 4, uint8_t>;
  973. static void drive(SkPMColor* dst, const SkPMColor* src, const uint8_t* cov, int n,
  974. U8x4 (*kernel)(U8x4,U8x4,U8x4)) {
  975. auto apply = [kernel](U32 dst, U32 src, U8 cov) -> U32 {
  976. U8x4 cov_splat = skvx::shuffle<0,0,0,0, 1,1,1,1, 2,2,2,2, 3,3,3,3>(cov);
  977. return skvx::bit_pun<U32>(kernel(skvx::bit_pun<U8x4>(dst),
  978. skvx::bit_pun<U8x4>(src),
  979. cov_splat));
  980. };
  981. while (n >= 4) {
  982. apply(U32::Load(dst), U32::Load(src), U8::Load(cov)).store(dst);
  983. dst += 4;
  984. src += 4;
  985. cov += 4;
  986. n -= 4;
  987. }
  988. while (n --> 0) {
  989. *dst = apply(U32{*dst}, U32{*src}, U8{*cov})[0];
  990. dst++;
  991. src++;
  992. cov++;
  993. }
  994. }
  995. #endif
  996. static void blend_row_A8(SkPMColor* dst, const void* mask, const SkPMColor* src, int n) {
  997. auto cov = (const uint8_t*)mask;
  998. #ifdef SK_SUPPORT_LEGACY_A8_MASKBLITTER
  999. for (int i = 0; i < n; ++i) {
  1000. if (cov[i]) {
  1001. dst[i] = SkBlendARGB32(src[i], dst[i], cov[i]);
  1002. }
  1003. }
  1004. #else
  1005. drive(dst, src, cov, n, [](U8x4 d, U8x4 s, U8x4 c) {
  1006. U8x4 s_aa = skvx::approx_scale(s, c),
  1007. alpha = skvx::shuffle<3,3,3,3, 7,7,7,7, 11,11,11,11, 15,15,15,15>(s_aa);
  1008. return s_aa + skvx::approx_scale(d, 255 - alpha);
  1009. });
  1010. #endif
  1011. }
  1012. static void blend_row_A8_opaque(SkPMColor* dst, const void* mask, const SkPMColor* src, int n) {
  1013. auto cov = (const uint8_t*)mask;
  1014. #ifdef SK_SUPPORT_LEGACY_A8_MASKBLITTER
  1015. for (int i = 0; i < n; ++i) {
  1016. if (int c = cov[i]) {
  1017. c += (c >> 7);
  1018. dst[i] = SkAlphaMulQ(src[i], c) + SkAlphaMulQ(dst[i], 256 - c);
  1019. }
  1020. }
  1021. #else
  1022. drive(dst, src, cov, n, [](U8x4 d, U8x4 s, U8x4 c) {
  1023. return skvx::div255( skvx::cast<uint16_t>(s) * skvx::cast<uint16_t>( c )
  1024. + skvx::cast<uint16_t>(d) * skvx::cast<uint16_t>(255-c));
  1025. });
  1026. #endif
  1027. }
  1028. static void blend_row_lcd16(SkPMColor* dst, const void* vmask, const SkPMColor* src, int n) {
  1029. auto src_alpha_blend = [](int s, int d, int sa, int m) {
  1030. return d + SkAlphaMul(s - SkAlphaMul(sa, d), m);
  1031. };
  1032. auto upscale_31_to_255 = [](int v) {
  1033. return (v << 3) | (v >> 2);
  1034. };
  1035. auto mask = (const uint16_t*)vmask;
  1036. for (int i = 0; i < n; ++i) {
  1037. uint16_t m = mask[i];
  1038. if (0 == m) {
  1039. continue;
  1040. }
  1041. SkPMColor s = src[i];
  1042. SkPMColor d = dst[i];
  1043. int srcA = SkGetPackedA32(s);
  1044. int srcR = SkGetPackedR32(s);
  1045. int srcG = SkGetPackedG32(s);
  1046. int srcB = SkGetPackedB32(s);
  1047. srcA += srcA >> 7;
  1048. // We're ignoring the least significant bit of the green coverage channel here.
  1049. int maskR = SkGetPackedR16(m) >> (SK_R16_BITS - 5);
  1050. int maskG = SkGetPackedG16(m) >> (SK_G16_BITS - 5);
  1051. int maskB = SkGetPackedB16(m) >> (SK_B16_BITS - 5);
  1052. // Scale up to 8-bit coverage to work with SkAlphaMul() in src_alpha_blend().
  1053. maskR = upscale_31_to_255(maskR);
  1054. maskG = upscale_31_to_255(maskG);
  1055. maskB = upscale_31_to_255(maskB);
  1056. // This LCD blit routine only works if the destination is opaque.
  1057. dst[i] = SkPackARGB32(0xFF,
  1058. src_alpha_blend(srcR, SkGetPackedR32(d), srcA, maskR),
  1059. src_alpha_blend(srcG, SkGetPackedG32(d), srcA, maskG),
  1060. src_alpha_blend(srcB, SkGetPackedB32(d), srcA, maskB));
  1061. }
  1062. }
  1063. static void blend_row_LCD16_opaque(SkPMColor* dst, const void* vmask, const SkPMColor* src, int n) {
  1064. auto mask = (const uint16_t*)vmask;
  1065. for (int i = 0; i < n; ++i) {
  1066. uint16_t m = mask[i];
  1067. if (0 == m) {
  1068. continue;
  1069. }
  1070. SkPMColor s = src[i];
  1071. SkPMColor d = dst[i];
  1072. int srcR = SkGetPackedR32(s);
  1073. int srcG = SkGetPackedG32(s);
  1074. int srcB = SkGetPackedB32(s);
  1075. // We're ignoring the least significant bit of the green coverage channel here.
  1076. int maskR = SkGetPackedR16(m) >> (SK_R16_BITS - 5);
  1077. int maskG = SkGetPackedG16(m) >> (SK_G16_BITS - 5);
  1078. int maskB = SkGetPackedB16(m) >> (SK_B16_BITS - 5);
  1079. // Now upscale them to 0..32, so we can use blend_32.
  1080. maskR = upscale_31_to_32(maskR);
  1081. maskG = upscale_31_to_32(maskG);
  1082. maskB = upscale_31_to_32(maskB);
  1083. // This LCD blit routine only works if the destination is opaque.
  1084. dst[i] = SkPackARGB32(0xFF,
  1085. blend_32(srcR, SkGetPackedR32(d), maskR),
  1086. blend_32(srcG, SkGetPackedG32(d), maskG),
  1087. blend_32(srcB, SkGetPackedB32(d), maskB));
  1088. }
  1089. }
  1090. void SkARGB32_Shader_Blitter::blitMask(const SkMask& mask, const SkIRect& clip) {
  1091. // we only handle kA8 with an xfermode
  1092. if (fXfermode && (SkMask::kA8_Format != mask.fFormat)) {
  1093. this->INHERITED::blitMask(mask, clip);
  1094. return;
  1095. }
  1096. SkASSERT(mask.fBounds.contains(clip));
  1097. void (*blend_row)(SkPMColor*, const void* mask, const SkPMColor*, int) = nullptr;
  1098. if (!fXfermode) {
  1099. bool opaque = (fShaderContext->getFlags() & SkShaderBase::kOpaqueAlpha_Flag);
  1100. if (mask.fFormat == SkMask::kA8_Format && opaque) {
  1101. blend_row = blend_row_A8_opaque;
  1102. } else if (mask.fFormat == SkMask::kA8_Format) {
  1103. blend_row = blend_row_A8;
  1104. } else if (mask.fFormat == SkMask::kLCD16_Format && opaque) {
  1105. blend_row = blend_row_LCD16_opaque;
  1106. } else if (mask.fFormat == SkMask::kLCD16_Format) {
  1107. blend_row = blend_row_lcd16;
  1108. } else {
  1109. this->INHERITED::blitMask(mask, clip);
  1110. return;
  1111. }
  1112. }
  1113. const int x = clip.fLeft;
  1114. const int width = clip.width();
  1115. int y = clip.fTop;
  1116. int height = clip.height();
  1117. char* dstRow = (char*)fDevice.writable_addr32(x, y);
  1118. const size_t dstRB = fDevice.rowBytes();
  1119. const uint8_t* maskRow = (const uint8_t*)mask.getAddr(x, y);
  1120. const size_t maskRB = mask.fRowBytes;
  1121. SkPMColor* span = fBuffer;
  1122. if (fXfermode) {
  1123. SkASSERT(SkMask::kA8_Format == mask.fFormat);
  1124. SkXfermode* xfer = fXfermode;
  1125. do {
  1126. fShaderContext->shadeSpan(x, y, span, width);
  1127. xfer->xfer32(reinterpret_cast<SkPMColor*>(dstRow), span, width, maskRow);
  1128. dstRow += dstRB;
  1129. maskRow += maskRB;
  1130. y += 1;
  1131. } while (--height > 0);
  1132. } else {
  1133. SkASSERT(blend_row);
  1134. do {
  1135. fShaderContext->shadeSpan(x, y, span, width);
  1136. blend_row(reinterpret_cast<SkPMColor*>(dstRow), maskRow, span, width);
  1137. dstRow += dstRB;
  1138. maskRow += maskRB;
  1139. y += 1;
  1140. } while (--height > 0);
  1141. }
  1142. }
  1143. void SkARGB32_Shader_Blitter::blitV(int x, int y, int height, SkAlpha alpha) {
  1144. SkASSERT(x >= 0 && y >= 0 && y + height <= fDevice.height());
  1145. uint32_t* device = fDevice.writable_addr32(x, y);
  1146. size_t deviceRB = fDevice.rowBytes();
  1147. if (fConstInY) {
  1148. SkPMColor c;
  1149. fShaderContext->shadeSpan(x, y, &c, 1);
  1150. if (fShadeDirectlyIntoDevice) {
  1151. if (255 == alpha) {
  1152. do {
  1153. *device = c;
  1154. device = (uint32_t*)((char*)device + deviceRB);
  1155. } while (--height > 0);
  1156. } else {
  1157. do {
  1158. *device = SkFourByteInterp(c, *device, alpha);
  1159. device = (uint32_t*)((char*)device + deviceRB);
  1160. } while (--height > 0);
  1161. }
  1162. } else {
  1163. SkXfermode* xfer = fXfermode;
  1164. if (xfer) {
  1165. do {
  1166. xfer->xfer32(device, &c, 1, &alpha);
  1167. device = (uint32_t*)((char*)device + deviceRB);
  1168. } while (--height > 0);
  1169. } else {
  1170. SkBlitRow::Proc32 proc = (255 == alpha) ? fProc32 : fProc32Blend;
  1171. do {
  1172. proc(device, &c, 1, alpha);
  1173. device = (uint32_t*)((char*)device + deviceRB);
  1174. } while (--height > 0);
  1175. }
  1176. }
  1177. return;
  1178. }
  1179. if (fShadeDirectlyIntoDevice) {
  1180. if (255 == alpha) {
  1181. do {
  1182. fShaderContext->shadeSpan(x, y, device, 1);
  1183. y += 1;
  1184. device = (uint32_t*)((char*)device + deviceRB);
  1185. } while (--height > 0);
  1186. } else {
  1187. do {
  1188. SkPMColor c;
  1189. fShaderContext->shadeSpan(x, y, &c, 1);
  1190. *device = SkFourByteInterp(c, *device, alpha);
  1191. y += 1;
  1192. device = (uint32_t*)((char*)device + deviceRB);
  1193. } while (--height > 0);
  1194. }
  1195. } else {
  1196. SkPMColor* span = fBuffer;
  1197. SkXfermode* xfer = fXfermode;
  1198. if (xfer) {
  1199. do {
  1200. fShaderContext->shadeSpan(x, y, span, 1);
  1201. xfer->xfer32(device, span, 1, &alpha);
  1202. y += 1;
  1203. device = (uint32_t*)((char*)device + deviceRB);
  1204. } while (--height > 0);
  1205. } else {
  1206. SkBlitRow::Proc32 proc = (255 == alpha) ? fProc32 : fProc32Blend;
  1207. do {
  1208. fShaderContext->shadeSpan(x, y, span, 1);
  1209. proc(device, span, 1, alpha);
  1210. y += 1;
  1211. device = (uint32_t*)((char*)device + deviceRB);
  1212. } while (--height > 0);
  1213. }
  1214. }
  1215. }