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 { | 15 namespace { |
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 s, Sk4px d) | 18 #define XFERMODE(Name) static Sk4px SK_VECTORCALL Name(Sk4px d, Sk4px s) |
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 (d,s); } | 26 XFERMODE(DstIn) { return SrcIn (s,d); } |
27 XFERMODE(DstOut) { return SrcOut (d,s); } | 27 XFERMODE(DstOut) { return SrcOut (s,d); } |
28 XFERMODE(DstOver) { return SrcOver(d,s); } | 28 XFERMODE(DstOver) { return SrcOver(s,d); } |
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(d,s); } | 32 XFERMODE(DstATop) { return SrcATop(s,d); } |
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(d,s); } | 82 XFERMODE(Overlay) { return HardLight(s,d); } |
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 74 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 s, Sk4px d, Sk4px aa) { | 177 static Sk4px SK_VECTORCALL xfer_aa(Sk4px d, Sk4px s, Sk4px aa) { |
178 Sk4px bw = Mode(s, d); | 178 Sk4px bw = Mode(d, s); |
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 s, Sk4px d, Sk4px aa) | 184 template <> Sk4px SK_VECTORCALL xfer_aa<Name>(Sk4px d, Sk4px s, 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, [&](const Sk4px& dst4, const Sk4px& sr
c4) { | 205 Sk4px::MapDstSrc(n, dst, src, fProc4); |
206 return fProc4(src4, dst4); | |
207 }); | |
208 } else { | 206 } else { |
209 Sk4px::MapDstSrcAlpha(n, dst, src, aa, | 207 Sk4px::MapDstSrcAlpha(n, dst, src, aa, fAAProc4); |
210 [&](const Sk4px& dst4, const Sk4px& src4, const Sk4px& alpha
) { | |
211 return fAAProc4(src4, dst4, alpha); | |
212 }); | |
213 } | 208 } |
214 } | 209 } |
215 | 210 |
216 void xfer16(uint16_t dst[], const SkPMColor src[], int n, const SkAlpha aa[]
) const override { | 211 void xfer16(uint16_t dst[], const SkPMColor src[], int n, const SkAlpha aa[]
) const override { |
217 if (NULL == aa) { | 212 if (NULL == aa) { |
218 Sk4px::MapDstSrc(n, dst, src, [&](const Sk4px& dst4, const Sk4px& sr
c4) { | 213 Sk4px::MapDstSrc(n, dst, src, fProc4); |
219 return fProc4(src4, dst4); | |
220 }); | |
221 } else { | 214 } else { |
222 Sk4px::MapDstSrcAlpha(n, dst, src, aa, | 215 Sk4px::MapDstSrcAlpha(n, dst, src, aa, fAAProc4); |
223 [&](const Sk4px& dst4, const Sk4px& src4, const Sk4px& alpha
) { | |
224 return fAAProc4(src4, dst4, alpha); | |
225 }); | |
226 } | 216 } |
227 } | 217 } |
228 | 218 |
229 private: | 219 private: |
230 Proc4 fProc4; | 220 Proc4 fProc4; |
231 AAProc4 fAAProc4; | 221 AAProc4 fAAProc4; |
232 typedef SkProcCoeffXfermode INHERITED; | 222 typedef SkProcCoeffXfermode INHERITED; |
233 }; | 223 }; |
234 | 224 |
235 class SkPMFloatXfermode : public SkProcCoeffXfermode { | 225 class SkPMFloatXfermode : public SkProcCoeffXfermode { |
(...skipping 78 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
314 #undef CASE | 304 #undef CASE |
315 | 305 |
316 default: break; | 306 default: break; |
317 } | 307 } |
318 return nullptr; | 308 return nullptr; |
319 } | 309 } |
320 | 310 |
321 } // namespace SK_OPTS_NS | 311 } // namespace SK_OPTS_NS |
322 | 312 |
323 #endif//Sk4pxXfermode_DEFINED | 313 #endif//Sk4pxXfermode_DEFINED |
OLD | NEW |