OLD | NEW |
1 /* | 1 /* |
2 * Copyright 2006 The Android Open Source Project | 2 * Copyright 2006 The Android Open Source Project |
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 #include "SkXfermode.h" | 8 #include "SkXfermode.h" |
9 #include "SkXfermode_proccoeff.h" | 9 #include "SkXfermode_proccoeff.h" |
10 #include "SkColorPriv.h" | 10 #include "SkColorPriv.h" |
(...skipping 35 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
46 } | 46 } |
47 } | 47 } |
48 | 48 |
49 /////////////////////////////////////////////////////////////////////////////// | 49 /////////////////////////////////////////////////////////////////////////////// |
50 #include "SkNx.h" | 50 #include "SkNx.h" |
51 | 51 |
52 static Sk4f alpha(const Sk4f& color) { return Sk4f(color.kth<3>()); } | 52 static Sk4f alpha(const Sk4f& color) { return Sk4f(color.kth<3>()); } |
53 static Sk4f inv_alpha(const Sk4f& color) { return Sk4f(1 - color.kth<3>()); } | 53 static Sk4f inv_alpha(const Sk4f& color) { return Sk4f(1 - color.kth<3>()); } |
54 static Sk4f pin_1(const Sk4f& value) { return Sk4f::Min(value, Sk4f(1)); } | 54 static Sk4f pin_1(const Sk4f& value) { return Sk4f::Min(value, Sk4f(1)); } |
55 | 55 |
| 56 static Sk4f color_alpha(const Sk4f& color, float newAlpha) { |
| 57 return Sk4f(color.kth<0>(), color.kth<1>(), color.kth<2>(), newAlpha); |
| 58 } |
| 59 static Sk4f color_alpha(const Sk4f& color, const Sk4f& newAlpha) { |
| 60 return color_alpha(color, newAlpha.kth<3>()); |
| 61 } |
| 62 |
| 63 static Sk4f set_argb(float a, float r, float g, float b) { |
| 64 if (0 == SkPM4f::R) { |
| 65 return Sk4f(r, g, b, a); |
| 66 } else { |
| 67 return Sk4f(b, g, r, a); |
| 68 } |
| 69 } |
| 70 |
56 static Sk4f clear_4f(const Sk4f& s, const Sk4f& d) { return Sk4f(0); } | 71 static Sk4f clear_4f(const Sk4f& s, const Sk4f& d) { return Sk4f(0); } |
57 static Sk4f src_4f(const Sk4f& s, const Sk4f& d) { return s; } | 72 static Sk4f src_4f(const Sk4f& s, const Sk4f& d) { return s; } |
58 static Sk4f dst_4f(const Sk4f& s, const Sk4f& d) { return d; } | 73 static Sk4f dst_4f(const Sk4f& s, const Sk4f& d) { return d; } |
59 static Sk4f srcover_4f(const Sk4f& s, const Sk4f& d) { return s + inv_alpha(s)
* d; } | 74 static Sk4f srcover_4f(const Sk4f& s, const Sk4f& d) { return s + inv_alpha(s)
* d; } |
60 static Sk4f dstover_4f(const Sk4f& s, const Sk4f& d) { return d + inv_alpha(d)
* s; } | 75 static Sk4f dstover_4f(const Sk4f& s, const Sk4f& d) { return d + inv_alpha(d)
* s; } |
61 static Sk4f srcin_4f(const Sk4f& s, const Sk4f& d) { return s * alpha(d); } | 76 static Sk4f srcin_4f(const Sk4f& s, const Sk4f& d) { return s * alpha(d); } |
62 static Sk4f dstin_4f(const Sk4f& s, const Sk4f& d) { return d * alpha(s); } | 77 static Sk4f dstin_4f(const Sk4f& s, const Sk4f& d) { return d * alpha(s); } |
63 static Sk4f srcout_4f(const Sk4f& s, const Sk4f& d) { return s * inv_alpha(d);
} | 78 static Sk4f srcout_4f(const Sk4f& s, const Sk4f& d) { return s * inv_alpha(d);
} |
64 static Sk4f dstout_4f(const Sk4f& s, const Sk4f& d) { return d * inv_alpha(s);
} | 79 static Sk4f dstout_4f(const Sk4f& s, const Sk4f& d) { return d * inv_alpha(s);
} |
65 static Sk4f srcatop_4f(const Sk4f& s, const Sk4f& d) { return s * alpha(d) + d
* inv_alpha(s); } | 80 static Sk4f srcatop_4f(const Sk4f& s, const Sk4f& d) { return s * alpha(d) + d
* inv_alpha(s); } |
66 static Sk4f dstatop_4f(const Sk4f& s, const Sk4f& d) { return d * alpha(s) + s
* inv_alpha(d); } | 81 static Sk4f dstatop_4f(const Sk4f& s, const Sk4f& d) { return d * alpha(s) + s
* inv_alpha(d); } |
67 static Sk4f xor_4f(const Sk4f& s, const Sk4f& d) { return s * inv_alpha(d)
+ d * inv_alpha(s);} | 82 static Sk4f xor_4f(const Sk4f& s, const Sk4f& d) { return s * inv_alpha(d)
+ d * inv_alpha(s);} |
68 static Sk4f plus_4f(const Sk4f& s, const Sk4f& d) { return pin_1(s + d); } | 83 static Sk4f plus_4f(const Sk4f& s, const Sk4f& d) { return pin_1(s + d); } |
69 static Sk4f modulate_4f(const Sk4f& s, const Sk4f& d) { return s * d; } | 84 static Sk4f modulate_4f(const Sk4f& s, const Sk4f& d) { return s * d; } |
70 static Sk4f screen_4f(const Sk4f& s, const Sk4f& d) { return s + d - s * d; } | 85 static Sk4f screen_4f(const Sk4f& s, const Sk4f& d) { return s + d - s * d; } |
71 | 86 |
72 static Sk4f multiply_4f(const Sk4f& s, const Sk4f& d) { | 87 static Sk4f multiply_4f(const Sk4f& s, const Sk4f& d) { |
73 return s * inv_alpha(d) + d * inv_alpha(s) + s * d; | 88 return s * inv_alpha(d) + d * inv_alpha(s) + s * d; |
74 } | 89 } |
75 | 90 |
| 91 static Sk4f overlay_4f(const Sk4f& s, const Sk4f& d) { |
| 92 Sk4f sa = alpha(s); |
| 93 Sk4f da = alpha(d); |
| 94 Sk4f two = Sk4f(2); |
| 95 Sk4f rc = (two * d <= da).thenElse(two * s * d, |
| 96 sa * da - two * (da - d) * (sa - s)); |
| 97 return s + d - s * da + color_alpha(rc - d * sa, 0); |
| 98 } |
| 99 |
| 100 static Sk4f hardlight_4f(const Sk4f& s, const Sk4f& d) { |
| 101 return overlay_4f(d, s); |
| 102 } |
| 103 |
| 104 static Sk4f darken_4f(const Sk4f& s, const Sk4f& d) { |
| 105 Sk4f sa = alpha(s); |
| 106 Sk4f da = alpha(d); |
| 107 return s + d - Sk4f::Max(s * da, d * sa); |
| 108 } |
| 109 |
| 110 static Sk4f lighten_4f(const Sk4f& s, const Sk4f& d) { |
| 111 Sk4f sa = alpha(s); |
| 112 Sk4f da = alpha(d); |
| 113 return s + d - Sk4f::Min(s * da, d * sa); |
| 114 } |
| 115 |
| 116 static Sk4f colordodge_4f(const Sk4f& s, const Sk4f& d) { |
| 117 Sk4f sa = alpha(s); |
| 118 Sk4f da = alpha(d); |
| 119 Sk4f isa = Sk4f(1) - sa; |
| 120 Sk4f ida = Sk4f(1) - da; |
| 121 |
| 122 Sk4f srcover = s + d * isa; |
| 123 Sk4f dstover = d + s * ida; |
| 124 Sk4f otherwise = sa * Sk4f::Min(da, (d * sa) / (sa - s)) + s * ida + d * isa
; |
| 125 |
| 126 // Order matters here, preferring d==0 over s==sa. |
| 127 auto colors = (d == Sk4f(0)).thenElse(dstover, |
| 128 (s == sa).thenElse(srcover, |
| 129 otherwise)); |
| 130 return color_alpha(colors, srcover); |
| 131 } |
| 132 |
| 133 static Sk4f colorburn_4f(const Sk4f& s, const Sk4f& d) { |
| 134 Sk4f sa = alpha(s); |
| 135 Sk4f da = alpha(d); |
| 136 Sk4f isa = Sk4f(1) - sa; |
| 137 Sk4f ida = Sk4f(1) - da; |
| 138 |
| 139 Sk4f srcover = s + d * isa; |
| 140 Sk4f dstover = d + s * ida; |
| 141 Sk4f otherwise = sa * (da - Sk4f::Min(da, (da - d) * sa / s)) + s * ida + d
* isa; |
| 142 |
| 143 // Order matters here, preferring d==da over s==0. |
| 144 auto colors = (d == da).thenElse(dstover, |
| 145 (s == Sk4f(0)).thenElse(srcover, |
| 146 otherwise)); |
| 147 return color_alpha(colors, srcover); |
| 148 } |
| 149 |
| 150 static Sk4f softlight_4f(const Sk4f& s, const Sk4f& d) { |
| 151 Sk4f sa = alpha(s); |
| 152 Sk4f da = alpha(d); |
| 153 Sk4f isa = Sk4f(1) - sa; |
| 154 Sk4f ida = Sk4f(1) - da; |
| 155 |
| 156 // Some common terms. |
| 157 Sk4f m = (da > Sk4f(0)).thenElse(d / da, Sk4f(0)); |
| 158 Sk4f s2 = Sk4f(2) * s; |
| 159 Sk4f m4 = Sk4f(4) * m; |
| 160 |
| 161 // The logic forks three ways: |
| 162 // 1. dark src? |
| 163 // 2. light src, dark dst? |
| 164 // 3. light src, light dst? |
| 165 Sk4f darkSrc = d * (sa + (s2 - sa) * (Sk4f(1) - m)); // Used in c
ase 1. |
| 166 Sk4f darkDst = (m4 * m4 + m4) * (m - Sk4f(1)) + Sk4f(7) * m; // Used in c
ase 2. |
| 167 Sk4f liteDst = m.sqrt() - m; // Used in c
ase 3. |
| 168 Sk4f liteSrc = d * sa + da * (s2 - sa) * (Sk4f(4) * d <= da).thenElse(darkDs
t, |
| 169 liteDs
t); // Case 2 or 3? |
| 170 |
| 171 return color_alpha(s * ida + d * isa + (s2 <= sa).thenElse(darkSrc, liteSrc)
, // Case 1 or 2/3? |
| 172 s + d * isa); |
| 173 } |
| 174 |
| 175 static Sk4f difference_4f(const Sk4f& s, const Sk4f& d) { |
| 176 Sk4f min = Sk4f::Min(s * alpha(d), d * alpha(s)); |
| 177 return s + d - min - color_alpha(min, 0); |
| 178 } |
| 179 |
| 180 static Sk4f exclusion_4f(const Sk4f& s, const Sk4f& d) { |
| 181 Sk4f product = s * d; |
| 182 return s + d - product - color_alpha(product, 0); |
| 183 } |
| 184 |
| 185 //////////////////////////////////////////////////// |
| 186 |
| 187 // The CSS compositing spec introduces the following formulas: |
| 188 // (See https://dvcs.w3.org/hg/FXTF/rawfile/tip/compositing/index.html#blendingn
onseparable) |
| 189 // SkComputeLuminance is similar to this formula but it uses the new definition
from Rec. 709 |
| 190 // while PDF and CG uses the one from Rec. Rec. 601 |
| 191 // See http://www.glennchan.info/articles/technical/hd-versus-sd-color-space/hd-
versus-sd-color-space.htm |
| 192 static inline float Lum(float r, float g, float b) { |
| 193 return r * 0.2126f + g * 0.7152f + b * 0.0722f; |
| 194 } |
| 195 |
| 196 static inline float max(float a, float b, float c) { |
| 197 return SkTMax(a, SkTMax(b, c)); |
| 198 } |
| 199 |
| 200 static inline float min(float a, float b, float c) { |
| 201 return SkTMin(a, SkTMin(b, c)); |
| 202 } |
| 203 |
| 204 static inline float Sat(float r, float g, float b) { |
| 205 return max(r, g, b) - min(r, g, b); |
| 206 } |
| 207 |
| 208 static inline void setSaturationComponents(float* Cmin, float* Cmid, float* Cmax
, float s) { |
| 209 if(*Cmax > *Cmin) { |
| 210 *Cmid = (*Cmid - *Cmin) * s / (*Cmax - *Cmin); |
| 211 *Cmax = s; |
| 212 } else { |
| 213 *Cmax = 0; |
| 214 *Cmid = 0; |
| 215 } |
| 216 *Cmin = 0; |
| 217 } |
| 218 |
| 219 static inline void SetSat(float* r, float* g, float* b, float s) { |
| 220 if(*r <= *g) { |
| 221 if(*g <= *b) { |
| 222 setSaturationComponents(r, g, b, s); |
| 223 } else if(*r <= *b) { |
| 224 setSaturationComponents(r, b, g, s); |
| 225 } else { |
| 226 setSaturationComponents(b, r, g, s); |
| 227 } |
| 228 } else if(*r <= *b) { |
| 229 setSaturationComponents(g, r, b, s); |
| 230 } else if(*g <= *b) { |
| 231 setSaturationComponents(g, b, r, s); |
| 232 } else { |
| 233 setSaturationComponents(b, g, r, s); |
| 234 } |
| 235 } |
| 236 |
| 237 static inline void clipColor(float* r, float* g, float* b, float a) { |
| 238 float L = Lum(*r, *g, *b); |
| 239 float n = min(*r, *g, *b); |
| 240 float x = max(*r, *g, *b); |
| 241 float denom; |
| 242 if ((n < 0) && (denom = L - n)) { // Compute denom and make sure it's non ze
ro |
| 243 float scale = L / denom; |
| 244 *r = L + (*r - L) * scale; |
| 245 *g = L + (*g - L) * scale; |
| 246 *b = L + (*b - L) * scale; |
| 247 } |
| 248 |
| 249 if ((x > a) && (denom = x - L)) { // Compute denom and make sure it's non ze
ro |
| 250 float scale = (a - L) / denom; |
| 251 *r = L + (*r - L) * scale; |
| 252 *g = L + (*g - L) * scale; |
| 253 *b = L + (*b - L) * scale; |
| 254 } |
| 255 } |
| 256 |
| 257 static inline void SetLum(float* r, float* g, float* b, float a, float l) { |
| 258 float d = l - Lum(*r, *g, *b); |
| 259 *r += d; |
| 260 *g += d; |
| 261 *b += d; |
| 262 clipColor(r, g, b, a); |
| 263 } |
| 264 |
| 265 static Sk4f hue_4f(const Sk4f& s, const Sk4f& d) { |
| 266 float sa = s.kth<SkPM4f::A>(); |
| 267 float sr = s.kth<SkPM4f::R>(); |
| 268 float sg = s.kth<SkPM4f::G>(); |
| 269 float sb = s.kth<SkPM4f::B>(); |
| 270 |
| 271 float da = d.kth<SkPM4f::A>(); |
| 272 float dr = d.kth<SkPM4f::R>(); |
| 273 float dg = d.kth<SkPM4f::G>(); |
| 274 float db = d.kth<SkPM4f::B>(); |
| 275 |
| 276 float Sr = sr; |
| 277 float Sg = sg; |
| 278 float Sb = sb; |
| 279 SetSat(&Sr, &Sg, &Sb, Sat(dr, dg, db) * sa); |
| 280 SetLum(&Sr, &Sg, &Sb, sa * da, Lum(dr, dg, db) * sa); |
| 281 |
| 282 return color_alpha(s * inv_alpha(d) + d * inv_alpha(s) + set_argb(0, Sr, Sg,
Sb), |
| 283 sa + da - sa * da); |
| 284 } |
| 285 |
| 286 static Sk4f saturation_4f(const Sk4f& s, const Sk4f& d) { |
| 287 float sa = s.kth<SkPM4f::A>(); |
| 288 float sr = s.kth<SkPM4f::R>(); |
| 289 float sg = s.kth<SkPM4f::G>(); |
| 290 float sb = s.kth<SkPM4f::B>(); |
| 291 |
| 292 float da = d.kth<SkPM4f::A>(); |
| 293 float dr = d.kth<SkPM4f::R>(); |
| 294 float dg = d.kth<SkPM4f::G>(); |
| 295 float db = d.kth<SkPM4f::B>(); |
| 296 |
| 297 float Dr = dr; |
| 298 float Dg = dg; |
| 299 float Db = db; |
| 300 SetSat(&Dr, &Dg, &Db, Sat(sr, sg, sb) * da); |
| 301 SetLum(&Dr, &Dg, &Db, sa * da, Lum(dr, dg, db) * sa); |
| 302 |
| 303 return color_alpha(s * inv_alpha(d) + d * inv_alpha(s) + set_argb(0, Dr, Dg,
Db), |
| 304 sa + da - sa * da); |
| 305 } |
| 306 |
| 307 static Sk4f color_4f(const Sk4f& s, const Sk4f& d) { |
| 308 float sa = s.kth<SkPM4f::A>(); |
| 309 float sr = s.kth<SkPM4f::R>(); |
| 310 float sg = s.kth<SkPM4f::G>(); |
| 311 float sb = s.kth<SkPM4f::B>(); |
| 312 |
| 313 float da = d.kth<SkPM4f::A>(); |
| 314 float dr = d.kth<SkPM4f::R>(); |
| 315 float dg = d.kth<SkPM4f::G>(); |
| 316 float db = d.kth<SkPM4f::B>(); |
| 317 |
| 318 float Sr = sr; |
| 319 float Sg = sg; |
| 320 float Sb = sb; |
| 321 SetLum(&Sr, &Sg, &Sb, sa * da, Lum(dr, dg, db) * sa); |
| 322 |
| 323 return color_alpha(s * inv_alpha(d) + d * inv_alpha(s) + set_argb(0, Sr, Sg,
Sb), |
| 324 sa + da - sa * da); |
| 325 } |
| 326 |
| 327 static Sk4f luminosity_4f(const Sk4f& s, const Sk4f& d) { |
| 328 float sa = s.kth<SkPM4f::A>(); |
| 329 float sr = s.kth<SkPM4f::R>(); |
| 330 float sg = s.kth<SkPM4f::G>(); |
| 331 float sb = s.kth<SkPM4f::B>(); |
| 332 |
| 333 float da = d.kth<SkPM4f::A>(); |
| 334 float dr = d.kth<SkPM4f::R>(); |
| 335 float dg = d.kth<SkPM4f::G>(); |
| 336 float db = d.kth<SkPM4f::B>(); |
| 337 |
| 338 float Dr = dr; |
| 339 float Dg = dg; |
| 340 float Db = db; |
| 341 SetLum(&Dr, &Dg, &Db, sa * da, Lum(sr, sg, sb) * da); |
| 342 |
| 343 return color_alpha(s * inv_alpha(d) + d * inv_alpha(s) + set_argb(0, Dr, Dg,
Db), |
| 344 sa + da - sa * da); |
| 345 } |
| 346 |
76 /////////////////////////////////////////////////////////////////////////////// | 347 /////////////////////////////////////////////////////////////////////////////// |
77 | 348 |
78 static SkPM4f as_pm4f(const Sk4f& x) { | |
79 SkPM4f pm4; | |
80 x.store(pm4.fVec); | |
81 return pm4; | |
82 } | |
83 | |
84 static Sk4f as_4f(const SkPM4f& pm4) { | |
85 return Sk4f::Load(pm4.fVec); | |
86 } | |
87 | |
88 template <Sk4f (blend)(const Sk4f&, const Sk4f&)> | |
89 SkPM4f proc_4f(const SkPM4f& src, const SkPM4f& dst) { | |
90 return as_pm4f(blend(as_4f(src), as_4f(dst))); | |
91 } | |
92 | |
93 /////////////////////////////////////////////////////////////////////////////// | |
94 | |
95 static SkPM4f not_implemented_yet_proc4f(const SkPM4f& src, const SkPM4f& dst) { | |
96 return {{ 0.5f, 1.0f, 0.25f, 0.5f }}; | |
97 } | |
98 | |
99 // kClear_Mode, //!< [0, 0] | 349 // kClear_Mode, //!< [0, 0] |
100 static SkPMColor clear_modeproc(SkPMColor src, SkPMColor dst) { | 350 static SkPMColor clear_modeproc(SkPMColor src, SkPMColor dst) { |
101 return 0; | 351 return 0; |
102 } | 352 } |
103 | 353 |
104 // kSrc_Mode, //!< [Sa, Sc] | 354 // kSrc_Mode, //!< [Sa, Sc] |
105 static SkPMColor src_modeproc(SkPMColor src, SkPMColor dst) { | 355 static SkPMColor src_modeproc(SkPMColor src, SkPMColor dst) { |
106 return src; | 356 return src; |
107 } | 357 } |
108 | 358 |
(...skipping 151 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
260 } | 510 } |
261 static SkPMColor overlay_modeproc(SkPMColor src, SkPMColor dst) { | 511 static SkPMColor overlay_modeproc(SkPMColor src, SkPMColor dst) { |
262 int sa = SkGetPackedA32(src); | 512 int sa = SkGetPackedA32(src); |
263 int da = SkGetPackedA32(dst); | 513 int da = SkGetPackedA32(dst); |
264 int a = srcover_byte(sa, da); | 514 int a = srcover_byte(sa, da); |
265 int r = overlay_byte(SkGetPackedR32(src), SkGetPackedR32(dst), sa, da); | 515 int r = overlay_byte(SkGetPackedR32(src), SkGetPackedR32(dst), sa, da); |
266 int g = overlay_byte(SkGetPackedG32(src), SkGetPackedG32(dst), sa, da); | 516 int g = overlay_byte(SkGetPackedG32(src), SkGetPackedG32(dst), sa, da); |
267 int b = overlay_byte(SkGetPackedB32(src), SkGetPackedB32(dst), sa, da); | 517 int b = overlay_byte(SkGetPackedB32(src), SkGetPackedB32(dst), sa, da); |
268 return SkPackARGB32(a, r, g, b); | 518 return SkPackARGB32(a, r, g, b); |
269 } | 519 } |
270 static SkPM4f overlay_proc4f(const SkPM4f& src, const SkPM4f& dst) { | |
271 return not_implemented_yet_proc4f(src, dst); | |
272 } | |
273 | 520 |
274 // kDarken_Mode | 521 // kDarken_Mode |
275 static inline int darken_byte(int sc, int dc, int sa, int da) { | 522 static inline int darken_byte(int sc, int dc, int sa, int da) { |
276 int sd = sc * da; | 523 int sd = sc * da; |
277 int ds = dc * sa; | 524 int ds = dc * sa; |
278 if (sd < ds) { | 525 if (sd < ds) { |
279 // srcover | 526 // srcover |
280 return sc + dc - SkDiv255Round(ds); | 527 return sc + dc - SkDiv255Round(ds); |
281 } else { | 528 } else { |
282 // dstover | 529 // dstover |
283 return dc + sc - SkDiv255Round(sd); | 530 return dc + sc - SkDiv255Round(sd); |
284 } | 531 } |
285 } | 532 } |
286 static SkPMColor darken_modeproc(SkPMColor src, SkPMColor dst) { | 533 static SkPMColor darken_modeproc(SkPMColor src, SkPMColor dst) { |
287 int sa = SkGetPackedA32(src); | 534 int sa = SkGetPackedA32(src); |
288 int da = SkGetPackedA32(dst); | 535 int da = SkGetPackedA32(dst); |
289 int a = srcover_byte(sa, da); | 536 int a = srcover_byte(sa, da); |
290 int r = darken_byte(SkGetPackedR32(src), SkGetPackedR32(dst), sa, da); | 537 int r = darken_byte(SkGetPackedR32(src), SkGetPackedR32(dst), sa, da); |
291 int g = darken_byte(SkGetPackedG32(src), SkGetPackedG32(dst), sa, da); | 538 int g = darken_byte(SkGetPackedG32(src), SkGetPackedG32(dst), sa, da); |
292 int b = darken_byte(SkGetPackedB32(src), SkGetPackedB32(dst), sa, da); | 539 int b = darken_byte(SkGetPackedB32(src), SkGetPackedB32(dst), sa, da); |
293 return SkPackARGB32(a, r, g, b); | 540 return SkPackARGB32(a, r, g, b); |
294 } | 541 } |
295 static SkPM4f darken_proc4f(const SkPM4f& src, const SkPM4f& dst) { | |
296 return not_implemented_yet_proc4f(src, dst); | |
297 } | |
298 | 542 |
299 // kLighten_Mode | 543 // kLighten_Mode |
300 static inline int lighten_byte(int sc, int dc, int sa, int da) { | 544 static inline int lighten_byte(int sc, int dc, int sa, int da) { |
301 int sd = sc * da; | 545 int sd = sc * da; |
302 int ds = dc * sa; | 546 int ds = dc * sa; |
303 if (sd > ds) { | 547 if (sd > ds) { |
304 // srcover | 548 // srcover |
305 return sc + dc - SkDiv255Round(ds); | 549 return sc + dc - SkDiv255Round(ds); |
306 } else { | 550 } else { |
307 // dstover | 551 // dstover |
308 return dc + sc - SkDiv255Round(sd); | 552 return dc + sc - SkDiv255Round(sd); |
309 } | 553 } |
310 } | 554 } |
311 static SkPMColor lighten_modeproc(SkPMColor src, SkPMColor dst) { | 555 static SkPMColor lighten_modeproc(SkPMColor src, SkPMColor dst) { |
312 int sa = SkGetPackedA32(src); | 556 int sa = SkGetPackedA32(src); |
313 int da = SkGetPackedA32(dst); | 557 int da = SkGetPackedA32(dst); |
314 int a = srcover_byte(sa, da); | 558 int a = srcover_byte(sa, da); |
315 int r = lighten_byte(SkGetPackedR32(src), SkGetPackedR32(dst), sa, da); | 559 int r = lighten_byte(SkGetPackedR32(src), SkGetPackedR32(dst), sa, da); |
316 int g = lighten_byte(SkGetPackedG32(src), SkGetPackedG32(dst), sa, da); | 560 int g = lighten_byte(SkGetPackedG32(src), SkGetPackedG32(dst), sa, da); |
317 int b = lighten_byte(SkGetPackedB32(src), SkGetPackedB32(dst), sa, da); | 561 int b = lighten_byte(SkGetPackedB32(src), SkGetPackedB32(dst), sa, da); |
318 return SkPackARGB32(a, r, g, b); | 562 return SkPackARGB32(a, r, g, b); |
319 } | 563 } |
320 static SkPM4f lighten_proc4f(const SkPM4f& src, const SkPM4f& dst) { | |
321 return not_implemented_yet_proc4f(src, dst); | |
322 } | |
323 | 564 |
324 // kColorDodge_Mode | 565 // kColorDodge_Mode |
325 static inline int colordodge_byte(int sc, int dc, int sa, int da) { | 566 static inline int colordodge_byte(int sc, int dc, int sa, int da) { |
326 int diff = sa - sc; | 567 int diff = sa - sc; |
327 int rc; | 568 int rc; |
328 if (0 == dc) { | 569 if (0 == dc) { |
329 return SkAlphaMulAlpha(sc, 255 - da); | 570 return SkAlphaMulAlpha(sc, 255 - da); |
330 } else if (0 == diff) { | 571 } else if (0 == diff) { |
331 rc = sa * da + sc * (255 - da) + dc * (255 - sa); | 572 rc = sa * da + sc * (255 - da) + dc * (255 - sa); |
332 } else { | 573 } else { |
333 diff = dc * sa / diff; | 574 diff = dc * sa / diff; |
334 rc = sa * ((da < diff) ? da : diff) + sc * (255 - da) + dc * (255 - sa); | 575 rc = sa * ((da < diff) ? da : diff) + sc * (255 - da) + dc * (255 - sa); |
335 } | 576 } |
336 return clamp_div255round(rc); | 577 return clamp_div255round(rc); |
337 } | 578 } |
338 static SkPMColor colordodge_modeproc(SkPMColor src, SkPMColor dst) { | 579 static SkPMColor colordodge_modeproc(SkPMColor src, SkPMColor dst) { |
339 int sa = SkGetPackedA32(src); | 580 int sa = SkGetPackedA32(src); |
340 int da = SkGetPackedA32(dst); | 581 int da = SkGetPackedA32(dst); |
341 int a = srcover_byte(sa, da); | 582 int a = srcover_byte(sa, da); |
342 int r = colordodge_byte(SkGetPackedR32(src), SkGetPackedR32(dst), sa, da); | 583 int r = colordodge_byte(SkGetPackedR32(src), SkGetPackedR32(dst), sa, da); |
343 int g = colordodge_byte(SkGetPackedG32(src), SkGetPackedG32(dst), sa, da); | 584 int g = colordodge_byte(SkGetPackedG32(src), SkGetPackedG32(dst), sa, da); |
344 int b = colordodge_byte(SkGetPackedB32(src), SkGetPackedB32(dst), sa, da); | 585 int b = colordodge_byte(SkGetPackedB32(src), SkGetPackedB32(dst), sa, da); |
345 return SkPackARGB32(a, r, g, b); | 586 return SkPackARGB32(a, r, g, b); |
346 } | 587 } |
347 static SkPM4f colordodge_proc4f(const SkPM4f& src, const SkPM4f& dst) { | |
348 return not_implemented_yet_proc4f(src, dst); | |
349 } | |
350 | 588 |
351 // kColorBurn_Mode | 589 // kColorBurn_Mode |
352 static inline int colorburn_byte(int sc, int dc, int sa, int da) { | 590 static inline int colorburn_byte(int sc, int dc, int sa, int da) { |
353 int rc; | 591 int rc; |
354 if (dc == da) { | 592 if (dc == da) { |
355 rc = sa * da + sc * (255 - da) + dc * (255 - sa); | 593 rc = sa * da + sc * (255 - da) + dc * (255 - sa); |
356 } else if (0 == sc) { | 594 } else if (0 == sc) { |
357 return SkAlphaMulAlpha(dc, 255 - sa); | 595 return SkAlphaMulAlpha(dc, 255 - sa); |
358 } else { | 596 } else { |
359 int tmp = (da - dc) * sa / sc; | 597 int tmp = (da - dc) * sa / sc; |
360 rc = sa * (da - ((da < tmp) ? da : tmp)) | 598 rc = sa * (da - ((da < tmp) ? da : tmp)) |
361 + sc * (255 - da) + dc * (255 - sa); | 599 + sc * (255 - da) + dc * (255 - sa); |
362 } | 600 } |
363 return clamp_div255round(rc); | 601 return clamp_div255round(rc); |
364 } | 602 } |
365 static SkPMColor colorburn_modeproc(SkPMColor src, SkPMColor dst) { | 603 static SkPMColor colorburn_modeproc(SkPMColor src, SkPMColor dst) { |
366 int sa = SkGetPackedA32(src); | 604 int sa = SkGetPackedA32(src); |
367 int da = SkGetPackedA32(dst); | 605 int da = SkGetPackedA32(dst); |
368 int a = srcover_byte(sa, da); | 606 int a = srcover_byte(sa, da); |
369 int r = colorburn_byte(SkGetPackedR32(src), SkGetPackedR32(dst), sa, da); | 607 int r = colorburn_byte(SkGetPackedR32(src), SkGetPackedR32(dst), sa, da); |
370 int g = colorburn_byte(SkGetPackedG32(src), SkGetPackedG32(dst), sa, da); | 608 int g = colorburn_byte(SkGetPackedG32(src), SkGetPackedG32(dst), sa, da); |
371 int b = colorburn_byte(SkGetPackedB32(src), SkGetPackedB32(dst), sa, da); | 609 int b = colorburn_byte(SkGetPackedB32(src), SkGetPackedB32(dst), sa, da); |
372 return SkPackARGB32(a, r, g, b); | 610 return SkPackARGB32(a, r, g, b); |
373 } | 611 } |
374 static SkPM4f colorburn_proc4f(const SkPM4f& src, const SkPM4f& dst) { | |
375 return not_implemented_yet_proc4f(src, dst); | |
376 } | |
377 | 612 |
378 // kHardLight_Mode | 613 // kHardLight_Mode |
379 static inline int hardlight_byte(int sc, int dc, int sa, int da) { | 614 static inline int hardlight_byte(int sc, int dc, int sa, int da) { |
380 int rc; | 615 int rc; |
381 if (2 * sc <= sa) { | 616 if (2 * sc <= sa) { |
382 rc = 2 * sc * dc; | 617 rc = 2 * sc * dc; |
383 } else { | 618 } else { |
384 rc = sa * da - 2 * (da - dc) * (sa - sc); | 619 rc = sa * da - 2 * (da - dc) * (sa - sc); |
385 } | 620 } |
386 return clamp_div255round(rc + sc * (255 - da) + dc * (255 - sa)); | 621 return clamp_div255round(rc + sc * (255 - da) + dc * (255 - sa)); |
387 } | 622 } |
388 static SkPMColor hardlight_modeproc(SkPMColor src, SkPMColor dst) { | 623 static SkPMColor hardlight_modeproc(SkPMColor src, SkPMColor dst) { |
389 int sa = SkGetPackedA32(src); | 624 int sa = SkGetPackedA32(src); |
390 int da = SkGetPackedA32(dst); | 625 int da = SkGetPackedA32(dst); |
391 int a = srcover_byte(sa, da); | 626 int a = srcover_byte(sa, da); |
392 int r = hardlight_byte(SkGetPackedR32(src), SkGetPackedR32(dst), sa, da); | 627 int r = hardlight_byte(SkGetPackedR32(src), SkGetPackedR32(dst), sa, da); |
393 int g = hardlight_byte(SkGetPackedG32(src), SkGetPackedG32(dst), sa, da); | 628 int g = hardlight_byte(SkGetPackedG32(src), SkGetPackedG32(dst), sa, da); |
394 int b = hardlight_byte(SkGetPackedB32(src), SkGetPackedB32(dst), sa, da); | 629 int b = hardlight_byte(SkGetPackedB32(src), SkGetPackedB32(dst), sa, da); |
395 return SkPackARGB32(a, r, g, b); | 630 return SkPackARGB32(a, r, g, b); |
396 } | 631 } |
397 static SkPM4f hardlight_proc4f(const SkPM4f& src, const SkPM4f& dst) { | |
398 return not_implemented_yet_proc4f(src, dst); | |
399 } | |
400 | 632 |
401 // returns 255 * sqrt(n/255) | 633 // returns 255 * sqrt(n/255) |
402 static U8CPU sqrt_unit_byte(U8CPU n) { | 634 static U8CPU sqrt_unit_byte(U8CPU n) { |
403 return SkSqrtBits(n, 15+4); | 635 return SkSqrtBits(n, 15+4); |
404 } | 636 } |
405 | 637 |
406 // kSoftLight_Mode | 638 // kSoftLight_Mode |
407 static inline int softlight_byte(int sc, int dc, int sa, int da) { | 639 static inline int softlight_byte(int sc, int dc, int sa, int da) { |
408 int m = da ? dc * 256 / da : 0; | 640 int m = da ? dc * 256 / da : 0; |
409 int rc; | 641 int rc; |
(...skipping 10 matching lines...) Expand all Loading... |
420 } | 652 } |
421 static SkPMColor softlight_modeproc(SkPMColor src, SkPMColor dst) { | 653 static SkPMColor softlight_modeproc(SkPMColor src, SkPMColor dst) { |
422 int sa = SkGetPackedA32(src); | 654 int sa = SkGetPackedA32(src); |
423 int da = SkGetPackedA32(dst); | 655 int da = SkGetPackedA32(dst); |
424 int a = srcover_byte(sa, da); | 656 int a = srcover_byte(sa, da); |
425 int r = softlight_byte(SkGetPackedR32(src), SkGetPackedR32(dst), sa, da); | 657 int r = softlight_byte(SkGetPackedR32(src), SkGetPackedR32(dst), sa, da); |
426 int g = softlight_byte(SkGetPackedG32(src), SkGetPackedG32(dst), sa, da); | 658 int g = softlight_byte(SkGetPackedG32(src), SkGetPackedG32(dst), sa, da); |
427 int b = softlight_byte(SkGetPackedB32(src), SkGetPackedB32(dst), sa, da); | 659 int b = softlight_byte(SkGetPackedB32(src), SkGetPackedB32(dst), sa, da); |
428 return SkPackARGB32(a, r, g, b); | 660 return SkPackARGB32(a, r, g, b); |
429 } | 661 } |
430 static SkPM4f softlight_proc4f(const SkPM4f& src, const SkPM4f& dst) { | |
431 return not_implemented_yet_proc4f(src, dst); | |
432 } | |
433 | 662 |
434 // kDifference_Mode | 663 // kDifference_Mode |
435 static inline int difference_byte(int sc, int dc, int sa, int da) { | 664 static inline int difference_byte(int sc, int dc, int sa, int da) { |
436 int tmp = SkMin32(sc * da, dc * sa); | 665 int tmp = SkMin32(sc * da, dc * sa); |
437 return clamp_signed_byte(sc + dc - 2 * SkDiv255Round(tmp)); | 666 return clamp_signed_byte(sc + dc - 2 * SkDiv255Round(tmp)); |
438 } | 667 } |
439 static SkPMColor difference_modeproc(SkPMColor src, SkPMColor dst) { | 668 static SkPMColor difference_modeproc(SkPMColor src, SkPMColor dst) { |
440 int sa = SkGetPackedA32(src); | 669 int sa = SkGetPackedA32(src); |
441 int da = SkGetPackedA32(dst); | 670 int da = SkGetPackedA32(dst); |
442 int a = srcover_byte(sa, da); | 671 int a = srcover_byte(sa, da); |
443 int r = difference_byte(SkGetPackedR32(src), SkGetPackedR32(dst), sa, da); | 672 int r = difference_byte(SkGetPackedR32(src), SkGetPackedR32(dst), sa, da); |
444 int g = difference_byte(SkGetPackedG32(src), SkGetPackedG32(dst), sa, da); | 673 int g = difference_byte(SkGetPackedG32(src), SkGetPackedG32(dst), sa, da); |
445 int b = difference_byte(SkGetPackedB32(src), SkGetPackedB32(dst), sa, da); | 674 int b = difference_byte(SkGetPackedB32(src), SkGetPackedB32(dst), sa, da); |
446 return SkPackARGB32(a, r, g, b); | 675 return SkPackARGB32(a, r, g, b); |
447 } | 676 } |
448 static SkPM4f difference_proc4f(const SkPM4f& src, const SkPM4f& dst) { | |
449 return not_implemented_yet_proc4f(src, dst); | |
450 } | |
451 | 677 |
452 // kExclusion_Mode | 678 // kExclusion_Mode |
453 static inline int exclusion_byte(int sc, int dc, int, int) { | 679 static inline int exclusion_byte(int sc, int dc, int, int) { |
454 // this equations is wacky, wait for SVG to confirm it | 680 // this equations is wacky, wait for SVG to confirm it |
455 //int r = sc * da + dc * sa - 2 * sc * dc + sc * (255 - da) + dc * (255 - sa
); | 681 //int r = sc * da + dc * sa - 2 * sc * dc + sc * (255 - da) + dc * (255 - sa
); |
456 | 682 |
457 // The above equation can be simplified as follows | 683 // The above equation can be simplified as follows |
458 int r = 255*(sc + dc) - 2 * sc * dc; | 684 int r = 255*(sc + dc) - 2 * sc * dc; |
459 return clamp_div255round(r); | 685 return clamp_div255round(r); |
460 } | 686 } |
461 static SkPMColor exclusion_modeproc(SkPMColor src, SkPMColor dst) { | 687 static SkPMColor exclusion_modeproc(SkPMColor src, SkPMColor dst) { |
462 int sa = SkGetPackedA32(src); | 688 int sa = SkGetPackedA32(src); |
463 int da = SkGetPackedA32(dst); | 689 int da = SkGetPackedA32(dst); |
464 int a = srcover_byte(sa, da); | 690 int a = srcover_byte(sa, da); |
465 int r = exclusion_byte(SkGetPackedR32(src), SkGetPackedR32(dst), sa, da); | 691 int r = exclusion_byte(SkGetPackedR32(src), SkGetPackedR32(dst), sa, da); |
466 int g = exclusion_byte(SkGetPackedG32(src), SkGetPackedG32(dst), sa, da); | 692 int g = exclusion_byte(SkGetPackedG32(src), SkGetPackedG32(dst), sa, da); |
467 int b = exclusion_byte(SkGetPackedB32(src), SkGetPackedB32(dst), sa, da); | 693 int b = exclusion_byte(SkGetPackedB32(src), SkGetPackedB32(dst), sa, da); |
468 return SkPackARGB32(a, r, g, b); | 694 return SkPackARGB32(a, r, g, b); |
469 } | 695 } |
470 static SkPM4f exclusion_proc4f(const SkPM4f& src, const SkPM4f& dst) { | |
471 return not_implemented_yet_proc4f(src, dst); | |
472 } | |
473 | 696 |
474 // The CSS compositing spec introduces the following formulas: | 697 // The CSS compositing spec introduces the following formulas: |
475 // (See https://dvcs.w3.org/hg/FXTF/rawfile/tip/compositing/index.html#blendingn
onseparable) | 698 // (See https://dvcs.w3.org/hg/FXTF/rawfile/tip/compositing/index.html#blendingn
onseparable) |
476 // SkComputeLuminance is similar to this formula but it uses the new definition
from Rec. 709 | 699 // SkComputeLuminance is similar to this formula but it uses the new definition
from Rec. 709 |
477 // while PDF and CG uses the one from Rec. Rec. 601 | 700 // while PDF and CG uses the one from Rec. Rec. 601 |
478 // See http://www.glennchan.info/articles/technical/hd-versus-sd-color-space/hd-
versus-sd-color-space.htm | 701 // See http://www.glennchan.info/articles/technical/hd-versus-sd-color-space/hd-
versus-sd-color-space.htm |
479 static inline int Lum(int r, int g, int b) | 702 static inline int Lum(int r, int g, int b) |
480 { | 703 { |
481 return SkDiv255Round(r * 77 + g * 150 + b * 28); | 704 return SkDiv255Round(r * 77 + g * 150 + b * 28); |
482 } | 705 } |
(...skipping 95 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
578 Sg = 0; | 801 Sg = 0; |
579 Sb = 0; | 802 Sb = 0; |
580 } | 803 } |
581 | 804 |
582 int a = srcover_byte(sa, da); | 805 int a = srcover_byte(sa, da); |
583 int r = blendfunc_nonsep_byte(sr, dr, sa, da, Sr); | 806 int r = blendfunc_nonsep_byte(sr, dr, sa, da, Sr); |
584 int g = blendfunc_nonsep_byte(sg, dg, sa, da, Sg); | 807 int g = blendfunc_nonsep_byte(sg, dg, sa, da, Sg); |
585 int b = blendfunc_nonsep_byte(sb, db, sa, da, Sb); | 808 int b = blendfunc_nonsep_byte(sb, db, sa, da, Sb); |
586 return SkPackARGB32(a, r, g, b); | 809 return SkPackARGB32(a, r, g, b); |
587 } | 810 } |
588 static SkPM4f hue_proc4f(const SkPM4f& src, const SkPM4f& dst) { | |
589 return not_implemented_yet_proc4f(src, dst); | |
590 } | |
591 | 811 |
592 // kSaturation_Mode | 812 // kSaturation_Mode |
593 // B(Cb, Cs) = SetLum(SetSat(Cb, Sat(Cs)), Lum(Cb)) | 813 // B(Cb, Cs) = SetLum(SetSat(Cb, Sat(Cs)), Lum(Cb)) |
594 // Create a color with the saturation of the source color and the hue and lumino
sity of the backdrop color. | 814 // Create a color with the saturation of the source color and the hue and lumino
sity of the backdrop color. |
595 static SkPMColor saturation_modeproc(SkPMColor src, SkPMColor dst) { | 815 static SkPMColor saturation_modeproc(SkPMColor src, SkPMColor dst) { |
596 int sr = SkGetPackedR32(src); | 816 int sr = SkGetPackedR32(src); |
597 int sg = SkGetPackedG32(src); | 817 int sg = SkGetPackedG32(src); |
598 int sb = SkGetPackedB32(src); | 818 int sb = SkGetPackedB32(src); |
599 int sa = SkGetPackedA32(src); | 819 int sa = SkGetPackedA32(src); |
600 | 820 |
(...skipping 14 matching lines...) Expand all Loading... |
615 Dg = 0; | 835 Dg = 0; |
616 Db = 0; | 836 Db = 0; |
617 } | 837 } |
618 | 838 |
619 int a = srcover_byte(sa, da); | 839 int a = srcover_byte(sa, da); |
620 int r = blendfunc_nonsep_byte(sr, dr, sa, da, Dr); | 840 int r = blendfunc_nonsep_byte(sr, dr, sa, da, Dr); |
621 int g = blendfunc_nonsep_byte(sg, dg, sa, da, Dg); | 841 int g = blendfunc_nonsep_byte(sg, dg, sa, da, Dg); |
622 int b = blendfunc_nonsep_byte(sb, db, sa, da, Db); | 842 int b = blendfunc_nonsep_byte(sb, db, sa, da, Db); |
623 return SkPackARGB32(a, r, g, b); | 843 return SkPackARGB32(a, r, g, b); |
624 } | 844 } |
625 static SkPM4f saturation_proc4f(const SkPM4f& src, const SkPM4f& dst) { | |
626 return not_implemented_yet_proc4f(src, dst); | |
627 } | |
628 | 845 |
629 // kColor_Mode | 846 // kColor_Mode |
630 // B(Cb, Cs) = SetLum(Cs, Lum(Cb)) | 847 // B(Cb, Cs) = SetLum(Cs, Lum(Cb)) |
631 // Create a color with the hue and saturation of the source color and the lumino
sity of the backdrop color. | 848 // Create a color with the hue and saturation of the source color and the lumino
sity of the backdrop color. |
632 static SkPMColor color_modeproc(SkPMColor src, SkPMColor dst) { | 849 static SkPMColor color_modeproc(SkPMColor src, SkPMColor dst) { |
633 int sr = SkGetPackedR32(src); | 850 int sr = SkGetPackedR32(src); |
634 int sg = SkGetPackedG32(src); | 851 int sg = SkGetPackedG32(src); |
635 int sb = SkGetPackedB32(src); | 852 int sb = SkGetPackedB32(src); |
636 int sa = SkGetPackedA32(src); | 853 int sa = SkGetPackedA32(src); |
637 | 854 |
(...skipping 13 matching lines...) Expand all Loading... |
651 Sg = 0; | 868 Sg = 0; |
652 Sb = 0; | 869 Sb = 0; |
653 } | 870 } |
654 | 871 |
655 int a = srcover_byte(sa, da); | 872 int a = srcover_byte(sa, da); |
656 int r = blendfunc_nonsep_byte(sr, dr, sa, da, Sr); | 873 int r = blendfunc_nonsep_byte(sr, dr, sa, da, Sr); |
657 int g = blendfunc_nonsep_byte(sg, dg, sa, da, Sg); | 874 int g = blendfunc_nonsep_byte(sg, dg, sa, da, Sg); |
658 int b = blendfunc_nonsep_byte(sb, db, sa, da, Sb); | 875 int b = blendfunc_nonsep_byte(sb, db, sa, da, Sb); |
659 return SkPackARGB32(a, r, g, b); | 876 return SkPackARGB32(a, r, g, b); |
660 } | 877 } |
661 static SkPM4f color_proc4f(const SkPM4f& src, const SkPM4f& dst) { | |
662 return not_implemented_yet_proc4f(src, dst); | |
663 } | |
664 | 878 |
665 // kLuminosity_Mode | 879 // kLuminosity_Mode |
666 // B(Cb, Cs) = SetLum(Cb, Lum(Cs)) | 880 // B(Cb, Cs) = SetLum(Cb, Lum(Cs)) |
667 // Create a color with the luminosity of the source color and the hue and satura
tion of the backdrop color. | 881 // Create a color with the luminosity of the source color and the hue and satura
tion of the backdrop color. |
668 static SkPMColor luminosity_modeproc(SkPMColor src, SkPMColor dst) { | 882 static SkPMColor luminosity_modeproc(SkPMColor src, SkPMColor dst) { |
669 int sr = SkGetPackedR32(src); | 883 int sr = SkGetPackedR32(src); |
670 int sg = SkGetPackedG32(src); | 884 int sg = SkGetPackedG32(src); |
671 int sb = SkGetPackedB32(src); | 885 int sb = SkGetPackedB32(src); |
672 int sa = SkGetPackedA32(src); | 886 int sa = SkGetPackedA32(src); |
673 | 887 |
(...skipping 13 matching lines...) Expand all Loading... |
687 Dg = 0; | 901 Dg = 0; |
688 Db = 0; | 902 Db = 0; |
689 } | 903 } |
690 | 904 |
691 int a = srcover_byte(sa, da); | 905 int a = srcover_byte(sa, da); |
692 int r = blendfunc_nonsep_byte(sr, dr, sa, da, Dr); | 906 int r = blendfunc_nonsep_byte(sr, dr, sa, da, Dr); |
693 int g = blendfunc_nonsep_byte(sg, dg, sa, da, Dg); | 907 int g = blendfunc_nonsep_byte(sg, dg, sa, da, Dg); |
694 int b = blendfunc_nonsep_byte(sb, db, sa, da, Db); | 908 int b = blendfunc_nonsep_byte(sb, db, sa, da, Db); |
695 return SkPackARGB32(a, r, g, b); | 909 return SkPackARGB32(a, r, g, b); |
696 } | 910 } |
697 static SkPM4f luminosity_proc4f(const SkPM4f& src, const SkPM4f& dst) { | 911 |
698 return not_implemented_yet_proc4f(src, dst); | 912 ////////////////////////////////////////////////////////////////////////////////
/////////////////// |
| 913 |
| 914 static SkPM4f as_pm4f(const Sk4f& x) { |
| 915 SkPM4f pm4; |
| 916 x.store(pm4.fVec); |
| 917 return pm4; |
| 918 } |
| 919 |
| 920 static Sk4f as_4f(const SkPM4f& pm4) { |
| 921 return Sk4f::Load(pm4.fVec); |
| 922 } |
| 923 |
| 924 template <Sk4f (blend)(const Sk4f&, const Sk4f&)> SkPM4f proc_4f(const SkPM4f& s
, const SkPM4f& d) { |
| 925 SkPM4f r = as_pm4f(blend(as_4f(s), as_4f(d))); |
| 926 #ifdef SK_DEBUG |
| 927 const float min = 0; |
| 928 const float max = 1; |
| 929 for (int i = 0; i < 4; ++i) { |
| 930 SkASSERT(r.fVec[i] >= min && r.fVec[i] <= max); |
| 931 } |
| 932 #endif |
| 933 return r; |
699 } | 934 } |
700 | 935 |
701 const ProcCoeff gProcCoeffs[] = { | 936 const ProcCoeff gProcCoeffs[] = { |
702 { clear_modeproc, proc_4f<clear_4f>, SkXfermode::kZero_Coeff,
SkXfermode::kZero_Coeff }, | 937 { clear_modeproc, proc_4f<clear_4f>, SkXfermode::kZero_Coeff,
SkXfermode::kZero_Coeff }, |
703 { src_modeproc, proc_4f<src_4f>, SkXfermode::kOne_Coeff,
SkXfermode::kZero_Coeff }, | 938 { src_modeproc, proc_4f<src_4f>, SkXfermode::kOne_Coeff,
SkXfermode::kZero_Coeff }, |
704 { dst_modeproc, proc_4f<dst_4f>, SkXfermode::kZero_Coeff,
SkXfermode::kOne_Coeff }, | 939 { dst_modeproc, proc_4f<dst_4f>, SkXfermode::kZero_Coeff,
SkXfermode::kOne_Coeff }, |
705 { srcover_modeproc, proc_4f<srcover_4f>, SkXfermode::kOne_Coeff,
SkXfermode::kISA_Coeff }, | 940 { srcover_modeproc, proc_4f<srcover_4f>, SkXfermode::kOne_Coeff,
SkXfermode::kISA_Coeff }, |
706 { dstover_modeproc, proc_4f<dstover_4f>, SkXfermode::kIDA_Coeff,
SkXfermode::kOne_Coeff }, | 941 { dstover_modeproc, proc_4f<dstover_4f>, SkXfermode::kIDA_Coeff,
SkXfermode::kOne_Coeff }, |
707 { srcin_modeproc, proc_4f<srcin_4f>, SkXfermode::kDA_Coeff,
SkXfermode::kZero_Coeff }, | 942 { srcin_modeproc, proc_4f<srcin_4f>, SkXfermode::kDA_Coeff,
SkXfermode::kZero_Coeff }, |
708 { dstin_modeproc, proc_4f<dstin_4f>, SkXfermode::kZero_Coeff,
SkXfermode::kSA_Coeff }, | 943 { dstin_modeproc, proc_4f<dstin_4f>, SkXfermode::kZero_Coeff,
SkXfermode::kSA_Coeff }, |
709 { srcout_modeproc, proc_4f<srcout_4f>, SkXfermode::kIDA_Coeff,
SkXfermode::kZero_Coeff }, | 944 { srcout_modeproc, proc_4f<srcout_4f>, SkXfermode::kIDA_Coeff,
SkXfermode::kZero_Coeff }, |
710 { dstout_modeproc, proc_4f<dstout_4f>, SkXfermode::kZero_Coeff,
SkXfermode::kISA_Coeff }, | 945 { dstout_modeproc, proc_4f<dstout_4f>, SkXfermode::kZero_Coeff,
SkXfermode::kISA_Coeff }, |
711 { srcatop_modeproc, proc_4f<srcatop_4f>, SkXfermode::kDA_Coeff,
SkXfermode::kISA_Coeff }, | 946 { srcatop_modeproc, proc_4f<srcatop_4f>, SkXfermode::kDA_Coeff,
SkXfermode::kISA_Coeff }, |
712 { dstatop_modeproc, proc_4f<dstatop_4f>, SkXfermode::kIDA_Coeff,
SkXfermode::kSA_Coeff }, | 947 { dstatop_modeproc, proc_4f<dstatop_4f>, SkXfermode::kIDA_Coeff,
SkXfermode::kSA_Coeff }, |
713 { xor_modeproc, proc_4f<xor_4f>, SkXfermode::kIDA_Coeff,
SkXfermode::kISA_Coeff }, | 948 { xor_modeproc, proc_4f<xor_4f>, SkXfermode::kIDA_Coeff,
SkXfermode::kISA_Coeff }, |
714 | 949 |
715 { plus_modeproc, proc_4f<plus_4f>, SkXfermode::kOne_Coeff,
SkXfermode::kOne_Coeff }, | 950 { plus_modeproc, proc_4f<plus_4f>, SkXfermode::kOne_Coeff,
SkXfermode::kOne_Coeff }, |
716 { modulate_modeproc, proc_4f<modulate_4f>, SkXfermode::kZero_Coeff,
SkXfermode::kSC_Coeff }, | 951 { modulate_modeproc, proc_4f<modulate_4f>, SkXfermode::kZero_Coeff,
SkXfermode::kSC_Coeff }, |
717 { screen_modeproc, proc_4f<screen_4f>, SkXfermode::kOne_Coeff,
SkXfermode::kISC_Coeff }, | 952 { screen_modeproc, proc_4f<screen_4f>, SkXfermode::kOne_Coeff,
SkXfermode::kISC_Coeff }, |
718 { overlay_modeproc, overlay_proc4f, CANNOT_USE_COEFF, CANNOT_USE
_COEFF }, | 953 { overlay_modeproc, proc_4f<overlay_4f>, CANNOT_USE_COEFF, CANN
OT_USE_COEFF }, |
719 { darken_modeproc, darken_proc4f, CANNOT_USE_COEFF, CANNOT_USE_
COEFF }, | 954 { darken_modeproc, proc_4f<darken_4f>, CANNOT_USE_COEFF, CANN
OT_USE_COEFF }, |
720 { lighten_modeproc, lighten_proc4f, CANNOT_USE_COEFF, CANNOT_USE
_COEFF }, | 955 { lighten_modeproc, proc_4f<lighten_4f>, CANNOT_USE_COEFF, CANN
OT_USE_COEFF }, |
721 { colordodge_modeproc, colordodge_proc4f, CANNOT_USE_COEFF, CANNOT_
USE_COEFF }, | 956 { colordodge_modeproc, proc_4f<colordodge_4f>, CANNOT_USE_COEFF, CANN
OT_USE_COEFF }, |
722 { colorburn_modeproc, colorburn_proc4f, CANNOT_USE_COEFF, CANNOT_U
SE_COEFF }, | 957 { colorburn_modeproc, proc_4f<colorburn_4f>, CANNOT_USE_COEFF, CANN
OT_USE_COEFF }, |
723 { hardlight_modeproc, hardlight_proc4f, CANNOT_USE_COEFF, CANNOT_U
SE_COEFF }, | 958 { hardlight_modeproc, proc_4f<hardlight_4f>, CANNOT_USE_COEFF, CANN
OT_USE_COEFF }, |
724 { softlight_modeproc, softlight_proc4f, CANNOT_USE_COEFF, CANNOT_U
SE_COEFF }, | 959 { softlight_modeproc, proc_4f<softlight_4f>, CANNOT_USE_COEFF, CANN
OT_USE_COEFF }, |
725 { difference_modeproc, difference_proc4f, CANNOT_USE_COEFF, CANNOT_
USE_COEFF }, | 960 { difference_modeproc, proc_4f<difference_4f>, CANNOT_USE_COEFF, CANN
OT_USE_COEFF }, |
726 { exclusion_modeproc, exclusion_proc4f, CANNOT_USE_COEFF, CANNOT_U
SE_COEFF }, | 961 { exclusion_modeproc, proc_4f<exclusion_4f>, CANNOT_USE_COEFF, CANN
OT_USE_COEFF }, |
727 { multiply_modeproc, proc_4f<multiply_4f>, CANNOT_USE_COEFF, CANN
OT_USE_COEFF }, | 962 { multiply_modeproc, proc_4f<multiply_4f>, CANNOT_USE_COEFF, CANN
OT_USE_COEFF }, |
728 { hue_modeproc, hue_proc4f, CANNOT_USE_COEFF, CANNOT_USE_COE
FF }, | 963 { hue_modeproc, proc_4f<hue_4f>, CANNOT_USE_COEFF, CANN
OT_USE_COEFF }, |
729 { saturation_modeproc, saturation_proc4f, CANNOT_USE_COEFF, CANNOT_
USE_COEFF }, | 964 { saturation_modeproc, proc_4f<saturation_4f>, CANNOT_USE_COEFF, CANN
OT_USE_COEFF }, |
730 { color_modeproc, color_proc4f, CANNOT_USE_COEFF, CANNOT_USE_C
OEFF }, | 965 { color_modeproc, proc_4f<color_4f>, CANNOT_USE_COEFF, CANN
OT_USE_COEFF }, |
731 { luminosity_modeproc, luminosity_proc4f, CANNOT_USE_COEFF, CANNOT_
USE_COEFF }, | 966 { luminosity_modeproc, proc_4f<luminosity_4f>, CANNOT_USE_COEFF, CANN
OT_USE_COEFF }, |
732 }; | 967 }; |
733 | 968 |
734 /////////////////////////////////////////////////////////////////////////////// | 969 /////////////////////////////////////////////////////////////////////////////// |
735 | 970 |
736 bool SkXfermode::asMode(Mode* mode) const { | 971 bool SkXfermode::asMode(Mode* mode) const { |
737 return false; | 972 return false; |
738 } | 973 } |
739 | 974 |
740 #if SK_SUPPORT_GPU | 975 #if SK_SUPPORT_GPU |
741 const GrFragmentProcessor* SkXfermode::getFragmentProcessorForImageFilter( | 976 const GrFragmentProcessor* SkXfermode::getFragmentProcessorForImageFilter( |
(...skipping 412 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1154 if (!xfer) { | 1389 if (!xfer) { |
1155 return SkXfermode::kOpaque_SrcColorOpacity == opacityType; | 1390 return SkXfermode::kOpaque_SrcColorOpacity == opacityType; |
1156 } | 1391 } |
1157 | 1392 |
1158 return xfer->isOpaque(opacityType); | 1393 return xfer->isOpaque(opacityType); |
1159 } | 1394 } |
1160 | 1395 |
1161 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkXfermode) | 1396 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkXfermode) |
1162 SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkProcCoeffXfermode) | 1397 SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkProcCoeffXfermode) |
1163 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END | 1398 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END |
OLD | NEW |