?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
btrfs: [] on the end of a struct field is a variable length array.
[haiku.git] / headers / libs / agg / agg_pixfmt_rgba.h
blob20ec1299ff3c0b964385639f3817820a6ef842bf
1 //----------------------------------------------------------------------------
2 // Anti-Grain Geometry - Version 2.4
3 // Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
4 //
5 // Permission to copy, use, modify, sell and distribute this software
6 // is granted provided this copyright notice appears in all copies.
7 // This software is provided "as is" without express or implied
8 // warranty, and with no claim as to its suitability for any purpose.
9 //
10 //----------------------------------------------------------------------------
11 // Contact: mcseem@antigrain.com
12 // mcseemagg@yahoo.com
13 // http://www.antigrain.com
14 //----------------------------------------------------------------------------
15 //
16 // Adaptation for high precision colors has been sponsored by
17 // Liberty Technology Systems, Inc., visit http://lib-sys.com
18 //
19 // Liberty Technology Systems, Inc. is the provider of
20 // PostScript and PDF technology for software developers.
21 //
22 //----------------------------------------------------------------------------
23
24 #ifndef AGG_PIXFMT_RGBA_INCLUDED
25 #define AGG_PIXFMT_RGBA_INCLUDED
26
27 #include <string.h>
28 #include <math.h>
29 #include "agg_basics.h"
30 #include "agg_color_rgba.h"
31 #include "agg_rendering_buffer.h"
32
33 namespace agg
34 {
35
36 //=========================================================multiplier_rgba
37 template<class ColorT, class Order> struct multiplier_rgba
38 {
39 typedef typename ColorT::value_type value_type;
40 typedef typename ColorT::calc_type calc_type;
41
42 //--------------------------------------------------------------------
43 static AGG_INLINE void premultiply(value_type* p)
44 {
45 calc_type a = p[Order::A];
46 if(a < ColorT::base_mask)
47 {
48 if(a == 0)
49 {
50 p[Order::R] = p[Order::G] = p[Order::B] = 0;
51 return;
52 }
53 p[Order::R] = value_type((p[Order::R] * a + ColorT::base_mask) >> ColorT::base_shift);
54 p[Order::G] = value_type((p[Order::G] * a + ColorT::base_mask) >> ColorT::base_shift);
55 p[Order::B] = value_type((p[Order::B] * a + ColorT::base_mask) >> ColorT::base_shift);
56 }
57 }
58
59
60 //--------------------------------------------------------------------
61 static AGG_INLINE void demultiply(value_type* p)
62 {
63 calc_type a = p[Order::A];
64 if(a < ColorT::base_mask)
65 {
66 if(a == 0)
67 {
68 p[Order::R] = p[Order::G] = p[Order::B] = 0;
69 return;
70 }
71 calc_type r = (calc_type(p[Order::R]) * ColorT::base_mask) / a;
72 calc_type g = (calc_type(p[Order::G]) * ColorT::base_mask) / a;
73 calc_type b = (calc_type(p[Order::B]) * ColorT::base_mask) / a;
74 p[Order::R] = value_type((r > ColorT::base_mask) ? ColorT::base_mask : r);
75 p[Order::G] = value_type((g > ColorT::base_mask) ? ColorT::base_mask : g);
76 p[Order::B] = value_type((b > ColorT::base_mask) ? ColorT::base_mask : b);
77 }
78 }
79 };
80
81 //=====================================================apply_gamma_dir_rgba
82 template<class ColorT, class Order, class GammaLut> class apply_gamma_dir_rgba
83 {
84 public:
85 typedef typename ColorT::value_type value_type;
86
87 apply_gamma_dir_rgba(const GammaLut& gamma) : m_gamma(gamma) {}
88
89 AGG_INLINE void operator () (value_type* p)
90 {
91 p[Order::R] = m_gamma.dir(p[Order::R]);
92 p[Order::G] = m_gamma.dir(p[Order::G]);
93 p[Order::B] = m_gamma.dir(p[Order::B]);
94 }
95
96 private:
97 const GammaLut& m_gamma;
98 };
99
100 //=====================================================apply_gamma_inv_rgba
101 template<class ColorT, class Order, class GammaLut> class apply_gamma_inv_rgba
102 {
103 public:
104 typedef typename ColorT::value_type value_type;
105
106 apply_gamma_inv_rgba(const GammaLut& gamma) : m_gamma(gamma) {}
107
108 AGG_INLINE void operator () (value_type* p)
109 {
110 p[Order::R] = m_gamma.inv(p[Order::R]);
111 p[Order::G] = m_gamma.inv(p[Order::G]);
112 p[Order::B] = m_gamma.inv(p[Order::B]);
113 }
114
115 private:
116 const GammaLut& m_gamma;
117 };
118
119
120
121
122
123
124
125
126
127
128 //=============================================================blender_rgba
129 template<class ColorT, class Order> struct blender_rgba
130 {
131 typedef ColorT color_type;
132 typedef Order order_type;
133 typedef typename color_type::value_type value_type;
134 typedef typename color_type::calc_type calc_type;
135 enum base_scale_e
136 {
137 base_shift = color_type::base_shift,
138 base_mask = color_type::base_mask
139 };
140
141 //--------------------------------------------------------------------
142 static AGG_INLINE void blend_pix(value_type* p,
143 unsigned cr, unsigned cg, unsigned cb,
144 unsigned alpha,
145 unsigned cover=0)
146 {
147 calc_type r = p[Order::R];
148 calc_type g = p[Order::G];
149 calc_type b = p[Order::B];
150 calc_type a = p[Order::A];
151 p[Order::R] = (value_type)(((cr - r) * alpha + (r << base_shift)) >> base_shift);
152 p[Order::G] = (value_type)(((cg - g) * alpha + (g << base_shift)) >> base_shift);
153 p[Order::B] = (value_type)(((cb - b) * alpha + (b << base_shift)) >> base_shift);
154 p[Order::A] = (value_type)((alpha + a) - ((alpha * a + base_mask) >> base_shift));
155 }
156 };
157
158 //=========================================================blender_rgba_pre
159 template<class ColorT, class Order> struct blender_rgba_pre
160 {
161 typedef ColorT color_type;
162 typedef Order order_type;
163 typedef typename color_type::value_type value_type;
164 typedef typename color_type::calc_type calc_type;
165 enum base_scale_e
166 {
167 base_shift = color_type::base_shift,
168 base_mask = color_type::base_mask
169 };
170
171 //--------------------------------------------------------------------
172 static AGG_INLINE void blend_pix(value_type* p,
173 unsigned cr, unsigned cg, unsigned cb,
174 unsigned alpha,
175 unsigned cover)
176 {
177 alpha = color_type::base_mask - alpha;
178 cover = (cover + 1) << (base_shift - 8);
179 p[Order::R] = (value_type)((p[Order::R] * alpha + cr * cover) >> base_shift);
180 p[Order::G] = (value_type)((p[Order::G] * alpha + cg * cover) >> base_shift);
181 p[Order::B] = (value_type)((p[Order::B] * alpha + cb * cover) >> base_shift);
182 p[Order::A] = (value_type)(base_mask - ((alpha * (base_mask - p[Order::A])) >> base_shift));
183 }
184
185 //--------------------------------------------------------------------
186 static AGG_INLINE void blend_pix(value_type* p,
187 unsigned cr, unsigned cg, unsigned cb,
188 unsigned alpha)
189 {
190 alpha = color_type::base_mask - alpha;
191 p[Order::R] = (value_type)(((p[Order::R] * alpha) >> base_shift) + cr);
192 p[Order::G] = (value_type)(((p[Order::G] * alpha) >> base_shift) + cg);
193 p[Order::B] = (value_type)(((p[Order::B] * alpha) >> base_shift) + cb);
194 p[Order::A] = (value_type)(base_mask - ((alpha * (base_mask - p[Order::A])) >> base_shift));
195 }
196 };
197
198 //======================================================blender_rgba_plain
199 template<class ColorT, class Order> struct blender_rgba_plain
200 {
201 typedef ColorT color_type;
202 typedef Order order_type;
203 typedef typename color_type::value_type value_type;
204 typedef typename color_type::calc_type calc_type;
205 enum base_scale_e { base_shift = color_type::base_shift };
206
207 //--------------------------------------------------------------------
208 static AGG_INLINE void blend_pix(value_type* p,
209 unsigned cr, unsigned cg, unsigned cb,
210 unsigned alpha,
211 unsigned cover=0)
212 {
213 if(alpha == 0) return;
214 calc_type a = p[Order::A];
215 calc_type r = p[Order::R] * a;
216 calc_type g = p[Order::G] * a;
217 calc_type b = p[Order::B] * a;
218 a = ((alpha + a) << base_shift) - alpha * a;
219 p[Order::A] = (value_type)(a >> base_shift);
220 p[Order::R] = (value_type)((((cr << base_shift) - r) * alpha + (r << base_shift)) / a);
221 p[Order::G] = (value_type)((((cg << base_shift) - g) * alpha + (g << base_shift)) / a);
222 p[Order::B] = (value_type)((((cb << base_shift) - b) * alpha + (b << base_shift)) / a);
223 }
224 };
225
226
227
228
229
230
231
232
233
234
235
236 //=========================================================comp_op_rgba_clear
237 template<class ColorT, class Order> struct comp_op_rgba_clear
238 {
239 typedef ColorT color_type;
240 typedef Order order_type;
241 typedef typename color_type::value_type value_type;
242 enum base_scale_e
243 {
244 base_shift = color_type::base_shift,
245 base_mask = color_type::base_mask
246 };
247
248 static AGG_INLINE void blend_pix(value_type* p,
249 unsigned, unsigned, unsigned, unsigned,
250 unsigned cover)
251 {
252 if(cover < 255)
253 {
254 cover = 255 - cover;
255 p[Order::R] = (value_type)((p[Order::R] * cover + 255) >> 8);
256 p[Order::G] = (value_type)((p[Order::G] * cover + 255) >> 8);
257 p[Order::B] = (value_type)((p[Order::B] * cover + 255) >> 8);
258 p[Order::A] = (value_type)((p[Order::A] * cover + 255) >> 8);
259 }
260 else
261 {
262 p[0] = p[1] = p[2] = p[3] = 0;
263 }
264 }
265 };
266
267 //===========================================================comp_op_rgba_src
268 template<class ColorT, class Order> struct comp_op_rgba_src
269 {
270 typedef ColorT color_type;
271 typedef Order order_type;
272 typedef typename color_type::value_type value_type;
273
274 static AGG_INLINE void blend_pix(value_type* p,
275 unsigned sr, unsigned sg, unsigned sb,
276 unsigned sa, unsigned cover)
277 {
278 if(cover < 255)
279 {
280 unsigned alpha = 255 - cover;
281 p[Order::R] = (value_type)(((p[Order::R] * alpha + 255) >> 8) + ((sr * cover + 255) >> 8));
282 p[Order::G] = (value_type)(((p[Order::G] * alpha + 255) >> 8) + ((sg * cover + 255) >> 8));
283 p[Order::B] = (value_type)(((p[Order::B] * alpha + 255) >> 8) + ((sb * cover + 255) >> 8));
284 p[Order::A] = (value_type)(((p[Order::A] * alpha + 255) >> 8) + ((sa * cover + 255) >> 8));
285 }
286 else
287 {
288 p[Order::R] = sr;
289 p[Order::G] = sg;
290 p[Order::B] = sb;
291 p[Order::A] = sa;
292 }
293 }
294 };
295
296 //===========================================================comp_op_rgba_dst
297 template<class ColorT, class Order> struct comp_op_rgba_dst
298 {
299 typedef ColorT color_type;
300 typedef Order order_type;
301 typedef typename color_type::value_type value_type;
302
303 static AGG_INLINE void blend_pix(value_type*,
304 unsigned, unsigned, unsigned,
305 unsigned, unsigned)
306 {
307 }
308 };
309
310 //======================================================comp_op_rgba_src_over
311 template<class ColorT, class Order> struct comp_op_rgba_src_over
312 {
313 typedef ColorT color_type;
314 typedef Order order_type;
315 typedef typename color_type::value_type value_type;
316 typedef typename color_type::calc_type calc_type;
317 enum base_scale_e
318 {
319 base_shift = color_type::base_shift,
320 base_mask = color_type::base_mask
321 };
322
323 // Dca' = Sca + Dca.(1 - Sa)
324 // Da' = Sa + Da - Sa.Da
325 static AGG_INLINE void blend_pix(value_type* p,
326 unsigned sr, unsigned sg, unsigned sb,
327 unsigned sa, unsigned cover)
328 {
329 if(cover < 255)
330 {
331 sr = (sr * cover + 255) >> 8;
332 sg = (sg * cover + 255) >> 8;
333 sb = (sb * cover + 255) >> 8;
334 sa = (sa * cover + 255) >> 8;
335 }
336 calc_type s1a = base_mask - sa;
337 p[Order::R] = (value_type)(sr + ((p[Order::R] * s1a + base_mask) >> base_shift));
338 p[Order::G] = (value_type)(sg + ((p[Order::G] * s1a + base_mask) >> base_shift));
339 p[Order::B] = (value_type)(sb + ((p[Order::B] * s1a + base_mask) >> base_shift));
340 p[Order::A] = (value_type)(sa + p[Order::A] - ((sa * p[Order::A] + base_mask) >> base_shift));
341 }
342 };
343
344 //======================================================comp_op_rgba_dst_over
345 template<class ColorT, class Order> struct comp_op_rgba_dst_over
346 {
347 typedef ColorT color_type;
348 typedef Order order_type;
349 typedef typename color_type::value_type value_type;
350 typedef typename color_type::calc_type calc_type;
351 enum base_scale_e
352 {
353 base_shift = color_type::base_shift,
354 base_mask = color_type::base_mask
355 };
356
357 // Dca' = Dca + Sca.(1 - Da)
358 // Da' = Sa + Da - Sa.Da
359 static AGG_INLINE void blend_pix(value_type* p,
360 unsigned sr, unsigned sg, unsigned sb,
361 unsigned sa, unsigned cover)
362 {
363 if(cover < 255)
364 {
365 sr = (sr * cover + 255) >> 8;
366 sg = (sg * cover + 255) >> 8;
367 sb = (sb * cover + 255) >> 8;
368 sa = (sa * cover + 255) >> 8;
369 }
370 calc_type d1a = base_mask - p[Order::A];
371 p[Order::R] = (value_type)(p[Order::R] + ((sr * d1a + base_mask) >> base_shift));
372 p[Order::G] = (value_type)(p[Order::G] + ((sg * d1a + base_mask) >> base_shift));
373 p[Order::B] = (value_type)(p[Order::B] + ((sb * d1a + base_mask) >> base_shift));
374 p[Order::A] = (value_type)(sa + p[Order::A] - ((sa * p[Order::A] + base_mask) >> base_shift));
375 }
376 };
377
378 //======================================================comp_op_rgba_src_in
379 template<class ColorT, class Order> struct comp_op_rgba_src_in
380 {
381 typedef ColorT color_type;
382 typedef Order order_type;
383 typedef typename color_type::value_type value_type;
384 typedef typename color_type::calc_type calc_type;
385 enum base_scale_e
386 {
387 base_shift = color_type::base_shift,
388 base_mask = color_type::base_mask
389 };
390
391 // Dca' = Sca.Da
392 // Da' = Sa.Da
393 static AGG_INLINE void blend_pix(value_type* p,
394 unsigned sr, unsigned sg, unsigned sb,
395 unsigned sa, unsigned cover)
396 {
397 calc_type da = p[Order::A];
398 if(cover < 255)
399 {
400 unsigned alpha = 255 - cover;
401 p[Order::R] = (value_type)(((p[Order::R] * alpha + 255) >> 8) + ((((sr * da + base_mask) >> base_shift) * cover + 255) >> 8));
402 p[Order::G] = (value_type)(((p[Order::G] * alpha + 255) >> 8) + ((((sg * da + base_mask) >> base_shift) * cover + 255) >> 8));
403 p[Order::B] = (value_type)(((p[Order::B] * alpha + 255) >> 8) + ((((sb * da + base_mask) >> base_shift) * cover + 255) >> 8));
404 p[Order::A] = (value_type)(((p[Order::A] * alpha + 255) >> 8) + ((((sa * da + base_mask) >> base_shift) * cover + 255) >> 8));
405 }
406 else
407 {
408 p[Order::R] = (value_type)((sr * da + base_mask) >> base_shift);
409 p[Order::G] = (value_type)((sg * da + base_mask) >> base_shift);
410 p[Order::B] = (value_type)((sb * da + base_mask) >> base_shift);
411 p[Order::A] = (value_type)((sa * da + base_mask) >> base_shift);
412 }
413 }
414 };
415
416 //======================================================comp_op_rgba_dst_in
417 template<class ColorT, class Order> struct comp_op_rgba_dst_in
418 {
419 typedef ColorT color_type;
420 typedef Order order_type;
421 typedef typename color_type::value_type value_type;
422 typedef typename color_type::calc_type calc_type;
423 enum base_scale_e
424 {
425 base_shift = color_type::base_shift,
426 base_mask = color_type::base_mask
427 };
428
429 // Dca' = Dca.Sa
430 // Da' = Sa.Da
431 static AGG_INLINE void blend_pix(value_type* p,
432 unsigned, unsigned, unsigned,
433 unsigned sa, unsigned cover)
434 {
435 if(cover < 255)
436 {
437 sa = base_mask - ((cover * (base_mask - sa) + 255) >> 8);
438 }
439 p[Order::R] = (value_type)((p[Order::R] * sa + base_mask) >> base_shift);
440 p[Order::G] = (value_type)((p[Order::G] * sa + base_mask) >> base_shift);
441 p[Order::B] = (value_type)((p[Order::B] * sa + base_mask) >> base_shift);
442 p[Order::A] = (value_type)((p[Order::A] * sa + base_mask) >> base_shift);
443 }
444 };
445
446 //======================================================comp_op_rgba_src_out
447 template<class ColorT, class Order> struct comp_op_rgba_src_out
448 {
449 typedef ColorT color_type;
450 typedef Order order_type;
451 typedef typename color_type::value_type value_type;
452 typedef typename color_type::calc_type calc_type;
453 enum base_scale_e
454 {
455 base_shift = color_type::base_shift,
456 base_mask = color_type::base_mask
457 };
458
459 // Dca' = Sca.(1 - Da)
460 // Da' = Sa.(1 - Da)
461 static AGG_INLINE void blend_pix(value_type* p,
462 unsigned sr, unsigned sg, unsigned sb,
463 unsigned sa, unsigned cover)
464 {
465 calc_type da = base_mask - p[Order::A];
466 if(cover < 255)
467 {
468 unsigned alpha = 255 - cover;
469 p[Order::R] = (value_type)(((p[Order::R] * alpha + 255) >> 8) + ((((sr * da + base_mask) >> base_shift) * cover + 255) >> 8));
470 p[Order::G] = (value_type)(((p[Order::G] * alpha + 255) >> 8) + ((((sg * da + base_mask) >> base_shift) * cover + 255) >> 8));
471 p[Order::B] = (value_type)(((p[Order::B] * alpha + 255) >> 8) + ((((sb * da + base_mask) >> base_shift) * cover + 255) >> 8));
472 p[Order::A] = (value_type)(((p[Order::A] * alpha + 255) >> 8) + ((((sa * da + base_mask) >> base_shift) * cover + 255) >> 8));
473 }
474 else
475 {
476 p[Order::R] = (value_type)((sr * da + base_mask) >> base_shift);
477 p[Order::G] = (value_type)((sg * da + base_mask) >> base_shift);
478 p[Order::B] = (value_type)((sb * da + base_mask) >> base_shift);
479 p[Order::A] = (value_type)((sa * da + base_mask) >> base_shift);
480 }
481 }
482 };
483
484 //======================================================comp_op_rgba_dst_out
485 template<class ColorT, class Order> struct comp_op_rgba_dst_out
486 {
487 typedef ColorT color_type;
488 typedef Order order_type;
489 typedef typename color_type::value_type value_type;
490 typedef typename color_type::calc_type calc_type;
491 enum base_scale_e
492 {
493 base_shift = color_type::base_shift,
494 base_mask = color_type::base_mask
495 };
496
497 // Dca' = Dca.(1 - Sa)
498 // Da' = Da.(1 - Sa)
499 static AGG_INLINE void blend_pix(value_type* p,
500 unsigned, unsigned, unsigned,
501 unsigned sa, unsigned cover)
502 {
503 if(cover < 255)
504 {
505 sa = (sa * cover + 255) >> 8;
506 }
507 sa = base_mask - sa;
508 p[Order::R] = (value_type)((p[Order::R] * sa + base_shift) >> base_shift);
509 p[Order::G] = (value_type)((p[Order::G] * sa + base_shift) >> base_shift);
510 p[Order::B] = (value_type)((p[Order::B] * sa + base_shift) >> base_shift);
511 p[Order::A] = (value_type)((p[Order::A] * sa + base_shift) >> base_shift);
512 }
513 };
514
515 //=====================================================comp_op_rgba_src_atop
516 template<class ColorT, class Order> struct comp_op_rgba_src_atop
517 {
518 typedef ColorT color_type;
519 typedef Order order_type;
520 typedef typename color_type::value_type value_type;
521 typedef typename color_type::calc_type calc_type;
522 enum base_scale_e
523 {
524 base_shift = color_type::base_shift,
525 base_mask = color_type::base_mask
526 };
527
528 // Dca' = Sca.Da + Dca.(1 - Sa)
529 // Da' = Da
530 static AGG_INLINE void blend_pix(value_type* p,
531 unsigned sr, unsigned sg, unsigned sb,
532 unsigned sa, unsigned cover)
533 {
534 if(cover < 255)
535 {
536 sr = (sr * cover + 255) >> 8;
537 sg = (sg * cover + 255) >> 8;
538 sb = (sb * cover + 255) >> 8;
539 sa = (sa * cover + 255) >> 8;
540 }
541 calc_type da = p[Order::A];
542 sa = base_mask - sa;
543 p[Order::R] = (value_type)((sr * da + p[Order::R] * sa + base_mask) >> base_shift);
544 p[Order::G] = (value_type)((sg * da + p[Order::G] * sa + base_mask) >> base_shift);
545 p[Order::B] = (value_type)((sb * da + p[Order::B] * sa + base_mask) >> base_shift);
546 }
547 };
548
549 //=====================================================comp_op_rgba_dst_atop
550 template<class ColorT, class Order> struct comp_op_rgba_dst_atop
551 {
552 typedef ColorT color_type;
553 typedef Order order_type;
554 typedef typename color_type::value_type value_type;
555 typedef typename color_type::calc_type calc_type;
556 enum base_scale_e
557 {
558 base_shift = color_type::base_shift,
559 base_mask = color_type::base_mask
560 };
561
562 // Dca' = Dca.Sa + Sca.(1 - Da)
563 // Da' = Sa
564 static AGG_INLINE void blend_pix(value_type* p,
565 unsigned sr, unsigned sg, unsigned sb,
566 unsigned sa, unsigned cover)
567 {
568 calc_type da = base_mask - p[Order::A];
569 if(cover < 255)
570 {
571 unsigned alpha = 255 - cover;
572 sr = (p[Order::R] * sa + sr * da + base_mask) >> base_shift;
573 sg = (p[Order::G] * sa + sg * da + base_mask) >> base_shift;
574 sb = (p[Order::B] * sa + sb * da + base_mask) >> base_shift;
575 p[Order::R] = (value_type)(((p[Order::R] * alpha + 255) >> 8) + ((sr * cover + 255) >> 8));
576 p[Order::G] = (value_type)(((p[Order::G] * alpha + 255) >> 8) + ((sg * cover + 255) >> 8));
577 p[Order::B] = (value_type)(((p[Order::B] * alpha + 255) >> 8) + ((sb * cover + 255) >> 8));
578 p[Order::A] = (value_type)(((p[Order::A] * alpha + 255) >> 8) + ((sa * cover + 255) >> 8));
579
580 }
581 else
582 {
583 p[Order::R] = (value_type)((p[Order::R] * sa + sr * da + base_mask) >> base_shift);
584 p[Order::G] = (value_type)((p[Order::G] * sa + sg * da + base_mask) >> base_shift);
585 p[Order::B] = (value_type)((p[Order::B] * sa + sb * da + base_mask) >> base_shift);
586 p[Order::A] = (value_type)sa;
587 }
588 }
589 };
590
591 //=========================================================comp_op_rgba_xor
592 template<class ColorT, class Order> struct comp_op_rgba_xor
593 {
594 typedef ColorT color_type;
595 typedef Order order_type;
596 typedef typename color_type::value_type value_type;
597 typedef typename color_type::calc_type calc_type;
598 enum base_scale_e
599 {
600 base_shift = color_type::base_shift,
601 base_mask = color_type::base_mask
602 };
603
604 // Dca' = Sca.(1 - Da) + Dca.(1 - Sa)
605 // Da' = Sa + Da - 2.Sa.Da
606 static AGG_INLINE void blend_pix(value_type* p,
607 unsigned sr, unsigned sg, unsigned sb,
608 unsigned sa, unsigned cover)
609 {
610 if(cover < 255)
611 {
612 sr = (sr * cover + 255) >> 8;
613 sg = (sg * cover + 255) >> 8;
614 sb = (sb * cover + 255) >> 8;
615 sa = (sa * cover + 255) >> 8;
616 }
617 if(sa)
618 {
619 calc_type s1a = base_mask - sa;
620 calc_type d1a = base_mask - p[Order::A];
621 p[Order::R] = (value_type)((p[Order::R] * s1a + sr * d1a + base_mask) >> base_shift);
622 p[Order::G] = (value_type)((p[Order::G] * s1a + sg * d1a + base_mask) >> base_shift);
623 p[Order::B] = (value_type)((p[Order::B] * s1a + sb * d1a + base_mask) >> base_shift);
624 p[Order::A] = (value_type)(sa + p[Order::A] - ((sa * p[Order::A] + base_mask/2) >> (base_shift - 1)));
625 }
626 }
627 };
628
629 //=========================================================comp_op_rgba_plus
630 template<class ColorT, class Order> struct comp_op_rgba_plus
631 {
632 typedef ColorT color_type;
633 typedef Order order_type;
634 typedef typename color_type::value_type value_type;
635 typedef typename color_type::calc_type calc_type;
636 enum base_scale_e
637 {
638 base_shift = color_type::base_shift,
639 base_mask = color_type::base_mask
640 };
641
642 // Dca' = Sca + Dca
643 // Da' = Sa + Da
644 static AGG_INLINE void blend_pix(value_type* p,
645 unsigned sr, unsigned sg, unsigned sb,
646 unsigned sa, unsigned cover)
647 {
648 if(cover < 255)
649 {
650 sr = (sr * cover + 255) >> 8;
651 sg = (sg * cover + 255) >> 8;
652 sb = (sb * cover + 255) >> 8;
653 sa = (sa * cover + 255) >> 8;
654 }
655 if(sa)
656 {
657 calc_type dr = p[Order::R] + sr;
658 calc_type dg = p[Order::G] + sg;
659 calc_type db = p[Order::B] + sb;
660 calc_type da = p[Order::A] + sa;
661 p[Order::R] = (dr > base_mask) ? base_mask : dr;
662 p[Order::G] = (dg > base_mask) ? base_mask : dg;
663 p[Order::B] = (db > base_mask) ? base_mask : db;
664 p[Order::A] = (da > base_mask) ? base_mask : da;
665 }
666 }
667 };
668
669 //========================================================comp_op_rgba_minus
670 template<class ColorT, class Order> struct comp_op_rgba_minus
671 {
672 typedef ColorT color_type;
673 typedef Order order_type;
674 typedef typename color_type::value_type value_type;
675 typedef typename color_type::calc_type calc_type;
676 enum base_scale_e
677 {
678 base_shift = color_type::base_shift,
679 base_mask = color_type::base_mask
680 };
681
682 // Dca' = Dca - Sca
683 // Da' = 1 - (1 - Sa).(1 - Da)
684 static AGG_INLINE void blend_pix(value_type* p,
685 unsigned sr, unsigned sg, unsigned sb,
686 unsigned sa, unsigned cover)
687 {
688 if(cover < 255)
689 {
690 sr = (sr * cover + 255) >> 8;
691 sg = (sg * cover + 255) >> 8;
692 sb = (sb * cover + 255) >> 8;
693 sa = (sa * cover + 255) >> 8;
694 }
695 if(sa)
696 {
697 calc_type dr = p[Order::R] - sr;
698 calc_type dg = p[Order::G] - sg;
699 calc_type db = p[Order::B] - sb;
700 p[Order::R] = (dr > base_mask) ? 0 : dr;
701 p[Order::G] = (dg > base_mask) ? 0 : dg;
702 p[Order::B] = (db > base_mask) ? 0 : db;
703 p[Order::A] = (value_type)(sa + p[Order::A] - ((sa * p[Order::A] + base_mask) >> base_shift));
704 //p[Order::A] = (value_type)(base_mask - (((base_mask - sa) * (base_mask - p[Order::A]) + base_mask) >> base_shift));
705 }
706 }
707 };
708
709 //=====================================================comp_op_rgba_multiply
710 template<class ColorT, class Order> struct comp_op_rgba_multiply
711 {
712 typedef ColorT color_type;
713 typedef Order order_type;
714 typedef typename color_type::value_type value_type;
715 typedef typename color_type::calc_type calc_type;
716 enum base_scale_e
717 {
718 base_shift = color_type::base_shift,
719 base_mask = color_type::base_mask
720 };
721
722 // Dca' = Sca.Dca + Sca.(1 - Da) + Dca.(1 - Sa)
723 // Da' = Sa + Da - Sa.Da
724 static AGG_INLINE void blend_pix(value_type* p,
725 unsigned sr, unsigned sg, unsigned sb,
726 unsigned sa, unsigned cover)
727 {
728 if(cover < 255)
729 {
730 sr = (sr * cover + 255) >> 8;
731 sg = (sg * cover + 255) >> 8;
732 sb = (sb * cover + 255) >> 8;
733 sa = (sa * cover + 255) >> 8;
734 }
735 if(sa)
736 {
737 calc_type s1a = base_mask - sa;
738 calc_type d1a = base_mask - p[Order::A];
739 calc_type dr = p[Order::R];
740 calc_type dg = p[Order::G];
741 calc_type db = p[Order::B];
742 p[Order::R] = (value_type)((sr * dr + sr * d1a + dr * s1a + base_mask) >> base_shift);
743 p[Order::G] = (value_type)((sg * dg + sg * d1a + dg * s1a + base_mask) >> base_shift);
744 p[Order::B] = (value_type)((sb * db + sb * d1a + db * s1a + base_mask) >> base_shift);
745 p[Order::A] = (value_type)(sa + p[Order::A] - ((sa * p[Order::A] + base_mask) >> base_shift));
746 }
747 }
748 };
749
750 //=====================================================comp_op_rgba_screen
751 template<class ColorT, class Order> struct comp_op_rgba_screen
752 {
753 typedef ColorT color_type;
754 typedef Order order_type;
755 typedef typename color_type::value_type value_type;
756 typedef typename color_type::calc_type calc_type;
757 enum base_scale_e
758 {
759 base_shift = color_type::base_shift,
760 base_mask = color_type::base_mask
761 };
762
763 // Dca' = Sca + Dca - Sca.Dca
764 // Da' = Sa + Da - Sa.Da
765 static AGG_INLINE void blend_pix(value_type* p,
766 unsigned sr, unsigned sg, unsigned sb,
767 unsigned sa, unsigned cover)
768 {
769 if(cover < 255)
770 {
771 sr = (sr * cover + 255) >> 8;
772 sg = (sg * cover + 255) >> 8;
773 sb = (sb * cover + 255) >> 8;
774 sa = (sa * cover + 255) >> 8;
775 }
776 if(sa)
777 {
778 calc_type dr = p[Order::R];
779 calc_type dg = p[Order::G];
780 calc_type db = p[Order::B];
781 calc_type da = p[Order::A];
782 p[Order::R] = (value_type)(sr + dr - ((sr * dr + base_mask) >> base_shift));
783 p[Order::G] = (value_type)(sg + dg - ((sg * dg + base_mask) >> base_shift));
784 p[Order::B] = (value_type)(sb + db - ((sb * db + base_mask) >> base_shift));
785 p[Order::A] = (value_type)(sa + da - ((sa * da + base_mask) >> base_shift));
786 }
787 }
788 };
789
790 //=====================================================comp_op_rgba_overlay
791 template<class ColorT, class Order> struct comp_op_rgba_overlay
792 {
793 typedef ColorT color_type;
794 typedef Order order_type;
795 typedef typename color_type::value_type value_type;
796 typedef typename color_type::calc_type calc_type;
797 enum base_scale_e
798 {
799 base_shift = color_type::base_shift,
800 base_mask = color_type::base_mask
801 };
802
803 // if 2.Dca < Da
804 // Dca' = 2.Sca.Dca + Sca.(1 - Da) + Dca.(1 - Sa)
805 // otherwise
806 // Dca' = Sa.Da - 2.(Da - Dca).(Sa - Sca) + Sca.(1 - Da) + Dca.(1 - Sa)
807 //
808 // Da' = Sa + Da - Sa.Da
809 static AGG_INLINE void blend_pix(value_type* p,
810 unsigned sr, unsigned sg, unsigned sb,
811 unsigned sa, unsigned cover)
812 {
813 if(cover < 255)
814 {
815 sr = (sr * cover + 255) >> 8;
816 sg = (sg * cover + 255) >> 8;
817 sb = (sb * cover + 255) >> 8;
818 sa = (sa * cover + 255) >> 8;
819 }
820 if(sa)
821 {
822 calc_type d1a = base_mask - p[Order::A];
823 calc_type s1a = base_mask - sa;
824 calc_type dr = p[Order::R];
825 calc_type dg = p[Order::G];
826 calc_type db = p[Order::B];
827 calc_type da = p[Order::A];
828 calc_type sada = sa * p[Order::A];
829
830 p[Order::R] = (value_type)(((2*dr < da) ?
831 2*sr*dr + sr*d1a + dr*s1a :
832 sada - 2*(da - dr)*(sa - sr) + sr*d1a + dr*s1a + base_mask) >> base_shift);
833
834 p[Order::G] = (value_type)(((2*dg < da) ?
835 2*sg*dg + sg*d1a + dg*s1a :
836 sada - 2*(da - dg)*(sa - sg) + sg*d1a + dg*s1a + base_mask) >> base_shift);
837
838 p[Order::B] = (value_type)(((2*db < da) ?
839 2*sb*db + sb*d1a + db*s1a :
840 sada - 2*(da - db)*(sa - sb) + sb*d1a + db*s1a + base_mask) >> base_shift);
841
842 p[Order::A] = (value_type)(sa + da - ((sa * da + base_mask) >> base_shift));
843 }
844 }
845 };
846
847
848 template<class T> inline T sd_min(T a, T b) { return (a < b) ? a : b; }
849 template<class T> inline T sd_max(T a, T b) { return (a > b) ? a : b; }
850
851 //=====================================================comp_op_rgba_darken
852 template<class ColorT, class Order> struct comp_op_rgba_darken
853 {
854 typedef ColorT color_type;
855 typedef Order order_type;
856 typedef typename color_type::value_type value_type;
857 typedef typename color_type::calc_type calc_type;
858 enum base_scale_e
859 {
860 base_shift = color_type::base_shift,
861 base_mask = color_type::base_mask
862 };
863
864 // Dca' = min(Sca.Da, Dca.Sa) + Sca.(1 - Da) + Dca.(1 - Sa)
865 // Da' = Sa + Da - Sa.Da
866 static AGG_INLINE void blend_pix(value_type* p,
867 unsigned sr, unsigned sg, unsigned sb,
868 unsigned sa, unsigned cover)
869 {
870 if(cover < 255)
871 {
872 sr = (sr * cover + 255) >> 8;
873 sg = (sg * cover + 255) >> 8;
874 sb = (sb * cover + 255) >> 8;
875 sa = (sa * cover + 255) >> 8;
876 }
877 if(sa)
878 {
879 calc_type d1a = base_mask - p[Order::A];
880 calc_type s1a = base_mask - sa;
881 calc_type dr = p[Order::R];
882 calc_type dg = p[Order::G];
883 calc_type db = p[Order::B];
884 calc_type da = p[Order::A];
885
886 p[Order::R] = (value_type)((sd_min(sr * da, dr * sa) + sr * d1a + dr * s1a + base_mask) >> base_shift);
887 p[Order::G] = (value_type)((sd_min(sg * da, dg * sa) + sg * d1a + dg * s1a + base_mask) >> base_shift);
888 p[Order::B] = (value_type)((sd_min(sb * da, db * sa) + sb * d1a + db * s1a + base_mask) >> base_shift);
889 p[Order::A] = (value_type)(sa + da - ((sa * da + base_mask) >> base_shift));
890 }
891 }
892 };
893
894 //=====================================================comp_op_rgba_lighten
895 template<class ColorT, class Order> struct comp_op_rgba_lighten
896 {
897 typedef ColorT color_type;
898 typedef Order order_type;
899 typedef typename color_type::value_type value_type;
900 typedef typename color_type::calc_type calc_type;
901 enum base_scale_e
902 {
903 base_shift = color_type::base_shift,
904 base_mask = color_type::base_mask
905 };
906
907 // Dca' = max(Sca.Da, Dca.Sa) + Sca.(1 - Da) + Dca.(1 - Sa)
908 // Da' = Sa + Da - Sa.Da
909 static AGG_INLINE void blend_pix(value_type* p,
910 unsigned sr, unsigned sg, unsigned sb,
911 unsigned sa, unsigned cover)
912 {
913 if(cover < 255)
914 {
915 sr = (sr * cover + 255) >> 8;
916 sg = (sg * cover + 255) >> 8;
917 sb = (sb * cover + 255) >> 8;
918 sa = (sa * cover + 255) >> 8;
919 }
920 if(sa)
921 {
922 calc_type d1a = base_mask - p[Order::A];
923 calc_type s1a = base_mask - sa;
924 calc_type dr = p[Order::R];
925 calc_type dg = p[Order::G];
926 calc_type db = p[Order::B];
927 calc_type da = p[Order::A];
928
929 p[Order::R] = (value_type)((sd_max(sr * da, dr * sa) + sr * d1a + dr * s1a + base_mask) >> base_shift);
930 p[Order::G] = (value_type)((sd_max(sg * da, dg * sa) + sg * d1a + dg * s1a + base_mask) >> base_shift);
931 p[Order::B] = (value_type)((sd_max(sb * da, db * sa) + sb * d1a + db * s1a + base_mask) >> base_shift);
932 p[Order::A] = (value_type)(sa + da - ((sa * da + base_mask) >> base_shift));
933 }
934 }
935 };
936
937 //=====================================================comp_op_rgba_color_dodge
938 template<class ColorT, class Order> struct comp_op_rgba_color_dodge
939 {
940 typedef ColorT color_type;
941 typedef Order order_type;
942 typedef typename color_type::value_type value_type;
943 typedef typename color_type::calc_type calc_type;
944 typedef typename color_type::long_type long_type;
945 enum base_scale_e
946 {
947 base_shift = color_type::base_shift,
948 base_mask = color_type::base_mask
949 };
950
951 // if Sca.Da + Dca.Sa >= Sa.Da
952 // Dca' = Sa.Da + Sca.(1 - Da) + Dca.(1 - Sa)
953 // otherwise
954 // Dca' = Dca.Sa/(1-Sca/Sa) + Sca.(1 - Da) + Dca.(1 - Sa)
955 //
956 // Da' = Sa + Da - Sa.Da
957 static AGG_INLINE void blend_pix(value_type* p,
958 unsigned sr, unsigned sg, unsigned sb,
959 unsigned sa, unsigned cover)
960 {
961 if(cover < 255)
962 {
963 sr = (sr * cover + 255) >> 8;
964 sg = (sg * cover + 255) >> 8;
965 sb = (sb * cover + 255) >> 8;
966 sa = (sa * cover + 255) >> 8;
967 }
968 if(sa)
969 {
970 calc_type d1a = base_mask - p[Order::A];
971 calc_type s1a = base_mask - sa;
972 calc_type dr = p[Order::R];
973 calc_type dg = p[Order::G];
974 calc_type db = p[Order::B];
975 calc_type da = p[Order::A];
976 long_type drsa = dr * sa;
977 long_type dgsa = dg * sa;
978 long_type dbsa = db * sa;
979 long_type srda = sr * da;
980 long_type sgda = sg * da;
981 long_type sbda = sb * da;
982 long_type sada = sa * da;
983
984 p[Order::R] = (value_type)((srda + drsa >= sada) ?
985 (sada + sr * d1a + dr * s1a + base_mask) >> base_shift :
986 drsa / (base_mask - (sr << base_shift) / sa) + ((sr * d1a + dr * s1a + base_mask) >> base_shift));
987
988 p[Order::G] = (value_type)((sgda + dgsa >= sada) ?
989 (sada + sg * d1a + dg * s1a + base_mask) >> base_shift :
990 dgsa / (base_mask - (sg << base_shift) / sa) + ((sg * d1a + dg * s1a + base_mask) >> base_shift));
991
992 p[Order::B] = (value_type)((sbda + dbsa >= sada) ?
993 (sada + sb * d1a + db * s1a + base_mask) >> base_shift :
994 dbsa / (base_mask - (sb << base_shift) / sa) + ((sb * d1a + db * s1a + base_mask) >> base_shift));
995
996 p[Order::A] = (value_type)(sa + da - ((sa * da + base_mask) >> base_shift));
997 }
998 }
999 };
1000
1001 //=====================================================comp_op_rgba_color_burn
1002 template<class ColorT, class Order> struct comp_op_rgba_color_burn
1003 {
1004 typedef ColorT color_type;
1005 typedef Order order_type;
1006 typedef typename color_type::value_type value_type;
1007 typedef typename color_type::calc_type calc_type;
1008 typedef typename color_type::long_type long_type;
1009 enum base_scale_e
1010 {
1011 base_shift = color_type::base_shift,
1012 base_mask = color_type::base_mask
1013 };
1014
1015 // if Sca.Da + Dca.Sa <= Sa.Da
1016 // Dca' = Sca.(1 - Da) + Dca.(1 - Sa)
1017 // otherwise
1018 // Dca' = Sa.(Sca.Da + Dca.Sa - Sa.Da)/Sca + Sca.(1 - Da) + Dca.(1 - Sa)
1019 //
1020 // Da' = Sa + Da - Sa.Da
1021 static AGG_INLINE void blend_pix(value_type* p,
1022 unsigned sr, unsigned sg, unsigned sb,
1023 unsigned sa, unsigned cover)
1024 {
1025 if(cover < 255)
1026 {
1027 sr = (sr * cover + 255) >> 8;
1028 sg = (sg * cover + 255) >> 8;
1029 sb = (sb * cover + 255) >> 8;
1030 sa = (sa * cover + 255) >> 8;
1031 }
1032 if(sa)
1033 {
1034 calc_type d1a = base_mask - p[Order::A];
1035 calc_type s1a = base_mask - sa;
1036 calc_type dr = p[Order::R];
1037 calc_type dg = p[Order::G];
1038 calc_type db = p[Order::B];
1039 calc_type da = p[Order::A];
1040 long_type drsa = dr * sa;
1041 long_type dgsa = dg * sa;
1042 long_type dbsa = db * sa;
1043 long_type srda = sr * da;
1044 long_type sgda = sg * da;
1045 long_type sbda = sb * da;
1046 long_type sada = sa * da;
1047
1048 p[Order::R] = (value_type)(((srda + drsa <= sada) ?
1049 sr * d1a + dr * s1a :
1050 sa * (srda + drsa - sada) / sr + sr * d1a + dr * s1a + base_mask) >> base_shift);
1051
1052 p[Order::G] = (value_type)(((sgda + dgsa <= sada) ?
1053 sg * d1a + dg * s1a :
1054 sa * (sgda + dgsa - sada) / sg + sg * d1a + dg * s1a + base_mask) >> base_shift);
1055
1056 p[Order::B] = (value_type)(((sbda + dbsa <= sada) ?
1057 sb * d1a + db * s1a :
1058 sa * (sbda + dbsa - sada) / sb + sb * d1a + db * s1a + base_mask) >> base_shift);
1059
1060 p[Order::A] = (value_type)(sa + da - ((sa * da + base_mask) >> base_shift));
1061 }
1062 }
1063 };
1064
1065 //=====================================================comp_op_rgba_hard_light
1066 template<class ColorT, class Order> struct comp_op_rgba_hard_light
1067 {
1068 typedef ColorT color_type;
1069 typedef Order order_type;
1070 typedef typename color_type::value_type value_type;
1071 typedef typename color_type::calc_type calc_type;
1072 typedef typename color_type::long_type long_type;
1073 enum base_scale_e
1074 {
1075 base_shift = color_type::base_shift,
1076 base_mask = color_type::base_mask
1077 };
1078
1079 // if 2.Sca < Sa
1080 // Dca' = 2.Sca.Dca + Sca.(1 - Da) + Dca.(1 - Sa)
1081 // otherwise
1082 // Dca' = Sa.Da - 2.(Da - Dca).(Sa - Sca) + Sca.(1 - Da) + Dca.(1 - Sa)
1083 //
1084 // Da' = Sa + Da - Sa.Da
1085 static AGG_INLINE void blend_pix(value_type* p,
1086 unsigned sr, unsigned sg, unsigned sb,
1087 unsigned sa, unsigned cover)
1088 {
1089 if(cover < 255)
1090 {
1091 sr = (sr * cover + 255) >> 8;
1092 sg = (sg * cover + 255) >> 8;
1093 sb = (sb * cover + 255) >> 8;
1094 sa = (sa * cover + 255) >> 8;
1095 }
1096 if(sa)
1097 {
1098 calc_type d1a = base_mask - p[Order::A];
1099 calc_type s1a = base_mask - sa;
1100 calc_type dr = p[Order::R];
1101 calc_type dg = p[Order::G];
1102 calc_type db = p[Order::B];
1103 calc_type da = p[Order::A];
1104 calc_type sada = sa * da;
1105
1106 p[Order::R] = (value_type)(((2*sr < sa) ?
1107 2*sr*dr + sr*d1a + dr*s1a :
1108 sada - 2*(da - dr)*(sa - sr) + sr*d1a + dr*s1a + base_mask) >> base_shift);
1109
1110 p[Order::G] = (value_type)(((2*sg < sa) ?
1111 2*sg*dg + sg*d1a + dg*s1a :
1112 sada - 2*(da - dg)*(sa - sg) + sg*d1a + dg*s1a + base_mask) >> base_shift);
1113
1114 p[Order::B] = (value_type)(((2*sb < sa) ?
1115 2*sb*db + sb*d1a + db*s1a :
1116 sada - 2*(da - db)*(sa - sb) + sb*d1a + db*s1a + base_mask) >> base_shift);
1117
1118 p[Order::A] = (value_type)(sa + da - ((sa * da + base_mask) >> base_shift));
1119 }
1120 }
1121 };
1122
1123 //=====================================================comp_op_rgba_soft_light
1124 template<class ColorT, class Order> struct comp_op_rgba_soft_light
1125 {
1126 typedef ColorT color_type;
1127 typedef Order order_type;
1128 typedef typename color_type::value_type value_type;
1129 typedef typename color_type::calc_type calc_type;
1130 typedef typename color_type::long_type long_type;
1131 enum base_scale_e
1132 {
1133 base_shift = color_type::base_shift,
1134 base_mask = color_type::base_mask
1135 };
1136
1137 // if 2.Sca < Sa
1138 // Dca' = Dca.(Sa + (1 - Dca/Da).(2.Sca - Sa)) + Sca.(1 - Da) + Dca.(1 - Sa)
1139 // otherwise if 8.Dca <= Da
1140 // Dca' = Dca.(Sa + (1 - Dca/Da).(2.Sca - Sa).(3 - 8.Dca/Da)) + Sca.(1 - Da) + Dca.(1 - Sa)
1141 // otherwise
1142 // Dca' = (Dca.Sa + ((Dca/Da)^(0.5).Da - Dca).(2.Sca - Sa)) + Sca.(1 - Da) + Dca.(1 - Sa)
1143 //
1144 // Da' = Sa + Da - Sa.Da
1145
1146 static AGG_INLINE void blend_pix(value_type* p,
1147 unsigned r, unsigned g, unsigned b,
1148 unsigned a, unsigned cover)
1149 {
1150 double sr = double(r * cover) / (base_mask * 255);
1151 double sg = double(g * cover) / (base_mask * 255);
1152 double sb = double(b * cover) / (base_mask * 255);
1153 double sa = double(a * cover) / (base_mask * 255);
1154 if(sa > 0)
1155 {
1156 double dr = double(p[Order::R]) / base_mask;
1157 double dg = double(p[Order::G]) / base_mask;
1158 double db = double(p[Order::B]) / base_mask;
1159 double da = double(p[Order::A] ? p[Order::A] : 1) / base_mask;
1160 if(cover < 255)
1161 {
1162 a = (a * cover + 255) >> 8;
1163 }
1164
1165 if(2*sr < sa) dr = dr*(sa + (1 - dr/da)*(2*sr - sa)) + sr*(1 - da) + dr*(1 - sa);
1166 else if(8*dr <= da) dr = dr*(sa + (1 - dr/da)*(2*sr - sa)*(3 - 8*dr/da)) + sr*(1 - da) + dr*(1 - sa);
1167 else dr = (dr*sa + (sqrt(dr/da)*da - dr)*(2*sr - sa)) + sr*(1 - da) + dr*(1 - sa);
1168
1169 if(2*sg < sa) dg = dg*(sa + (1 - dg/da)*(2*sg - sa)) + sg*(1 - da) + dg*(1 - sa);
1170 else if(8*dg <= da) dg = dg*(sa + (1 - dg/da)*(2*sg - sa)*(3 - 8*dg/da)) + sg*(1 - da) + dg*(1 - sa);
1171 else dg = (dg*sa + (sqrt(dg/da)*da - dg)*(2*sg - sa)) + sg*(1 - da) + dg*(1 - sa);
1172
1173 if(2*sb < sa) db = db*(sa + (1 - db/da)*(2*sb - sa)) + sb*(1 - da) + db*(1 - sa);
1174 else if(8*db <= da) db = db*(sa + (1 - db/da)*(2*sb - sa)*(3 - 8*db/da)) + sb*(1 - da) + db*(1 - sa);
1175 else db = (db*sa + (sqrt(db/da)*da - db)*(2*sb - sa)) + sb*(1 - da) + db*(1 - sa);
1176
1177 p[Order::R] = (value_type)uround(dr * base_mask);
1178 p[Order::G] = (value_type)uround(dg * base_mask);
1179 p[Order::B] = (value_type)uround(db * base_mask);
1180 p[Order::A] = (value_type)(a + p[Order::A] - ((a * p[Order::A] + base_mask) >> base_shift));
1181 }
1182 }
1183 };
1184
1185 //=====================================================comp_op_rgba_difference
1186 template<class ColorT, class Order> struct comp_op_rgba_difference
1187 {
1188 typedef ColorT color_type;
1189 typedef Order order_type;
1190 typedef typename color_type::value_type value_type;
1191 typedef typename color_type::calc_type calc_type;
1192 typedef typename color_type::long_type long_type;
1193 enum base_scale_e
1194 {
1195 base_shift = color_type::base_shift,
1196 base_scale = color_type::base_scale,
1197 base_mask = color_type::base_mask
1198 };
1199
1200 // Dca' = Sca + Dca - 2.min(Sca.Da, Dca.Sa)
1201 // Da' = Sa + Da - Sa.Da
1202 static AGG_INLINE void blend_pix(value_type* p,
1203 unsigned sr, unsigned sg, unsigned sb,
1204 unsigned sa, unsigned cover)
1205 {
1206 if(cover < 255)
1207 {
1208 sr = (sr * cover + 255) >> 8;
1209 sg = (sg * cover + 255) >> 8;
1210 sb = (sb * cover + 255) >> 8;
1211 sa = (sa * cover + 255) >> 8;
1212 }
1213 if(sa)
1214 {
1215 calc_type dr = p[Order::R];
1216 calc_type dg = p[Order::G];
1217 calc_type db = p[Order::B];
1218 calc_type da = p[Order::A];
1219 p[Order::R] = (value_type)(sr + dr - ((2 * sd_min(sr*da, dr*sa) + base_mask) >> base_shift));
1220 p[Order::G] = (value_type)(sg + dg - ((2 * sd_min(sg*da, dg*sa) + base_mask) >> base_shift));
1221 p[Order::B] = (value_type)(sb + db - ((2 * sd_min(sb*da, db*sa) + base_mask) >> base_shift));
1222 p[Order::A] = (value_type)(sa + da - ((sa * da + base_mask) >> base_shift));
1223 }
1224 }
1225 };
1226
1227 //=====================================================comp_op_rgba_exclusion
1228 template<class ColorT, class Order> struct comp_op_rgba_exclusion
1229 {
1230 typedef ColorT color_type;
1231 typedef Order order_type;
1232 typedef typename color_type::value_type value_type;
1233 typedef typename color_type::calc_type calc_type;
1234 typedef typename color_type::long_type long_type;
1235 enum base_scale_e
1236 {
1237 base_shift = color_type::base_shift,
1238 base_mask = color_type::base_mask
1239 };
1240
1241 // Dca' = (Sca.Da + Dca.Sa - 2.Sca.Dca) + Sca.(1 - Da) + Dca.(1 - Sa)
1242 // Da' = Sa + Da - Sa.Da
1243 static AGG_INLINE void blend_pix(value_type* p,
1244 unsigned sr, unsigned sg, unsigned sb,
1245 unsigned sa, unsigned cover)
1246 {
1247 if(cover < 255)
1248 {
1249 sr = (sr * cover + 255) >> 8;
1250 sg = (sg * cover + 255) >> 8;
1251 sb = (sb * cover + 255) >> 8;
1252 sa = (sa * cover + 255) >> 8;
1253 }
1254 if(sa)
1255 {
1256 calc_type d1a = base_mask - p[Order::A];
1257 calc_type s1a = base_mask - sa;
1258 calc_type dr = p[Order::R];
1259 calc_type dg = p[Order::G];
1260 calc_type db = p[Order::B];
1261 calc_type da = p[Order::A];
1262 p[Order::R] = (value_type)((sr*da + dr*sa - 2*sr*dr + sr*d1a + dr*s1a + base_mask) >> base_shift);
1263 p[Order::G] = (value_type)((sg*da + dg*sa - 2*sg*dg + sg*d1a + dg*s1a + base_mask) >> base_shift);
1264 p[Order::B] = (value_type)((sb*da + db*sa - 2*sb*db + sb*d1a + db*s1a + base_mask) >> base_shift);
1265 p[Order::A] = (value_type)(sa + da - ((sa * da + base_mask) >> base_shift));
1266 }
1267 }
1268 };
1269
1270 //=====================================================comp_op_rgba_contrast
1271 template<class ColorT, class Order> struct comp_op_rgba_contrast
1272 {
1273 typedef ColorT color_type;
1274 typedef Order order_type;
1275 typedef typename color_type::value_type value_type;
1276 typedef typename color_type::calc_type calc_type;
1277 typedef typename color_type::long_type long_type;
1278 enum base_scale_e
1279 {
1280 base_shift = color_type::base_shift,
1281 base_mask = color_type::base_mask
1282 };
1283
1284
1285 static AGG_INLINE void blend_pix(value_type* p,
1286 unsigned sr, unsigned sg, unsigned sb,
1287 unsigned sa, unsigned cover)
1288 {
1289 if(cover < 255)
1290 {
1291 sr = (sr * cover + 255) >> 8;
1292 sg = (sg * cover + 255) >> 8;
1293 sb = (sb * cover + 255) >> 8;
1294 sa = (sa * cover + 255) >> 8;
1295 }
1296 long_type dr = p[Order::R];
1297 long_type dg = p[Order::G];
1298 long_type db = p[Order::B];
1299 int da = p[Order::A];
1300 long_type d2a = da >> 1;
1301 unsigned s2a = sa >> 1;
1302
1303 int r = (int)((((dr - d2a) * int((sr - s2a)*2 + base_mask)) >> base_shift) + d2a);
1304 int g = (int)((((dg - d2a) * int((sg - s2a)*2 + base_mask)) >> base_shift) + d2a);
1305 int b = (int)((((db - d2a) * int((sb - s2a)*2 + base_mask)) >> base_shift) + d2a);
1306
1307 r = (r < 0) ? 0 : r;
1308 g = (g < 0) ? 0 : g;
1309 b = (b < 0) ? 0 : b;
1310
1311 p[Order::R] = (value_type)((r > da) ? da : r);
1312 p[Order::G] = (value_type)((g > da) ? da : g);
1313 p[Order::B] = (value_type)((b > da) ? da : b);
1314 }
1315 };
1316
1317 //=====================================================comp_op_rgba_invert
1318 template<class ColorT, class Order> struct comp_op_rgba_invert
1319 {
1320 typedef ColorT color_type;
1321 typedef Order order_type;
1322 typedef typename color_type::value_type value_type;
1323 typedef typename color_type::calc_type calc_type;
1324 typedef typename color_type::long_type long_type;
1325 enum base_scale_e
1326 {
1327 base_shift = color_type::base_shift,
1328 base_mask = color_type::base_mask
1329 };
1330
1331 // Dca' = (Da - Dca) * Sa + Dca.(1 - Sa)
1332 // Da' = Sa + Da - Sa.Da
1333 static AGG_INLINE void blend_pix(value_type* p,
1334 unsigned sr, unsigned sg, unsigned sb,
1335 unsigned sa, unsigned cover)
1336 {
1337 sa = (sa * cover + 255) >> 8;
1338 if(sa)
1339 {
1340 calc_type da = p[Order::A];
1341 calc_type dr = ((da - p[Order::R]) * sa + base_mask) >> base_shift;
1342 calc_type dg = ((da - p[Order::G]) * sa + base_mask) >> base_shift;
1343 calc_type db = ((da - p[Order::B]) * sa + base_mask) >> base_shift;
1344 calc_type s1a = base_mask - sa;
1345 p[Order::R] = (value_type)(dr + ((p[Order::R] * s1a + base_mask) >> base_shift));
1346 p[Order::G] = (value_type)(dg + ((p[Order::G] * s1a + base_mask) >> base_shift));
1347 p[Order::B] = (value_type)(db + ((p[Order::B] * s1a + base_mask) >> base_shift));
1348 p[Order::A] = (value_type)(sa + da - ((sa * da + base_mask) >> base_shift));
1349 }
1350 }
1351 };
1352
1353 //=================================================comp_op_rgba_invert_rgb
1354 template<class ColorT, class Order> struct comp_op_rgba_invert_rgb
1355 {
1356 typedef ColorT color_type;
1357 typedef Order order_type;
1358 typedef typename color_type::value_type value_type;
1359 typedef typename color_type::calc_type calc_type;
1360 typedef typename color_type::long_type long_type;
1361 enum base_scale_e
1362 {
1363 base_shift = color_type::base_shift,
1364 base_mask = color_type::base_mask
1365 };
1366
1367 // Dca' = (Da - Dca) * Sca + Dca.(1 - Sa)
1368 // Da' = Sa + Da - Sa.Da
1369 static AGG_INLINE void blend_pix(value_type* p,
1370 unsigned sr, unsigned sg, unsigned sb,
1371 unsigned sa, unsigned cover)
1372 {
1373 if(cover < 255)
1374 {
1375 sr = (sr * cover + 255) >> 8;
1376 sg = (sg * cover + 255) >> 8;
1377 sb = (sb * cover + 255) >> 8;
1378 sa = (sa * cover + 255) >> 8;
1379 }
1380 if(sa)
1381 {
1382 calc_type da = p[Order::A];
1383 calc_type dr = ((da - p[Order::R]) * sr + base_mask) >> base_shift;
1384 calc_type dg = ((da - p[Order::G]) * sg + base_mask) >> base_shift;
1385 calc_type db = ((da - p[Order::B]) * sb + base_mask) >> base_shift;
1386 calc_type s1a = base_mask - sa;
1387 p[Order::R] = (value_type)(dr + ((p[Order::R] * s1a + base_mask) >> base_shift));
1388 p[Order::G] = (value_type)(dg + ((p[Order::G] * s1a + base_mask) >> base_shift));
1389 p[Order::B] = (value_type)(db + ((p[Order::B] * s1a + base_mask) >> base_shift));
1390 p[Order::A] = (value_type)(sa + da - ((sa * da + base_mask) >> base_shift));
1391 }
1392 }
1393 };
1394
1395
1396
1397
1398
1399 //======================================================comp_op_table_rgba
1400 template<class ColorT, class Order> struct comp_op_table_rgba
1401 {
1402 typedef typename ColorT::value_type value_type;
1403 typedef void (*comp_op_func_type)(value_type* p,
1404 unsigned cr,
1405 unsigned cg,
1406 unsigned cb,
1407 unsigned ca,
1408 unsigned cover);
1409 static comp_op_func_type g_comp_op_func[];
1410 };
1411
1412 //==========================================================g_comp_op_func
1413 template<class ColorT, class Order>
1414 typename comp_op_table_rgba<ColorT, Order>::comp_op_func_type
1415 comp_op_table_rgba<ColorT, Order>::g_comp_op_func[] =
1416 {
1417 comp_op_rgba_clear <ColorT,Order>::blend_pix,
1418 comp_op_rgba_src <ColorT,Order>::blend_pix,
1419 comp_op_rgba_dst <ColorT,Order>::blend_pix,
1420 comp_op_rgba_src_over <ColorT,Order>::blend_pix,
1421 comp_op_rgba_dst_over <ColorT,Order>::blend_pix,
1422 comp_op_rgba_src_in <ColorT,Order>::blend_pix,
1423 comp_op_rgba_dst_in <ColorT,Order>::blend_pix,
1424 comp_op_rgba_src_out <ColorT,Order>::blend_pix,
1425 comp_op_rgba_dst_out <ColorT,Order>::blend_pix,
1426 comp_op_rgba_src_atop <ColorT,Order>::blend_pix,
1427 comp_op_rgba_dst_atop <ColorT,Order>::blend_pix,
1428 comp_op_rgba_xor <ColorT,Order>::blend_pix,
1429 comp_op_rgba_plus <ColorT,Order>::blend_pix,
1430 comp_op_rgba_minus <ColorT,Order>::blend_pix,
1431 comp_op_rgba_multiply <ColorT,Order>::blend_pix,
1432 comp_op_rgba_screen <ColorT,Order>::blend_pix,
1433 comp_op_rgba_overlay <ColorT,Order>::blend_pix,
1434 comp_op_rgba_darken <ColorT,Order>::blend_pix,
1435 comp_op_rgba_lighten <ColorT,Order>::blend_pix,
1436 comp_op_rgba_color_dodge<ColorT,Order>::blend_pix,
1437 comp_op_rgba_color_burn <ColorT,Order>::blend_pix,
1438 comp_op_rgba_hard_light <ColorT,Order>::blend_pix,
1439 comp_op_rgba_soft_light <ColorT,Order>::blend_pix,
1440 comp_op_rgba_difference <ColorT,Order>::blend_pix,
1441 comp_op_rgba_exclusion <ColorT,Order>::blend_pix,
1442 comp_op_rgba_contrast <ColorT,Order>::blend_pix,
1443 comp_op_rgba_invert <ColorT,Order>::blend_pix,
1444 comp_op_rgba_invert_rgb <ColorT,Order>::blend_pix,
1445 0
1446 };
1447
1448
1449 //==============================================================comp_op_e
1450 enum comp_op_e
1451 {
1452 comp_op_clear, //----comp_op_clear
1453 comp_op_src, //----comp_op_src
1454 comp_op_dst, //----comp_op_dst
1455 comp_op_src_over, //----comp_op_src_over
1456 comp_op_dst_over, //----comp_op_dst_over
1457 comp_op_src_in, //----comp_op_src_in
1458 comp_op_dst_in, //----comp_op_dst_in
1459 comp_op_src_out, //----comp_op_src_out
1460 comp_op_dst_out, //----comp_op_dst_out
1461 comp_op_src_atop, //----comp_op_src_atop
1462 comp_op_dst_atop, //----comp_op_dst_atop
1463 comp_op_xor, //----comp_op_xor
1464 comp_op_plus, //----comp_op_plus
1465 comp_op_minus, //----comp_op_minus
1466 comp_op_multiply, //----comp_op_multiply
1467 comp_op_screen, //----comp_op_screen
1468 comp_op_overlay, //----comp_op_overlay
1469 comp_op_darken, //----comp_op_darken
1470 comp_op_lighten, //----comp_op_lighten
1471 comp_op_color_dodge, //----comp_op_color_dodge
1472 comp_op_color_burn, //----comp_op_color_burn
1473 comp_op_hard_light, //----comp_op_hard_light
1474 comp_op_soft_light, //----comp_op_soft_light
1475 comp_op_difference, //----comp_op_difference
1476 comp_op_exclusion, //----comp_op_exclusion
1477 comp_op_contrast, //----comp_op_contrast
1478 comp_op_invert, //----comp_op_invert
1479 comp_op_invert_rgb, //----comp_op_invert_rgb
1480
1481 end_of_comp_op_e
1482 };
1483
1484
1485
1486
1487
1488
1489
1490 //====================================================comp_op_adaptor_rgba
1491 template<class ColorT, class Order> struct comp_op_adaptor_rgba
1492 {
1493 typedef Order order_type;
1494 typedef ColorT color_type;
1495 typedef typename color_type::value_type value_type;
1496 enum base_scale_e
1497 {
1498 base_shift = color_type::base_shift,
1499 base_mask = color_type::base_mask
1500 };
1501
1502 static AGG_INLINE void blend_pix(unsigned op, value_type* p,
1503 unsigned cr, unsigned cg, unsigned cb,
1504 unsigned ca,
1505 unsigned cover)
1506 {
1507 comp_op_table_rgba<ColorT, Order>::g_comp_op_func[op]
1508 (p, (cr * ca + base_mask) >> base_shift,
1509 (cg * ca + base_mask) >> base_shift,
1510 (cb * ca + base_mask) >> base_shift,
1511 ca, cover);
1512 }
1513 };
1514
1515 //=========================================comp_op_adaptor_clip_to_dst_rgba
1516 template<class ColorT, class Order> struct comp_op_adaptor_clip_to_dst_rgba
1517 {
1518 typedef Order order_type;
1519 typedef ColorT color_type;
1520 typedef typename color_type::value_type value_type;
1521 enum base_scale_e
1522 {
1523 base_shift = color_type::base_shift,
1524 base_mask = color_type::base_mask
1525 };
1526
1527 static AGG_INLINE void blend_pix(unsigned op, value_type* p,
1528 unsigned cr, unsigned cg, unsigned cb,
1529 unsigned ca,
1530 unsigned cover)
1531 {
1532 cr = (cr * ca + base_mask) >> base_shift;
1533 cg = (cg * ca + base_mask) >> base_shift;
1534 cb = (cb * ca + base_mask) >> base_shift;
1535 unsigned da = p[Order::A];
1536 comp_op_table_rgba<ColorT, Order>::g_comp_op_func[op]
1537 (p, (cr * da + base_mask) >> base_shift,
1538 (cg * da + base_mask) >> base_shift,
1539 (cb * da + base_mask) >> base_shift,
1540 (ca * da + base_mask) >> base_shift,
1541 cover);
1542 }
1543 };
1544
1545 //================================================comp_op_adaptor_rgba_pre
1546 template<class ColorT, class Order> struct comp_op_adaptor_rgba_pre
1547 {
1548 typedef Order order_type;
1549 typedef ColorT color_type;
1550 typedef typename color_type::value_type value_type;
1551 enum base_scale_e
1552 {
1553 base_shift = color_type::base_shift,
1554 base_mask = color_type::base_mask
1555 };
1556
1557 static AGG_INLINE void blend_pix(unsigned op, value_type* p,
1558 unsigned cr, unsigned cg, unsigned cb,
1559 unsigned ca,
1560 unsigned cover)
1561 {
1562 comp_op_table_rgba<ColorT, Order>::g_comp_op_func[op](p, cr, cg, cb, ca, cover);
1563 }
1564 };
1565
1566 //=====================================comp_op_adaptor_clip_to_dst_rgba_pre
1567 template<class ColorT, class Order> struct comp_op_adaptor_clip_to_dst_rgba_pre
1568 {
1569 typedef Order order_type;
1570 typedef ColorT color_type;
1571 typedef typename color_type::value_type value_type;
1572 enum base_scale_e
1573 {
1574 base_shift = color_type::base_shift,
1575 base_mask = color_type::base_mask
1576 };
1577
1578 static AGG_INLINE void blend_pix(unsigned op, value_type* p,
1579 unsigned cr, unsigned cg, unsigned cb,
1580 unsigned ca,
1581 unsigned cover)
1582 {
1583 unsigned da = p[Order::A];
1584 comp_op_table_rgba<ColorT, Order>::g_comp_op_func[op]
1585 (p, (cr * da + base_mask) >> base_shift,
1586 (cg * da + base_mask) >> base_shift,
1587 (cb * da + base_mask) >> base_shift,
1588 (ca * da + base_mask) >> base_shift,
1589 cover);
1590 }
1591 };
1592
1593 //=======================================================comp_adaptor_rgba
1594 template<class BlenderPre> struct comp_adaptor_rgba
1595 {
1596 typedef typename BlenderPre::order_type order_type;
1597 typedef typename BlenderPre::color_type color_type;
1598 typedef typename color_type::value_type value_type;
1599 enum base_scale_e
1600 {
1601 base_shift = color_type::base_shift,
1602 base_mask = color_type::base_mask
1603 };
1604
1605 static AGG_INLINE void blend_pix(unsigned op, value_type* p,
1606 unsigned cr, unsigned cg, unsigned cb,
1607 unsigned ca,
1608 unsigned cover)
1609 {
1610 BlenderPre::blend_pix(p,
1611 (cr * ca + base_mask) >> base_shift,
1612 (cg * ca + base_mask) >> base_shift,
1613 (cb * ca + base_mask) >> base_shift,
1614 ca, cover);
1615 }
1616 };
1617
1618 //==========================================comp_adaptor_clip_to_dst_rgba
1619 template<class BlenderPre> struct comp_adaptor_clip_to_dst_rgba
1620 {
1621 typedef typename BlenderPre::order_type order_type;
1622 typedef typename BlenderPre::color_type color_type;
1623 typedef typename color_type::value_type value_type;
1624 enum base_scale_e
1625 {
1626 base_shift = color_type::base_shift,
1627 base_mask = color_type::base_mask
1628 };
1629
1630 static AGG_INLINE void blend_pix(unsigned op, value_type* p,
1631 unsigned cr, unsigned cg, unsigned cb,
1632 unsigned ca,
1633 unsigned cover)
1634 {
1635 cr = (cr * ca + base_mask) >> base_shift;
1636 cg = (cg * ca + base_mask) >> base_shift;
1637 cb = (cb * ca + base_mask) >> base_shift;
1638 unsigned da = p[order_type::A];
1639 BlenderPre::blend_pix(p,
1640 (cr * da + base_mask) >> base_shift,
1641 (cg * da + base_mask) >> base_shift,
1642 (cb * da + base_mask) >> base_shift,
1643 (ca * da + base_mask) >> base_shift,
1644 cover);
1645 }
1646 };
1647
1648 //======================================comp_adaptor_clip_to_dst_rgba_pre
1649 template<class BlenderPre> struct comp_adaptor_clip_to_dst_rgba_pre
1650 {
1651 typedef typename BlenderPre::order_type order_type;
1652 typedef typename BlenderPre::color_type color_type;
1653 typedef typename color_type::value_type value_type;
1654 enum base_scale_e
1655 {
1656 base_shift = color_type::base_shift,
1657 base_mask = color_type::base_mask
1658 };
1659
1660 static AGG_INLINE void blend_pix(unsigned op, value_type* p,
1661 unsigned cr, unsigned cg, unsigned cb,
1662 unsigned ca,
1663 unsigned cover)
1664 {
1665 unsigned da = p[order_type::A];
1666 BlenderPre::blend_pix(p,
1667 (cr * da + base_mask) >> base_shift,
1668 (cg * da + base_mask) >> base_shift,
1669 (cb * da + base_mask) >> base_shift,
1670 (ca * da + base_mask) >> base_shift,
1671 cover);
1672 }
1673 };
1674
1675
1676
1677
1678
1679
1680 //===============================================copy_or_blend_rgba_wrapper
1681 template<class Blender> struct copy_or_blend_rgba_wrapper
1682 {
1683 typedef typename Blender::color_type color_type;
1684 typedef typename Blender::order_type order_type;
1685 typedef typename color_type::value_type value_type;
1686 typedef typename color_type::calc_type calc_type;
1687 enum base_scale_e
1688 {
1689 base_shift = color_type::base_shift,
1690 base_scale = color_type::base_scale,
1691 base_mask = color_type::base_mask
1692 };
1693
1694 //--------------------------------------------------------------------
1695 static AGG_INLINE void copy_or_blend_pix(value_type* p,
1696 unsigned cr, unsigned cg, unsigned cb,
1697 unsigned alpha)
1698 {
1699 if(alpha)
1700 {
1701 if(alpha == base_mask)
1702 {
1703 p[order_type::R] = cr;
1704 p[order_type::G] = cg;
1705 p[order_type::B] = cb;
1706 p[order_type::A] = base_mask;
1707 }
1708 else
1709 {
1710 Blender::blend_pix(p, cr, cg, cb, alpha);
1711 }
1712 }
1713 }
1714
1715 //--------------------------------------------------------------------
1716 static AGG_INLINE void copy_or_blend_pix(value_type* p,
1717 unsigned cr, unsigned cg, unsigned cb,
1718 unsigned alpha,
1719 unsigned cover)
1720 {
1721 if(cover == 255)
1722 {
1723 copy_or_blend_pix(p, cr, cg, cb, alpha);
1724 }
1725 else
1726 {
1727 if(alpha)
1728 {
1729 alpha = (alpha * (cover + 1)) >> 8;
1730 if(alpha == base_mask)
1731 {
1732 p[order_type::R] = cr;
1733 p[order_type::G] = cg;
1734 p[order_type::B] = cb;
1735 p[order_type::A] = base_mask;
1736 }
1737 else
1738 {
1739 Blender::blend_pix(p, cr, cg, cb, alpha, cover);
1740 }
1741 }
1742 }
1743 }
1744 };
1745
1746
1747
1748
1749
1750
1751 //=================================================pixfmt_alpha_blend_rgba
1752 template<class Blender, class RenBuf, class PixelT = int32u>
1753 class pixfmt_alpha_blend_rgba
1754 {
1755 public:
1756 typedef RenBuf rbuf_type;
1757 typedef typename rbuf_type::row_data row_data;
1758 typedef PixelT pixel_type;
1759 typedef Blender blender_type;
1760 typedef typename blender_type::color_type color_type;
1761 typedef typename blender_type::order_type order_type;
1762 typedef typename color_type::value_type value_type;
1763 typedef typename color_type::calc_type calc_type;
1764 typedef copy_or_blend_rgba_wrapper<blender_type> cob_type;
1765 enum base_scale_e
1766 {
1767 base_shift = color_type::base_shift,
1768 base_scale = color_type::base_scale,
1769 base_mask = color_type::base_mask,
1770 pix_width = sizeof(pixel_type)
1771 };
1772
1773 //--------------------------------------------------------------------
1774 pixfmt_alpha_blend_rgba() : m_rbuf(0) {}
1775 pixfmt_alpha_blend_rgba(rbuf_type& rb) : m_rbuf(&rb) {}
1776 void attach(rbuf_type& rb) { m_rbuf = &rb; }
1777
1778 //--------------------------------------------------------------------
1779 template<class PixFmt>
1780 bool attach(PixFmt& pixf, int x1, int y1, int x2, int y2)
1781 {
1782 rect_i r(x1, y1, x2, y2);
1783 if(r.clip(rect_i(0, 0, pixf.width()-1, pixf.height()-1)))
1784 {
1785 int stride = pixf.stride();
1786 m_rbuf->attach(pixf.pix_ptr(r.x1, stride < 0 ? r.y2 : r.y1),
1787 (r.x2 - r.x1) + 1,
1788 (r.y2 - r.y1) + 1,
1789 stride);
1790 return true;
1791 }
1792 return false;
1793 }
1794
1795 //--------------------------------------------------------------------
1796 AGG_INLINE unsigned width() const { return m_rbuf->width(); }
1797 AGG_INLINE unsigned height() const { return m_rbuf->height(); }
1798 AGG_INLINE int stride() const { return m_rbuf->stride(); }
1799
1800 //--------------------------------------------------------------------
1801 AGG_INLINE int8u* row_ptr(int y) { return m_rbuf->row_ptr(y); }
1802 AGG_INLINE const int8u* row_ptr(int y) const { return m_rbuf->row_ptr(y); }
1803 AGG_INLINE row_data row(int y) const { return m_rbuf->row(y); }
1804
1805 //--------------------------------------------------------------------
1806 AGG_INLINE int8u* pix_ptr(int x, int y)
1807 {
1808 return m_rbuf->row_ptr(y) + x * pix_width;
1809 }
1810
1811 AGG_INLINE const int8u* pix_ptr(int x, int y) const
1812 {
1813 return m_rbuf->row_ptr(y) + x * pix_width;
1814 }
1815
1816
1817 //--------------------------------------------------------------------
1818 AGG_INLINE static void make_pix(int8u* p, const color_type& c)
1819 {
1820 ((value_type*)p)[order_type::R] = c.r;
1821 ((value_type*)p)[order_type::G] = c.g;
1822 ((value_type*)p)[order_type::B] = c.b;
1823 ((value_type*)p)[order_type::A] = c.a;
1824 }
1825
1826 //--------------------------------------------------------------------
1827 AGG_INLINE color_type pixel(int x, int y) const
1828 {
1829 const value_type* p = (const value_type*)m_rbuf->row_ptr(y);
1830 if(p)
1831 {
1832 p += x << 2;
1833 return color_type(p[order_type::R],
1834 p[order_type::G],
1835 p[order_type::B],
1836 p[order_type::A]);
1837 }
1838 return color_type::no_color();
1839 }
1840
1841 //--------------------------------------------------------------------
1842 AGG_INLINE void copy_pixel(int x, int y, const color_type& c)
1843 {
1844 value_type* p = (value_type*)m_rbuf->row_ptr(x, y, 1) + (x << 2);
1845 p[order_type::R] = c.r;
1846 p[order_type::G] = c.g;
1847 p[order_type::B] = c.b;
1848 p[order_type::A] = c.a;
1849 }
1850
1851 //--------------------------------------------------------------------
1852 AGG_INLINE void blend_pixel(int x, int y, const color_type& c, int8u cover)
1853 {
1854 cob_type::copy_or_blend_pix(
1855 (value_type*)m_rbuf->row_ptr(x, y, 1) + (x << 2),
1856 c.r, c.g, c.b, c.a,
1857 cover);
1858 }
1859
1860
1861 //--------------------------------------------------------------------
1862 AGG_INLINE void copy_hline(int x, int y,
1863 unsigned len,
1864 const color_type& c)
1865 {
1866 value_type* p = (value_type*)m_rbuf->row_ptr(x, y, len) + (x << 2);
1867 pixel_type v;
1868 ((value_type*)&v)[order_type::R] = c.r;
1869 ((value_type*)&v)[order_type::G] = c.g;
1870 ((value_type*)&v)[order_type::B] = c.b;
1871 ((value_type*)&v)[order_type::A] = c.a;
1872 do
1873 {
1874 *(pixel_type*)p = v;
1875 p += 4;
1876 }
1877 while(--len);
1878 }
1879
1880
1881 //--------------------------------------------------------------------
1882 AGG_INLINE void copy_vline(int x, int y,
1883 unsigned len,
1884 const color_type& c)
1885 {
1886 pixel_type v;
1887 ((value_type*)&v)[order_type::R] = c.r;
1888 ((value_type*)&v)[order_type::G] = c.g;
1889 ((value_type*)&v)[order_type::B] = c.b;
1890 ((value_type*)&v)[order_type::A] = c.a;
1891 do
1892 {
1893 value_type* p = (value_type*)m_rbuf->row_ptr(x, y++, 1) + (x << 2);
1894 *(pixel_type*)p = v;
1895 }
1896 while(--len);
1897 }
1898
1899
1900 //--------------------------------------------------------------------
1901 void blend_hline(int x, int y,
1902 unsigned len,
1903 const color_type& c,
1904 int8u cover)
1905 {
1906 if (c.a)
1907 {
1908 value_type* p = (value_type*)m_rbuf->row_ptr(x, y, len) + (x << 2);
1909 calc_type alpha = (calc_type(c.a) * (cover + 1)) >> 8;
1910 if(alpha == base_mask)
1911 {
1912 pixel_type v;
1913 ((value_type*)&v)[order_type::R] = c.r;
1914 ((value_type*)&v)[order_type::G] = c.g;
1915 ((value_type*)&v)[order_type::B] = c.b;
1916 ((value_type*)&v)[order_type::A] = c.a;
1917 do
1918 {
1919 *(pixel_type*)p = v;
1920 p += 4;
1921 }
1922 while(--len);
1923 }
1924 else
1925 {
1926 if(cover == 255)
1927 {
1928 do
1929 {
1930 blender_type::blend_pix(p, c.r, c.g, c.b, alpha);
1931 p += 4;
1932 }
1933 while(--len);
1934 }
1935 else
1936 {
1937 do
1938 {
1939 blender_type::blend_pix(p, c.r, c.g, c.b, alpha, cover);
1940 p += 4;
1941 }
1942 while(--len);
1943 }
1944 }
1945 }
1946 }
1947
1948
1949 //--------------------------------------------------------------------
1950 void blend_vline(int x, int y,
1951 unsigned len,
1952 const color_type& c,
1953 int8u cover)
1954 {
1955 if (c.a)
1956 {
1957 value_type* p;
1958 calc_type alpha = (calc_type(c.a) * (cover + 1)) >> 8;
1959 if(alpha == base_mask)
1960 {
1961 pixel_type v;
1962 ((value_type*)&v)[order_type::R] = c.r;
1963 ((value_type*)&v)[order_type::G] = c.g;
1964 ((value_type*)&v)[order_type::B] = c.b;
1965 ((value_type*)&v)[order_type::A] = c.a;
1966 do
1967 {
1968 p = (value_type*)m_rbuf->row_ptr(x, y++, 1) + (x << 2);
1969 *(pixel_type*)p = v;
1970 }
1971 while(--len);
1972 }
1973 else
1974 {
1975 if(cover == 255)
1976 {
1977 do
1978 {
1979 p = (value_type*)m_rbuf->row_ptr(x, y++, 1) + (x << 2);
1980 blender_type::blend_pix(p, c.r, c.g, c.b, alpha);
1981 }
1982 while(--len);
1983 }
1984 else
1985 {
1986 do
1987 {
1988 p = (value_type*)m_rbuf->row_ptr(x, y++, 1) + (x << 2);
1989 blender_type::blend_pix(p, c.r, c.g, c.b, alpha, cover);
1990 }
1991 while(--len);
1992 }
1993 }
1994 }
1995 }
1996
1997
1998 //--------------------------------------------------------------------
1999 void blend_solid_hspan(int x, int y,
2000 unsigned len,
2001 const color_type& c,
2002 const int8u* covers)
2003 {
2004 if (c.a)
2005 {
2006 value_type* p = (value_type*)m_rbuf->row_ptr(x, y, len) + (x << 2);
2007 do
2008 {
2009 calc_type alpha = (calc_type(c.a) * (calc_type(*covers) + 1)) >> 8;
2010 if(alpha == base_mask)
2011 {
2012 p[order_type::R] = c.r;
2013 p[order_type::G] = c.g;
2014 p[order_type::B] = c.b;
2015 p[order_type::A] = base_mask;
2016 }
2017 else
2018 {
2019 blender_type::blend_pix(p, c.r, c.g, c.b, alpha, *covers);
2020 }
2021 p += 4;
2022 ++covers;
2023 }
2024 while(--len);
2025 }
2026 }
2027
2028
2029 //--------------------------------------------------------------------
2030 void blend_solid_vspan(int x, int y,
2031 unsigned len,
2032 const color_type& c,
2033 const int8u* covers)
2034 {
2035 if (c.a)
2036 {
2037 do
2038 {
2039 value_type* p = (value_type*)m_rbuf->row_ptr(x, y++, 1) + (x << 2);
2040 calc_type alpha = (calc_type(c.a) * (calc_type(*covers) + 1)) >> 8;
2041 if(alpha == base_mask)
2042 {
2043 p[order_type::R] = c.r;
2044 p[order_type::G] = c.g;
2045 p[order_type::B] = c.b;
2046 p[order_type::A] = base_mask;
2047 }
2048 else
2049 {
2050 blender_type::blend_pix(p, c.r, c.g, c.b, alpha, *covers);
2051 }
2052 ++covers;
2053 }
2054 while(--len);
2055 }
2056 }
2057
2058
2059 //--------------------------------------------------------------------
2060 void copy_color_hspan(int x, int y,
2061 unsigned len,
2062 const color_type* colors)
2063 {
2064 value_type* p = (value_type*)m_rbuf->row_ptr(x, y, len) + (x << 2);
2065 do
2066 {
2067 p[order_type::R] = colors->r;
2068 p[order_type::G] = colors->g;
2069 p[order_type::B] = colors->b;
2070 p[order_type::A] = colors->a;
2071 ++colors;
2072 p += 4;
2073 }
2074 while(--len);
2075 }
2076
2077
2078 //--------------------------------------------------------------------
2079 void copy_color_vspan(int x, int y,
2080 unsigned len,
2081 const color_type* colors)
2082 {
2083 do
2084 {
2085 value_type* p = (value_type*)m_rbuf->row_ptr(x, y++, 1) + (x << 2);
2086 p[order_type::R] = colors->r;
2087 p[order_type::G] = colors->g;
2088 p[order_type::B] = colors->b;
2089 p[order_type::A] = colors->a;
2090 ++colors;
2091 }
2092 while(--len);
2093 }
2094
2095
2096 //--------------------------------------------------------------------
2097 void blend_color_hspan(int x, int y,
2098 unsigned len,
2099 const color_type* colors,
2100 const int8u* covers,
2101 int8u cover)
2102 {
2103 value_type* p = (value_type*)m_rbuf->row_ptr(x, y, len) + (x << 2);
2104 if(covers)
2105 {
2106 do
2107 {
2108 cob_type::copy_or_blend_pix(p,
2109 colors->r,
2110 colors->g,
2111 colors->b,
2112 colors->a,
2113 *covers++);
2114 p += 4;
2115 ++colors;
2116 }
2117 while(--len);
2118 }
2119 else
2120 {
2121 if(cover == 255)
2122 {
2123 do
2124 {
2125 cob_type::copy_or_blend_pix(p,
2126 colors->r,
2127 colors->g,
2128 colors->b,
2129 colors->a);
2130 p += 4;
2131 ++colors;
2132 }
2133 while(--len);
2134 }
2135 else
2136 {
2137 do
2138 {
2139 cob_type::copy_or_blend_pix(p,
2140 colors->r,
2141 colors->g,
2142 colors->b,
2143 colors->a,
2144 cover);
2145 p += 4;
2146 ++colors;
2147 }
2148 while(--len);
2149 }
2150 }
2151 }
2152
2153
2154
2155 //--------------------------------------------------------------------
2156 void blend_color_vspan(int x, int y,
2157 unsigned len,
2158 const color_type* colors,
2159 const int8u* covers,
2160 int8u cover)
2161 {
2162 value_type* p;
2163 if(covers)
2164 {
2165 do
2166 {
2167 p = (value_type*)m_rbuf->row_ptr(x, y++, 1) + (x << 2);
2168 cob_type::copy_or_blend_pix(p,
2169 colors->r,
2170 colors->g,
2171 colors->b,
2172 colors->a,
2173 *covers++);
2174 ++colors;
2175 }
2176 while(--len);
2177 }
2178 else
2179 {
2180 if(cover == 255)
2181 {
2182 do
2183 {
2184 p = (value_type*)m_rbuf->row_ptr(x, y++, 1) + (x << 2);
2185 cob_type::copy_or_blend_pix(p,
2186 colors->r,
2187 colors->g,
2188 colors->b,
2189 colors->a);
2190 ++colors;
2191 }
2192 while(--len);
2193 }
2194 else
2195 {
2196 do
2197 {
2198 p = (value_type*)m_rbuf->row_ptr(x, y++, 1) + (x << 2);
2199 cob_type::copy_or_blend_pix(p,
2200 colors->r,
2201 colors->g,
2202 colors->b,
2203 colors->a,
2204 cover);
2205 ++colors;
2206 }
2207 while(--len);
2208 }
2209 }
2210 }
2211
2212 //--------------------------------------------------------------------
2213 template<class Function> void for_each_pixel(Function f)
2214 {
2215 unsigned y;
2216 for(y = 0; y < height(); ++y)
2217 {
2218 row_data r = m_rbuf->row(y);
2219 if(r.ptr)
2220 {
2221 unsigned len = r.x2 - r.x1 + 1;
2222 value_type* p =
2223 (value_type*)m_rbuf->row_ptr(r.x1, y, len) + (r.x1 << 2);
2224 do
2225 {
2226 f(p);
2227 p += 4;
2228 }
2229 while(--len);
2230 }
2231 }
2232 }
2233
2234 //--------------------------------------------------------------------
2235 void premultiply()
2236 {
2237 for_each_pixel(multiplier_rgba<color_type, order_type>::premultiply);
2238 }
2239
2240 //--------------------------------------------------------------------
2241 void demultiply()
2242 {
2243 for_each_pixel(multiplier_rgba<color_type, order_type>::demultiply);
2244 }
2245
2246 //--------------------------------------------------------------------
2247 template<class GammaLut> void apply_gamma_dir(const GammaLut& g)
2248 {
2249 for_each_pixel(apply_gamma_dir_rgba<color_type, order_type, GammaLut>(g));
2250 }
2251
2252 //--------------------------------------------------------------------
2253 template<class GammaLut> void apply_gamma_inv(const GammaLut& g)
2254 {
2255 for_each_pixel(apply_gamma_inv_rgba<color_type, order_type, GammaLut>(g));
2256 }
2257
2258 //--------------------------------------------------------------------
2259 template<class RenBuf2> void copy_from(const RenBuf2& from,
2260 int xdst, int ydst,
2261 int xsrc, int ysrc,
2262 unsigned len)
2263 {
2264 const int8u* p = from.row_ptr(ysrc);
2265 if(p)
2266 {
2267 memmove(m_rbuf->row_ptr(xdst, ydst, len) + xdst * pix_width,
2268 p + xsrc * pix_width,
2269 len * pix_width);
2270 }
2271 }
2272
2273 //--------------------------------------------------------------------
2274 template<class SrcPixelFormatRenderer>
2275 void blend_from(const SrcPixelFormatRenderer& from,
2276 int xdst, int ydst,
2277 int xsrc, int ysrc,
2278 unsigned len,
2279 int8u cover)
2280 {
2281 typedef typename SrcPixelFormatRenderer::order_type src_order;
2282 const value_type* psrc = (value_type*)from.row_ptr(ysrc);
2283 if(psrc)
2284 {
2285 psrc += xsrc << 2;
2286 value_type* pdst =
2287 (value_type*)m_rbuf->row_ptr(xdst, ydst, len) + (xdst << 2);
2288 int incp = 4;
2289 if(xdst > xsrc)
2290 {
2291 psrc += (len-1) << 2;
2292 pdst += (len-1) << 2;
2293 incp = -4;
2294 }
2295
2296 if(cover == 255)
2297 {
2298 do
2299 {
2300 cob_type::copy_or_blend_pix(pdst,
2301 psrc[src_order::R],
2302 psrc[src_order::G],
2303 psrc[src_order::B],
2304 psrc[src_order::A]);
2305 psrc += incp;
2306 pdst += incp;
2307 }
2308 while(--len);
2309 }
2310 else
2311 {
2312 do
2313 {
2314 cob_type::copy_or_blend_pix(pdst,
2315 psrc[src_order::R],
2316 psrc[src_order::G],
2317 psrc[src_order::B],
2318 psrc[src_order::A],
2319 cover);
2320 psrc += incp;
2321 pdst += incp;
2322 }
2323 while(--len);
2324 }
2325 }
2326 }
2327
2328 private:
2329 rbuf_type* m_rbuf;
2330 };
2331
2332
2333
2334
2335 //================================================pixfmt_custom_blend_rgba
2336 template<class Blender, class RenBuf> class pixfmt_custom_blend_rgba
2337 {
2338 public:
2339 typedef RenBuf rbuf_type;
2340 typedef typename rbuf_type::row_data row_data;
2341 typedef Blender blender_type;
2342 typedef typename blender_type::color_type color_type;
2343 typedef typename blender_type::order_type order_type;
2344 typedef typename color_type::value_type value_type;
2345 typedef typename color_type::calc_type calc_type;
2346 enum base_scale_e
2347 {
2348 base_shift = color_type::base_shift,
2349 base_scale = color_type::base_scale,
2350 base_mask = color_type::base_mask,
2351 pix_width = sizeof(value_type) * 4
2352 };
2353
2354
2355 //--------------------------------------------------------------------
2356 pixfmt_custom_blend_rgba() : m_rbuf(0), m_comp_op(3) {}
2357 pixfmt_custom_blend_rgba(rbuf_type& rb, unsigned comp_op=3) :
2358 m_rbuf(&rb),
2359 m_comp_op(comp_op)
2360 {}
2361 void attach(rbuf_type& rb) { m_rbuf = &rb; }
2362
2363 //--------------------------------------------------------------------
2364 template<class PixFmt>
2365 bool attach(PixFmt& pixf, int x1, int y1, int x2, int y2)
2366 {
2367 rect_i r(x1, y1, x2, y2);
2368 if(r.clip(rect_i(0, 0, pixf.width()-1, pixf.height()-1)))
2369 {
2370 int stride = pixf.stride();
2371 m_rbuf->attach(pixf.pix_ptr(r.x1, stride < 0 ? r.y2 : r.y1),
2372 (r.x2 - r.x1) + 1,
2373 (r.y2 - r.y1) + 1,
2374 stride);
2375 return true;
2376 }
2377 return false;
2378 }
2379
2380 //--------------------------------------------------------------------
2381 AGG_INLINE unsigned width() const { return m_rbuf->width(); }
2382 AGG_INLINE unsigned height() const { return m_rbuf->height(); }
2383 AGG_INLINE int stride() const { return m_rbuf->stride(); }
2384
2385 //--------------------------------------------------------------------
2386 AGG_INLINE int8u* row_ptr(int y) { return m_rbuf->row_ptr(y); }
2387 AGG_INLINE const int8u* row_ptr(int y) const { return m_rbuf->row_ptr(y); }
2388 AGG_INLINE row_data row(int y) const { return m_rbuf->row(y); }
2389
2390 //--------------------------------------------------------------------
2391 AGG_INLINE int8u* pix_ptr(int x, int y)
2392 {
2393 return m_rbuf->row_ptr(y) + x * pix_width;
2394 }
2395
2396 AGG_INLINE const int8u* pix_ptr(int x, int y) const
2397 {
2398 return m_rbuf->row_ptr(y) + x * pix_width;
2399 }
2400
2401 //--------------------------------------------------------------------
2402 void comp_op(unsigned op) { m_comp_op = op; }
2403 unsigned comp_op() const { return m_comp_op; }
2404
2405 //--------------------------------------------------------------------
2406 AGG_INLINE static void make_pix(int8u* p, const color_type& c)
2407 {
2408 ((value_type*)p)[order_type::R] = c.r;
2409 ((value_type*)p)[order_type::G] = c.g;
2410 ((value_type*)p)[order_type::B] = c.b;
2411 ((value_type*)p)[order_type::A] = c.a;
2412 }
2413
2414 //--------------------------------------------------------------------
2415 color_type pixel(int x, int y) const
2416 {
2417 const value_type* p = (value_type*)m_rbuf->row_ptr(y) + (x << 2);
2418 return color_type(p[order_type::R],
2419 p[order_type::G],
2420 p[order_type::B],
2421 p[order_type::A]);
2422 }
2423
2424 //--------------------------------------------------------------------
2425 void copy_pixel(int x, int y, const color_type& c)
2426 {
2427 blender_type::blend_pix(
2428 m_comp_op,
2429 (value_type*)m_rbuf->row_ptr(x, y, 1) + (x << 2),
2430 c.r, c.g, c.b, c.a, 255);
2431 }
2432
2433 //--------------------------------------------------------------------
2434 void blend_pixel(int x, int y, const color_type& c, int8u cover)
2435 {
2436 blender_type::blend_pix(
2437 m_comp_op,
2438 (value_type*)m_rbuf->row_ptr(x, y, 1) + (x << 2),
2439 c.r, c.g, c.b, c.a,
2440 cover);
2441 }
2442
2443 //--------------------------------------------------------------------
2444 void copy_hline(int x, int y, unsigned len, const color_type& c)
2445 {
2446 value_type* p = (value_type*)m_rbuf->row_ptr(x, y, len) + (x << 2);;
2447 do
2448 {
2449 blender_type::blend_pix(m_comp_op, p, c.r, c.g, c.b, c.a, 255);
2450 p += 4;
2451 }
2452 while(--len);
2453 }
2454
2455 //--------------------------------------------------------------------
2456 void copy_vline(int x, int y, unsigned len, const color_type& c)
2457 {
2458 do
2459 {
2460 blender_type::blend_pix(
2461 m_comp_op,
2462 (value_type*)m_rbuf->row_ptr(x, y++, 1) + (x << 2),
2463 c.r, c.g, c.b, c.a, 255);
2464 }
2465 while(--len);
2466 }
2467
2468 //--------------------------------------------------------------------
2469 void blend_hline(int x, int y, unsigned len,
2470 const color_type& c, int8u cover)
2471 {
2472
2473 value_type* p = (value_type*)m_rbuf->row_ptr(x, y, len) + (x << 2);
2474 do
2475 {
2476 blender_type::blend_pix(m_comp_op, p, c.r, c.g, c.b, c.a, cover);
2477 p += 4;
2478 }
2479 while(--len);
2480 }
2481
2482 //--------------------------------------------------------------------
2483 void blend_vline(int x, int y, unsigned len,
2484 const color_type& c, int8u cover)
2485 {
2486
2487 do
2488 {
2489 blender_type::blend_pix(
2490 m_comp_op,
2491 (value_type*)m_rbuf->row_ptr(x, y++, 1) + (x << 2),
2492 c.r, c.g, c.b, c.a,
2493 cover);
2494 }
2495 while(--len);
2496 }
2497
2498 //--------------------------------------------------------------------
2499 void blend_solid_hspan(int x, int y, unsigned len,
2500 const color_type& c, const int8u* covers)
2501 {
2502 value_type* p = (value_type*)m_rbuf->row_ptr(x, y, len) + (x << 2);
2503 do
2504 {
2505 blender_type::blend_pix(m_comp_op,
2506 p, c.r, c.g, c.b, c.a,
2507 *covers++);
2508 p += 4;
2509 }
2510 while(--len);
2511 }
2512
2513 //--------------------------------------------------------------------
2514 void blend_solid_vspan(int x, int y, unsigned len,
2515 const color_type& c, const int8u* covers)
2516 {
2517 do
2518 {
2519 blender_type::blend_pix(
2520 m_comp_op,
2521 (value_type*)m_rbuf->row_ptr(x, y++, 1) + (x << 2),
2522 c.r, c.g, c.b, c.a,
2523 *covers++);
2524 }
2525 while(--len);
2526 }
2527
2528 //--------------------------------------------------------------------
2529 void copy_color_hspan(int x, int y,
2530 unsigned len,
2531 const color_type* colors)
2532 {
2533
2534 value_type* p = (value_type*)m_rbuf->row_ptr(x, y, len) + (x << 2);
2535 do
2536 {
2537 p[order_type::R] = colors->r;
2538 p[order_type::G] = colors->g;
2539 p[order_type::B] = colors->b;
2540 p[order_type::A] = colors->a;
2541 ++colors;
2542 p += 4;
2543 }
2544 while(--len);
2545 }
2546
2547 //--------------------------------------------------------------------
2548 void copy_color_vspan(int x, int y,
2549 unsigned len,
2550 const color_type* colors)
2551 {
2552 do
2553 {
2554 value_type* p = (value_type*)m_rbuf->row_ptr(x, y++, 1) + (x << 2);
2555 p[order_type::R] = colors->r;
2556 p[order_type::G] = colors->g;
2557 p[order_type::B] = colors->b;
2558 p[order_type::A] = colors->a;
2559 ++colors;
2560 }
2561 while(--len);
2562 }
2563
2564 //--------------------------------------------------------------------
2565 void blend_color_hspan(int x, int y, unsigned len,
2566 const color_type* colors,
2567 const int8u* covers,
2568 int8u cover)
2569 {
2570 value_type* p = (value_type*)m_rbuf->row_ptr(x, y, len) + (x << 2);
2571 do
2572 {
2573 blender_type::blend_pix(m_comp_op,
2574 p,
2575 colors->r,
2576 colors->g,
2577 colors->b,
2578 colors->a,
2579 covers ? *covers++ : cover);
2580 p += 4;
2581 ++colors;
2582 }
2583 while(--len);
2584 }
2585
2586 //--------------------------------------------------------------------
2587 void blend_color_vspan(int x, int y, unsigned len,
2588 const color_type* colors,
2589 const int8u* covers,
2590 int8u cover)
2591 {
2592 do
2593 {
2594 blender_type::blend_pix(
2595 m_comp_op,
2596 (value_type*)m_rbuf->row_ptr(x, y++, 1) + (x << 2),
2597 colors->r,
2598 colors->g,
2599 colors->b,
2600 colors->a,
2601 covers ? *covers++ : cover);
2602 ++colors;
2603 }
2604 while(--len);
2605
2606 }
2607
2608 //--------------------------------------------------------------------
2609 template<class Function> void for_each_pixel(Function f)
2610 {
2611 unsigned y;
2612 for(y = 0; y < height(); ++y)
2613 {
2614 row_data r = m_rbuf->row(y);
2615 if(r.ptr)
2616 {
2617 unsigned len = r.x2 - r.x1 + 1;
2618 value_type* p =
2619 (value_type*)m_rbuf->row_ptr(r.x1, y, len) + (r.x1 << 2);
2620 do
2621 {
2622 f(p);
2623 p += 4;
2624 }
2625 while(--len);
2626 }
2627 }
2628 }
2629
2630 //--------------------------------------------------------------------
2631 void premultiply()
2632 {
2633 for_each_pixel(multiplier_rgba<color_type, order_type>::premultiply);
2634 }
2635
2636 //--------------------------------------------------------------------
2637 void demultiply()
2638 {
2639 for_each_pixel(multiplier_rgba<color_type, order_type>::demultiply);
2640 }
2641
2642 //--------------------------------------------------------------------
2643 template<class GammaLut> void apply_gamma_dir(const GammaLut& g)
2644 {
2645 for_each_pixel(apply_gamma_dir_rgba<color_type, order_type, GammaLut>(g));
2646 }
2647
2648 //--------------------------------------------------------------------
2649 template<class GammaLut> void apply_gamma_inv(const GammaLut& g)
2650 {
2651 for_each_pixel(apply_gamma_inv_rgba<color_type, order_type, GammaLut>(g));
2652 }
2653
2654 //--------------------------------------------------------------------
2655 template<class RenBuf2> void copy_from(const RenBuf2& from,
2656 int xdst, int ydst,
2657 int xsrc, int ysrc,
2658 unsigned len)
2659 {
2660 const int8u* p = from.row_ptr(ysrc);
2661 if(p)
2662 {
2663 memmove(m_rbuf->row_ptr(xdst, ydst, len) + xdst * pix_width,
2664 p + xsrc * pix_width,
2665 len * pix_width);
2666 }
2667 }
2668
2669 //--------------------------------------------------------------------
2670 template<class SrcPixelFormatRenderer>
2671 void blend_from(const SrcPixelFormatRenderer& from,
2672 int xdst, int ydst,
2673 int xsrc, int ysrc,
2674 unsigned len,
2675 int8u cover)
2676 {
2677 typedef typename SrcPixelFormatRenderer::order_type src_order;
2678 const value_type* psrc = (const value_type*)from.row_ptr(ysrc);
2679 if(psrc)
2680 {
2681 psrc += xsrc << 2;
2682 value_type* pdst =
2683 (value_type*)m_rbuf->row_ptr(xdst, ydst, len) + (xdst << 2);
2684
2685 int incp = 4;
2686 if(xdst > xsrc)
2687 {
2688 psrc += (len-1) << 2;
2689 pdst += (len-1) << 2;
2690 incp = -4;
2691 }
2692
2693 do
2694 {
2695 blender_type::blend_pix(m_comp_op,
2696 pdst,
2697 psrc[src_order::R],
2698 psrc[src_order::G],
2699 psrc[src_order::B],
2700 psrc[src_order::A],
2701 cover);
2702 psrc += incp;
2703 pdst += incp;
2704 }
2705 while(--len);
2706 }
2707 }
2708
2709 private:
2710 rbuf_type* m_rbuf;
2711 unsigned m_comp_op;
2712 };
2713
2714
2715
2716
2717 //-----------------------------------------------------------------------
2718 typedef blender_rgba<rgba8, order_rgba> blender_rgba32; //----blender_rgba32
2719 typedef blender_rgba<rgba8, order_argb> blender_argb32; //----blender_argb32
2720 typedef blender_rgba<rgba8, order_abgr> blender_abgr32; //----blender_abgr32
2721 typedef blender_rgba<rgba8, order_bgra> blender_bgra32; //----blender_bgra32
2722
2723 typedef blender_rgba_pre<rgba8, order_rgba> blender_rgba32_pre; //----blender_rgba32_pre
2724 typedef blender_rgba_pre<rgba8, order_argb> blender_argb32_pre; //----blender_argb32_pre
2725 typedef blender_rgba_pre<rgba8, order_abgr> blender_abgr32_pre; //----blender_abgr32_pre
2726 typedef blender_rgba_pre<rgba8, order_bgra> blender_bgra32_pre; //----blender_bgra32_pre
2727
2728 typedef blender_rgba_plain<rgba8, order_rgba> blender_rgba32_plain; //----blender_rgba32_plain
2729 typedef blender_rgba_plain<rgba8, order_argb> blender_argb32_plain; //----blender_argb32_plain
2730 typedef blender_rgba_plain<rgba8, order_abgr> blender_abgr32_plain; //----blender_abgr32_plain
2731 typedef blender_rgba_plain<rgba8, order_bgra> blender_bgra32_plain; //----blender_bgra32_plain
2732
2733 typedef blender_rgba<rgba16, order_rgba> blender_rgba64; //----blender_rgba64
2734 typedef blender_rgba<rgba16, order_argb> blender_argb64; //----blender_argb64
2735 typedef blender_rgba<rgba16, order_abgr> blender_abgr64; //----blender_abgr64
2736 typedef blender_rgba<rgba16, order_bgra> blender_bgra64; //----blender_bgra64
2737
2738 typedef blender_rgba_pre<rgba16, order_rgba> blender_rgba64_pre; //----blender_rgba64_pre
2739 typedef blender_rgba_pre<rgba16, order_argb> blender_argb64_pre; //----blender_argb64_pre
2740 typedef blender_rgba_pre<rgba16, order_abgr> blender_abgr64_pre; //----blender_abgr64_pre
2741 typedef blender_rgba_pre<rgba16, order_bgra> blender_bgra64_pre; //----blender_bgra64_pre
2742
2743
2744 //-----------------------------------------------------------------------
2745 typedef int32u pixel32_type;
2746 typedef pixfmt_alpha_blend_rgba<blender_rgba32, rendering_buffer, pixel32_type> pixfmt_rgba32; //----pixfmt_rgba32
2747 typedef pixfmt_alpha_blend_rgba<blender_argb32, rendering_buffer, pixel32_type> pixfmt_argb32; //----pixfmt_argb32
2748 typedef pixfmt_alpha_blend_rgba<blender_abgr32, rendering_buffer, pixel32_type> pixfmt_abgr32; //----pixfmt_abgr32
2749 typedef pixfmt_alpha_blend_rgba<blender_bgra32, rendering_buffer, pixel32_type> pixfmt_bgra32; //----pixfmt_bgra32
2750
2751 typedef pixfmt_alpha_blend_rgba<blender_rgba32_pre, rendering_buffer, pixel32_type> pixfmt_rgba32_pre; //----pixfmt_rgba32_pre
2752 typedef pixfmt_alpha_blend_rgba<blender_argb32_pre, rendering_buffer, pixel32_type> pixfmt_argb32_pre; //----pixfmt_argb32_pre
2753 typedef pixfmt_alpha_blend_rgba<blender_abgr32_pre, rendering_buffer, pixel32_type> pixfmt_abgr32_pre; //----pixfmt_abgr32_pre
2754 typedef pixfmt_alpha_blend_rgba<blender_bgra32_pre, rendering_buffer, pixel32_type> pixfmt_bgra32_pre; //----pixfmt_bgra32_pre
2755
2756 typedef pixfmt_alpha_blend_rgba<blender_rgba32_plain, rendering_buffer, pixel32_type> pixfmt_rgba32_plain; //----pixfmt_rgba32_plain
2757 typedef pixfmt_alpha_blend_rgba<blender_argb32_plain, rendering_buffer, pixel32_type> pixfmt_argb32_plain; //----pixfmt_argb32_plain
2758 typedef pixfmt_alpha_blend_rgba<blender_abgr32_plain, rendering_buffer, pixel32_type> pixfmt_abgr32_plain; //----pixfmt_abgr32_plain
2759 typedef pixfmt_alpha_blend_rgba<blender_bgra32_plain, rendering_buffer, pixel32_type> pixfmt_bgra32_plain; //----pixfmt_bgra32_plain
2760
2761 struct pixel64_type { int16u c[4]; };
2762 typedef pixfmt_alpha_blend_rgba<blender_rgba64, rendering_buffer, pixel64_type> pixfmt_rgba64; //----pixfmt_rgba64
2763 typedef pixfmt_alpha_blend_rgba<blender_argb64, rendering_buffer, pixel64_type> pixfmt_argb64; //----pixfmt_argb64
2764 typedef pixfmt_alpha_blend_rgba<blender_abgr64, rendering_buffer, pixel64_type> pixfmt_abgr64; //----pixfmt_abgr64
2765 typedef pixfmt_alpha_blend_rgba<blender_bgra64, rendering_buffer, pixel64_type> pixfmt_bgra64; //----pixfmt_bgra64
2766
2767 typedef pixfmt_alpha_blend_rgba<blender_rgba64_pre, rendering_buffer, pixel64_type> pixfmt_rgba64_pre; //----pixfmt_rgba64_pre
2768 typedef pixfmt_alpha_blend_rgba<blender_argb64_pre, rendering_buffer, pixel64_type> pixfmt_argb64_pre; //----pixfmt_argb64_pre
2769 typedef pixfmt_alpha_blend_rgba<blender_abgr64_pre, rendering_buffer, pixel64_type> pixfmt_abgr64_pre; //----pixfmt_abgr64_pre
2770 typedef pixfmt_alpha_blend_rgba<blender_bgra64_pre, rendering_buffer, pixel64_type> pixfmt_bgra64_pre; //----pixfmt_bgra64_pre
2771 }
2772
2773 #endif
2774
Clone of Haiku svn repository