Line data Source code
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>
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 :
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.
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.
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 10 : 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 10 : auto s = Sk4px::DupPMColor(SkPreMultiplyColor(color));
138 828 : 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 828 : auto left = s.approxMulDiv255(aa),
142 828 : right = d.approxMulDiv255(left.alphas().inv());
143 828 : return left + right; // This does not overflow (exhaustively checked).
144 10 : };
145 310 : while (h --> 0) {
146 150 : Sk4px::MapDstAlpha(w, dst, mask, fn);
147 150 : dst += dstRB / sizeof(*dst);
148 150 : mask += maskRB / sizeof(*mask);
149 : }
150 10 : }
151 :
152 : // As above, but made slightly simpler by requiring that color is opaque.
153 24 : 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 24 : SkASSERT(SkColorGetA(color) == 0xFF);
157 24 : auto s = Sk4px::DupPMColor(SkPreMultiplyColor(color));
158 2836 : 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 5672 : return s.approxMulDiv255(aa) + d.approxMulDiv255(aa.inv());
164 5696 : };
165 1098 : while (h --> 0) {
166 537 : Sk4px::MapDstAlpha(w, dst, mask, fn);
167 537 : dst += dstRB / sizeof(*dst);
168 537 : mask += maskRB / sizeof(*mask);
169 : }
170 24 : }
171 :
172 : // Same as _opaque, but assumes color == SK_ColorBLACK, a very common and even simpler case.
173 0 : 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 0 : 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 0 : return aa.zeroColors() + d.approxMulDiv255(aa.inv());
183 0 : };
184 0 : while (h --> 0) {
185 0 : Sk4px::MapDstAlpha(w, dst, mask, fn);
186 0 : dst += dstRB / sizeof(*dst);
187 0 : mask += maskRB / sizeof(*mask);
188 : }
189 0 : }
190 : #endif
191 :
192 34 : 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 34 : if (color == SK_ColorBLACK) {
196 0 : blit_mask_d32_a8_black(dst, dstRB, mask, maskRB, w, h);
197 34 : } else if (SkColorGetA(color) == 0xFF) {
198 24 : blit_mask_d32_a8_opaque(dst, dstRB, mask, maskRB, color, w, h);
199 : } else {
200 10 : blit_mask_d32_a8_general(dst, dstRB, mask, maskRB, color, w, h);
201 : }
202 34 : }
203 :
204 : } // SK_OPTS_NS
205 :
206 : #endif//SkBlitMask_opts_DEFINED
|
