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