libs/agg/agg_pixfmt_rgba.h

276                                          unsigned sa, unsigned cover)
284                 p[Order::A] = (value_type)(((p[Order::A] * alpha + 255) >> 8) + ((sa * cover + 255) >> 8));
291                 p[Order::A] = sa;
327                                          unsigned sa, unsigned cover)
334                 sa = (sa * cover + 255) >> 8;
336             calc_type s1a = base_mask - sa;
340             p[Order::A] = (value_type)(sa + p[Order::A] - ((sa * p[Order::A] + base_mask) >> base_shift));
361                                          unsigned sa, unsigned cover)
368                 sa = (sa * cover + 255) >> 8;
374             p[Order::A] = (value_type)(sa + p[Order::A] - ((sa * p[Order::A] + base_mask) >> base_shift));
395                                          unsigned sa, unsigned cover)
404                 p[Order::A] = (value_type)(((p[Order::A] * alpha + 255) >> 8) + ((((sa * da + base_mask) >> base_shift) * cover + 255) >> 8));
411                 p[Order::A] = (value_type)((sa * da + base_mask) >> base_shift);
433                                          unsigned sa, unsigned cover)
437                 sa = base_mask - ((cover * (base_mask - sa) + 255) >> 8);
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);
463                                          unsigned sa, unsigned cover)
472                 p[Order::A] = (value_type)(((p[Order::A] * alpha + 255) >> 8) + ((((sa * da + base_mask) >> base_shift) * cover + 255) >> 8));
479                 p[Order::A] = (value_type)((sa * da + base_mask) >> base_shift);
501                                          unsigned sa, unsigned cover)
505                 sa = (sa * cover + 255) >> 8;
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);
532                                          unsigned sa, unsigned cover)
539                 sa = (sa * cover + 255) >> 8;
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);
566                                          unsigned sa, unsigned 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;
578                 p[Order::A] = (value_type)(((p[Order::A] * alpha + 255) >> 8) + ((sa * cover + 255) >> 8));
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;
608                                          unsigned sa, unsigned cover)
615                 sa = (sa * cover + 255) >> 8;
617             if(sa)
619                 calc_type s1a = base_mask - sa;
624                 p[Order::A] = (value_type)(sa + p[Order::A] - ((sa * p[Order::A] + base_mask/2) >> (base_shift - 1)));
646                                          unsigned sa, unsigned cover)
653                 sa = (sa * cover + 255) >> 8;
655             if(sa)
660                 calc_type da = p[Order::A] + sa;
686                                          unsigned sa, unsigned cover)
693                 sa = (sa * cover + 255) >> 8;
695             if(sa)
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));
726                                          unsigned sa, unsigned cover)
733                 sa = (sa * cover + 255) >> 8;
735             if(sa)
737                 calc_type s1a = base_mask - sa;
745                 p[Order::A] = (value_type)(sa + p[Order::A] - ((sa * p[Order::A] + base_mask) >> base_shift));
767                                          unsigned sa, unsigned cover)
774                 sa = (sa * cover + 255) >> 8;
776             if(sa)
785                 p[Order::A] = (value_type)(sa + da - ((sa * da + base_mask) >> base_shift));
811                                          unsigned sa, unsigned cover)
818                 sa = (sa * cover + 255) >> 8;
820             if(sa)
823                 calc_type s1a  = base_mask - sa;
828                 calc_type sada = sa * p[Order::A];
832                     sada - 2*(da - dr)*(sa - sr) + sr*d1a + dr*s1a + base_mask) >> base_shift);
836                     sada - 2*(da - dg)*(sa - sg) + sg*d1a + dg*s1a + base_mask) >> base_shift);
840                     sada - 2*(da - db)*(sa - sb) + sb*d1a + db*s1a + base_mask) >> base_shift);
842                 p[Order::A] = (value_type)(sa + da - ((sa * da + base_mask) >> base_shift));
868                                          unsigned sa, unsigned cover)
875                 sa = (sa * cover + 255) >> 8;
877             if(sa)
880                 calc_type s1a = base_mask - sa;
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));
911                                          unsigned sa, unsigned cover)
918                 sa = (sa * cover + 255) >> 8;
920             if(sa)
923                 calc_type s1a = base_mask - sa;
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));
959                                          unsigned sa, unsigned cover)
966                 sa = (sa * cover + 255) >> 8;
968             if(sa)
971                 calc_type s1a  = base_mask - sa;
976                 long_type drsa = dr * sa;
977                 long_type dgsa = dg * sa;
978                 long_type dbsa = db * sa;
982                 long_type sada = sa * da;
986                     drsa / (base_mask - (sr << base_shift) / sa) + ((sr * d1a + dr * s1a + base_mask) >> base_shift));
990                     dgsa / (base_mask - (sg << base_shift) / sa) + ((sg * d1a + dg * s1a + base_mask) >> base_shift));
994                     dbsa / (base_mask - (sb << base_shift) / sa) + ((sb * d1a + db * s1a + base_mask) >> base_shift));
996                 p[Order::A] = (value_type)(sa + da - ((sa * da + base_mask) >> base_shift));
1023                                          unsigned sa, unsigned cover)
1030                 sa = (sa * cover + 255) >> 8;
1032             if(sa)
1035                 calc_type s1a  = base_mask - sa;
1040                 long_type drsa = dr * sa;
1041                 long_type dgsa = dg * sa;
1042                 long_type dbsa = db * sa;
1046                 long_type sada = sa * da;
1050                     sa * (srda + drsa - sada) / sr + sr * d1a + dr * s1a + base_mask) >> base_shift);
1054                     sa * (sgda + dgsa - sada) / sg + sg * d1a + dg * s1a + base_mask) >> base_shift);
1058                     sa * (sbda + dbsa - sada) / sb + sb * d1a + db * s1a + base_mask) >> base_shift);
1060                 p[Order::A] = (value_type)(sa + da - ((sa * da + base_mask) >> base_shift));
1087                                          unsigned sa, unsigned cover)
1094                 sa = (sa * cover + 255) >> 8;
1096             if(sa)
1099                 calc_type s1a  = base_mask - sa;
1104                 calc_type sada = sa * da;
1106                 p[Order::R] = (value_type)(((2*sr < sa) ?
1108                     sada - 2*(da - dr)*(sa - sr) + sr*d1a + dr*s1a + base_mask) >> base_shift);
1110                 p[Order::G] = (value_type)(((2*sg < sa) ?
1112                     sada - 2*(da - dg)*(sa - sg) + sg*d1a + dg*s1a + base_mask) >> base_shift);
1114                 p[Order::B] = (value_type)(((2*sb < sa) ?
1116                     sada - 2*(da - db)*(sa - sb) + sb*d1a + db*s1a + base_mask) >> base_shift);
1118                 p[Order::A] = (value_type)(sa + da - ((sa * da + base_mask) >> base_shift));
1153             double sa = double(a * cover) / (base_mask * 255);
1154             if(sa > 0)
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);
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);
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);
1204                                          unsigned sa, unsigned cover)
1211                 sa = (sa * cover + 255) >> 8;
1213             if(sa)
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));
1245                                          unsigned sa, unsigned cover)
1252                 sa = (sa * cover + 255) >> 8;
1254             if(sa)
1257                 calc_type s1a = base_mask - sa;
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));
1287                                          unsigned sa, unsigned cover)
1294                 sa = (sa * cover + 255) >> 8;
1301             unsigned s2a = sa >> 1;
1335                                          unsigned sa, unsigned cover)
1337             sa = (sa * cover + 255) >> 8;
1338             if(sa)
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;
1348                 p[Order::A] = (value_type)(sa + da - ((sa * da + base_mask) >> base_shift));
1371                                          unsigned sa, unsigned cover)
1378                 sa = (sa * cover + 255) >> 8;
1380             if(sa)
1386                 calc_type s1a = base_mask - sa;
1390                 p[Order::A] = (value_type)(sa + da - ((sa * da + base_mask) >> base_shift));