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