OLD | NEW |
1 /* | 1 /* |
2 * Copyright 2015 Google Inc. | 2 * Copyright 2015 Google Inc. |
3 * | 3 * |
4 * Use of this source code is governed by a BSD-style license that can be | 4 * Use of this source code is governed by a BSD-style license that can be |
5 * found in the LICENSE file. | 5 * found in the LICENSE file. |
6 */ | 6 */ |
7 | 7 |
8 #ifndef Sk4pxXfermode_DEFINED | 8 #ifndef Sk4pxXfermode_DEFINED |
9 #define Sk4pxXfermode_DEFINED | 9 #define Sk4pxXfermode_DEFINED |
10 | 10 |
11 #include "Sk4px.h" | 11 #include "Sk4px.h" |
12 #include "SkPMFloat.h" | 12 #include "SkPMFloat.h" |
13 #include "SkXfermode_proccoeff.h" | 13 #include "SkXfermode_proccoeff.h" |
14 | 14 |
15 namespace SK_OPTS_NS { | 15 namespace SK_OPTS_NS { |
16 | 16 |
17 // Most xfermodes can be done most efficiently 4 pixels at a time in 8 or 16-bit
fixed point. | 17 // Most xfermodes can be done most efficiently 4 pixels at a time in 8 or 16-bit
fixed point. |
18 #define XFERMODE(Name) static Sk4px SK_VECTORCALL Name(Sk4px d, Sk4px s) | 18 #define XFERMODE(Name) static Sk4px SK_VECTORCALL Name(Sk4px s, Sk4px d) |
19 | 19 |
20 XFERMODE(Clear) { return Sk4px::DupPMColor(0); } | 20 XFERMODE(Clear) { return Sk4px::DupPMColor(0); } |
21 XFERMODE(Src) { return s; } | 21 XFERMODE(Src) { return s; } |
22 XFERMODE(Dst) { return d; } | 22 XFERMODE(Dst) { return d; } |
23 XFERMODE(SrcIn) { return s.approxMulDiv255(d.alphas() ); } | 23 XFERMODE(SrcIn) { return s.approxMulDiv255(d.alphas() ); } |
24 XFERMODE(SrcOut) { return s.approxMulDiv255(d.alphas().inv()); } | 24 XFERMODE(SrcOut) { return s.approxMulDiv255(d.alphas().inv()); } |
25 XFERMODE(SrcOver) { return s + d.approxMulDiv255(s.alphas().inv()); } | 25 XFERMODE(SrcOver) { return s + d.approxMulDiv255(s.alphas().inv()); } |
26 XFERMODE(DstIn) { return SrcIn (s,d); } | 26 XFERMODE(DstIn) { return SrcIn (d,s); } |
27 XFERMODE(DstOut) { return SrcOut (s,d); } | 27 XFERMODE(DstOut) { return SrcOut (d,s); } |
28 XFERMODE(DstOver) { return SrcOver(s,d); } | 28 XFERMODE(DstOver) { return SrcOver(d,s); } |
29 | 29 |
30 // [ S * Da + (1 - Sa) * D] | 30 // [ S * Da + (1 - Sa) * D] |
31 XFERMODE(SrcATop) { return (s * d.alphas() + d * s.alphas().inv()).div255(); } | 31 XFERMODE(SrcATop) { return (s * d.alphas() + d * s.alphas().inv()).div255(); } |
32 XFERMODE(DstATop) { return SrcATop(s,d); } | 32 XFERMODE(DstATop) { return SrcATop(d,s); } |
33 //[ S * (1 - Da) + (1 - Sa) * D ] | 33 //[ S * (1 - Da) + (1 - Sa) * D ] |
34 XFERMODE(Xor) { return (s * d.alphas().inv() + d * s.alphas().inv()).div255(); } | 34 XFERMODE(Xor) { return (s * d.alphas().inv() + d * s.alphas().inv()).div255(); } |
35 // [S + D ] | 35 // [S + D ] |
36 XFERMODE(Plus) { return s.saturatedAdd(d); } | 36 XFERMODE(Plus) { return s.saturatedAdd(d); } |
37 // [S * D ] | 37 // [S * D ] |
38 XFERMODE(Modulate) { return s.approxMulDiv255(d); } | 38 XFERMODE(Modulate) { return s.approxMulDiv255(d); } |
39 // [S + D - S * D] | 39 // [S + D - S * D] |
40 XFERMODE(Screen) { | 40 XFERMODE(Screen) { |
41 // Doing the math as S + (1-S)*D or S + (D - S*D) means the add and subtract
can be done | 41 // Doing the math as S + (1-S)*D or S + (D - S*D) means the add and subtract
can be done |
42 // in 8-bit space without overflow. S + (1-S)*D is a touch faster because i
nv() is cheap. | 42 // in 8-bit space without overflow. S + (1-S)*D is a touch faster because i
nv() is cheap. |
(...skipping 29 matching lines...) Expand all Loading... |
72 auto isLite = ((sa-s) < s).widenLoHi(); | 72 auto isLite = ((sa-s) < s).widenLoHi(); |
73 | 73 |
74 auto lite = sa*da - ((da-d)*(sa-s) << 1), | 74 auto lite = sa*da - ((da-d)*(sa-s) << 1), |
75 dark = s*d << 1, | 75 dark = s*d << 1, |
76 both = s*da.inv() + d*sa.inv(); | 76 both = s*da.inv() + d*sa.inv(); |
77 | 77 |
78 auto alphas = srcover; | 78 auto alphas = srcover; |
79 auto colors = (both + isLite.thenElse(lite, dark)).div255(); | 79 auto colors = (both + isLite.thenElse(lite, dark)).div255(); |
80 return alphas.zeroColors() + colors.zeroAlphas(); | 80 return alphas.zeroColors() + colors.zeroAlphas(); |
81 } | 81 } |
82 XFERMODE(Overlay) { return HardLight(s,d); } | 82 XFERMODE(Overlay) { return HardLight(d,s); } |
83 | 83 |
84 XFERMODE(Darken) { | 84 XFERMODE(Darken) { |
85 auto sa = s.alphas(), | 85 auto sa = s.alphas(), |
86 da = d.alphas(); | 86 da = d.alphas(); |
87 | 87 |
88 auto sda = (s*da).div255(), | 88 auto sda = (s*da).div255(), |
89 dsa = (d*sa).div255(); | 89 dsa = (d*sa).div255(); |
90 | 90 |
91 auto srcover = s + (d * sa.inv()).div255(), | 91 auto srcover = s + (d * sa.inv()).div255(), |
92 dstover = d + (s * da.inv()).div255(); | 92 dstover = d + (s * da.inv()).div255(); |
(...skipping 10 matching lines...) Expand all Loading... |
103 | 103 |
104 auto srcover = s + (d * sa.inv()).div255(), | 104 auto srcover = s + (d * sa.inv()).div255(), |
105 dstover = d + (s * da.inv()).div255(); | 105 dstover = d + (s * da.inv()).div255(); |
106 auto alphas = srcover, | 106 auto alphas = srcover, |
107 colors = (dsa < sda).thenElse(srcover, dstover); | 107 colors = (dsa < sda).thenElse(srcover, dstover); |
108 return alphas.zeroColors() + colors.zeroAlphas(); | 108 return alphas.zeroColors() + colors.zeroAlphas(); |
109 } | 109 } |
110 #undef XFERMODE | 110 #undef XFERMODE |
111 | 111 |
112 // Some xfermodes use math like divide or sqrt that's best done in floats 1 pixe
l at a time. | 112 // Some xfermodes use math like divide or sqrt that's best done in floats 1 pixe
l at a time. |
113 #define XFERMODE(Name) static SkPMFloat SK_VECTORCALL Name(SkPMFloat d, SkPMFloa
t s) | 113 #define XFERMODE(Name) static SkPMFloat SK_VECTORCALL Name(SkPMFloat s, SkPMFloa
t d) |
114 | 114 |
115 XFERMODE(ColorDodge) { | 115 XFERMODE(ColorDodge) { |
116 auto sa = s.alphas(), | 116 auto sa = s.alphas(), |
117 da = d.alphas(), | 117 da = d.alphas(), |
118 isa = Sk4f(1)-sa, | 118 isa = Sk4f(1)-sa, |
119 ida = Sk4f(1)-da; | 119 ida = Sk4f(1)-da; |
120 | 120 |
121 auto srcover = s + d*isa, | 121 auto srcover = s + d*isa, |
122 dstover = d + s*ida, | 122 dstover = d + s*ida, |
123 otherwise = sa * Sk4f::Min(da, (d*sa)*(sa-s).approxInvert()) + s*ida +
d*isa; | 123 otherwise = sa * Sk4f::Min(da, (d*sa)*(sa-s).approxInvert()) + s*ida +
d*isa; |
(...skipping 43 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
167 auto alpha = s + d*isa; | 167 auto alpha = s + d*isa; |
168 auto colors = s*ida + d*isa + (s2 <= sa).thenElse(darkSrc, liteSrc);
// Case 1 or 2/3? | 168 auto colors = s*ida + d*isa + (s2 <= sa).thenElse(darkSrc, liteSrc);
// Case 1 or 2/3? |
169 | 169 |
170 return alpha * SkPMFloat(1,0,0,0) + colors * SkPMFloat(0,1,1,1); | 170 return alpha * SkPMFloat(1,0,0,0) + colors * SkPMFloat(0,1,1,1); |
171 } | 171 } |
172 #undef XFERMODE | 172 #undef XFERMODE |
173 | 173 |
174 // A reasonable fallback mode for doing AA is to simply apply the transfermode f
irst, | 174 // A reasonable fallback mode for doing AA is to simply apply the transfermode f
irst, |
175 // then linearly interpolate the AA. | 175 // then linearly interpolate the AA. |
176 template <Sk4px (SK_VECTORCALL *Mode)(Sk4px, Sk4px)> | 176 template <Sk4px (SK_VECTORCALL *Mode)(Sk4px, Sk4px)> |
177 static Sk4px SK_VECTORCALL xfer_aa(Sk4px d, Sk4px s, Sk4px aa) { | 177 static Sk4px SK_VECTORCALL xfer_aa(Sk4px s, Sk4px d, Sk4px aa) { |
178 Sk4px bw = Mode(d, s); | 178 Sk4px bw = Mode(s, d); |
179 return (bw * aa + d * aa.inv()).div255(); | 179 return (bw * aa + d * aa.inv()).div255(); |
180 } | 180 } |
181 | 181 |
182 // For some transfermodes we specialize AA, either for correctness or performanc
e. | 182 // For some transfermodes we specialize AA, either for correctness or performanc
e. |
183 #define XFERMODE_AA(Name) \ | 183 #define XFERMODE_AA(Name) \ |
184 template <> Sk4px SK_VECTORCALL xfer_aa<Name>(Sk4px d, Sk4px s, Sk4px aa) | 184 template <> Sk4px SK_VECTORCALL xfer_aa<Name>(Sk4px s, Sk4px d, Sk4px aa) |
185 | 185 |
186 // Plus' clamp needs to happen after AA. skia:3852 | 186 // Plus' clamp needs to happen after AA. skia:3852 |
187 XFERMODE_AA(Plus) { // [ clamp( (1-AA)D + (AA)(S+D) ) == clamp(D + AA*S) ] | 187 XFERMODE_AA(Plus) { // [ clamp( (1-AA)D + (AA)(S+D) ) == clamp(D + AA*S) ] |
188 return d.saturatedAdd(s.approxMulDiv255(aa)); | 188 return d.saturatedAdd(s.approxMulDiv255(aa)); |
189 } | 189 } |
190 | 190 |
191 #undef XFERMODE_AA | 191 #undef XFERMODE_AA |
192 | 192 |
193 class Sk4pxXfermode : public SkProcCoeffXfermode { | 193 class Sk4pxXfermode : public SkProcCoeffXfermode { |
194 public: | 194 public: |
195 typedef Sk4px (SK_VECTORCALL *Proc4)(Sk4px, Sk4px); | 195 typedef Sk4px (SK_VECTORCALL *Proc4)(Sk4px, Sk4px); |
196 typedef Sk4px (SK_VECTORCALL *AAProc4)(Sk4px, Sk4px, Sk4px); | 196 typedef Sk4px (SK_VECTORCALL *AAProc4)(Sk4px, Sk4px, Sk4px); |
197 | 197 |
198 Sk4pxXfermode(const ProcCoeff& rec, SkXfermode::Mode mode, Proc4 proc4, AAPr
oc4 aaproc4) | 198 Sk4pxXfermode(const ProcCoeff& rec, SkXfermode::Mode mode, Proc4 proc4, AAPr
oc4 aaproc4) |
199 : INHERITED(rec, mode) | 199 : INHERITED(rec, mode) |
200 , fProc4(proc4) | 200 , fProc4(proc4) |
201 , fAAProc4(aaproc4) {} | 201 , fAAProc4(aaproc4) {} |
202 | 202 |
203 void xfer32(SkPMColor dst[], const SkPMColor src[], int n, const SkAlpha aa[
]) const override { | 203 void xfer32(SkPMColor dst[], const SkPMColor src[], int n, const SkAlpha aa[
]) const override { |
204 if (NULL == aa) { | 204 if (NULL == aa) { |
205 Sk4px::MapDstSrc(n, dst, src, fProc4); | 205 Sk4px::MapDstSrc(n, dst, src, [&](const Sk4px& dst4, const Sk4px& sr
c4) { |
| 206 return fProc4(src4, dst4); |
| 207 }); |
206 } else { | 208 } else { |
207 Sk4px::MapDstSrcAlpha(n, dst, src, aa, fAAProc4); | 209 Sk4px::MapDstSrcAlpha(n, dst, src, aa, |
| 210 [&](const Sk4px& dst4, const Sk4px& src4, const Sk4px& alpha
) { |
| 211 return fAAProc4(src4, dst4, alpha); |
| 212 }); |
208 } | 213 } |
209 } | 214 } |
210 | 215 |
211 void xfer16(uint16_t dst[], const SkPMColor src[], int n, const SkAlpha aa[]
) const override { | 216 void xfer16(uint16_t dst[], const SkPMColor src[], int n, const SkAlpha aa[]
) const override { |
212 if (NULL == aa) { | 217 if (NULL == aa) { |
213 Sk4px::MapDstSrc(n, dst, src, fProc4); | 218 Sk4px::MapDstSrc(n, dst, src, [&](const Sk4px& dst4, const Sk4px& sr
c4) { |
| 219 return fProc4(src4, dst4); |
| 220 }); |
214 } else { | 221 } else { |
215 Sk4px::MapDstSrcAlpha(n, dst, src, aa, fAAProc4); | 222 Sk4px::MapDstSrcAlpha(n, dst, src, aa, |
| 223 [&](const Sk4px& dst4, const Sk4px& src4, const Sk4px& alpha
) { |
| 224 return fAAProc4(src4, dst4, alpha); |
| 225 }); |
216 } | 226 } |
217 } | 227 } |
218 | 228 |
219 private: | 229 private: |
220 Proc4 fProc4; | 230 Proc4 fProc4; |
221 AAProc4 fAAProc4; | 231 AAProc4 fAAProc4; |
222 typedef SkProcCoeffXfermode INHERITED; | 232 typedef SkProcCoeffXfermode INHERITED; |
223 }; | 233 }; |
224 | 234 |
225 class SkPMFloatXfermode : public SkProcCoeffXfermode { | 235 class SkPMFloatXfermode : public SkProcCoeffXfermode { |
(...skipping 14 matching lines...) Expand all Loading... |
240 for (int i = 0; i < n; i++) { | 250 for (int i = 0; i < n; i++) { |
241 SkPMColor dst32 = SkPixel16ToPixel32(dst[i]); | 251 SkPMColor dst32 = SkPixel16ToPixel32(dst[i]); |
242 dst32 = aa ? this->xfer32(dst32, src[i], aa[i]) | 252 dst32 = aa ? this->xfer32(dst32, src[i], aa[i]) |
243 : this->xfer32(dst32, src[i]); | 253 : this->xfer32(dst32, src[i]); |
244 dst[i] = SkPixel32ToPixel16(dst32); | 254 dst[i] = SkPixel32ToPixel16(dst32); |
245 } | 255 } |
246 } | 256 } |
247 | 257 |
248 private: | 258 private: |
249 inline SkPMColor xfer32(SkPMColor dst, SkPMColor src) const { | 259 inline SkPMColor xfer32(SkPMColor dst, SkPMColor src) const { |
250 return fProcF(SkPMFloat(dst), SkPMFloat(src)).round(); | 260 return fProcF(SkPMFloat(src), SkPMFloat(dst)).round(); |
251 } | 261 } |
252 | 262 |
253 inline SkPMColor xfer32(SkPMColor dst, SkPMColor src, SkAlpha aa) const { | 263 inline SkPMColor xfer32(SkPMColor dst, SkPMColor src, SkAlpha aa) const { |
254 SkPMFloat s(src), | 264 SkPMFloat s(src), |
255 d(dst), | 265 d(dst), |
256 b(fProcF(d,s)); | 266 b(fProcF(s,d)); |
257 // We do aa in full float precision before going back down to bytes, bec
ause we can! | 267 // We do aa in full float precision before going back down to bytes, bec
ause we can! |
258 SkPMFloat a = Sk4f(aa) * Sk4f(1.0f/255); | 268 SkPMFloat a = Sk4f(aa) * Sk4f(1.0f/255); |
259 b = b*a + d*(Sk4f(1)-a); | 269 b = b*a + d*(Sk4f(1)-a); |
260 return b.round(); | 270 return b.round(); |
261 } | 271 } |
262 | 272 |
263 ProcF fProcF; | 273 ProcF fProcF; |
264 typedef SkProcCoeffXfermode INHERITED; | 274 typedef SkProcCoeffXfermode INHERITED; |
265 }; | 275 }; |
266 | 276 |
(...skipping 33 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
300 #undef CASE | 310 #undef CASE |
301 | 311 |
302 default: break; | 312 default: break; |
303 } | 313 } |
304 return nullptr; | 314 return nullptr; |
305 } | 315 } |
306 | 316 |
307 } // namespace SK_NS_OPTS | 317 } // namespace SK_NS_OPTS |
308 | 318 |
309 #endif//Sk4pxXfermode_DEFINED | 319 #endif//Sk4pxXfermode_DEFINED |
OLD | NEW |