libs/agg/agg_pixfmt_rgba.h

39         typedef typename ColorT::value_type value_type;
43         static AGG_INLINE void premultiply(value_type* p)
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);
61         static AGG_INLINE void demultiply(value_type* p)
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);
85         typedef typename ColorT::value_type value_type;
89         AGG_INLINE void operator () (value_type* p)
104         typedef typename ColorT::value_type value_type;
108         AGG_INLINE void operator () (value_type* p)
133         typedef typename color_type::value_type value_type;
142         static AGG_INLINE void blend_pix(value_type* p,
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));
163         typedef typename color_type::value_type value_type;
172         static AGG_INLINE void blend_pix(value_type* p,
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));
186         static AGG_INLINE void blend_pix(value_type* p,
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));
203         typedef typename color_type::value_type value_type;
208         static AGG_INLINE void blend_pix(value_type* p,
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);
241         typedef typename color_type::value_type value_type;
248         static AGG_INLINE void blend_pix(value_type* p,
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);
272         typedef typename color_type::value_type value_type;
274         static AGG_INLINE void blend_pix(value_type* p,
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));
301         typedef typename color_type::value_type value_type;
303         static AGG_INLINE void blend_pix(value_type*,
315         typedef typename color_type::value_type value_type;
325         static AGG_INLINE void blend_pix(value_type* p,
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));
349         typedef typename color_type::value_type value_type;
359         static AGG_INLINE void blend_pix(value_type* p,
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));
383         typedef typename color_type::value_type value_type;
393         static AGG_INLINE void blend_pix(value_type* p,
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));
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);
421         typedef typename color_type::value_type value_type;
431         static AGG_INLINE void blend_pix(value_type* p,
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);
451         typedef typename color_type::value_type value_type;
461         static AGG_INLINE void blend_pix(value_type* p,
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));
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);
489         typedef typename color_type::value_type value_type;
499         static AGG_INLINE void blend_pix(value_type* p,
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);
520         typedef typename color_type::value_type value_type;
530         static AGG_INLINE void blend_pix(value_type* p,
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);
554         typedef typename color_type::value_type value_type;
564         static AGG_INLINE void blend_pix(value_type* p,
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));
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;
596         typedef typename color_type::value_type value_type;
606         static AGG_INLINE void blend_pix(value_type* p,
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)));
634         typedef typename color_type::value_type value_type;
644         static AGG_INLINE void blend_pix(value_type* p,
674         typedef typename color_type::value_type value_type;
684         static AGG_INLINE void blend_pix(value_type* p,
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));
714         typedef typename color_type::value_type value_type;
724         static AGG_INLINE void blend_pix(value_type* p,
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));
755         typedef typename color_type::value_type value_type;
765         static AGG_INLINE void blend_pix(value_type* p,
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));
795         typedef typename color_type::value_type value_type;
809         static AGG_INLINE void blend_pix(value_type* p,
830                 p[Order::R] = (value_type)(((2*dr < da) ?
834                 p[Order::G] = (value_type)(((2*dg < da) ?
838                 p[Order::B] = (value_type)(((2*db < da) ?
842                 p[Order::A] = (value_type)(sa + da - ((sa * da + base_mask) >> base_shift));
856         typedef typename color_type::value_type value_type;
866         static AGG_INLINE void blend_pix(value_type* p,
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));
899         typedef typename color_type::value_type value_type;
909         static AGG_INLINE void blend_pix(value_type* p,
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));
942         typedef typename color_type::value_type value_type;
957         static AGG_INLINE void blend_pix(value_type* p,
984                 p[Order::R] = (value_type)((srda + drsa >= sada) ?
988                 p[Order::G] = (value_type)((sgda + dgsa >= sada) ?
992                 p[Order::B] = (value_type)((sbda + dbsa >= sada) ?
996                 p[Order::A] = (value_type)(sa + da - ((sa * da + base_mask) >> base_shift));
1006         typedef typename color_type::value_type value_type;
1021         static AGG_INLINE void blend_pix(value_type* p,
1048                 p[Order::R] = (value_type)(((srda + drsa <= sada) ?
1052                 p[Order::G] = (value_type)(((sgda + dgsa <= sada) ?
1056                 p[Order::B] = (value_type)(((sbda + dbsa <= sada) ?
1060                 p[Order::A] = (value_type)(sa + da - ((sa * da + base_mask) >> base_shift));
1070         typedef typename color_type::value_type value_type;
1085         static AGG_INLINE void blend_pix(value_type* p,
1106                 p[Order::R] = (value_type)(((2*sr < sa) ?
1110                 p[Order::G] = (value_type)(((2*sg < sa) ?
1114                 p[Order::B] = (value_type)(((2*sb < sa) ?
1118                 p[Order::A] = (value_type)(sa + da - ((sa * da + base_mask) >> base_shift));
1128         typedef typename color_type::value_type value_type;
1146         static AGG_INLINE void blend_pix(value_type* p,
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));
1190         typedef typename color_type::value_type value_type;
1202         static AGG_INLINE void blend_pix(value_type* p,
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));
1232         typedef typename color_type::value_type value_type;
1243         static AGG_INLINE void blend_pix(value_type* p,
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));
1275         typedef typename color_type::value_type value_type;
1285         static AGG_INLINE void blend_pix(value_type* p,
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);
1322         typedef typename color_type::value_type value_type;
1333         static AGG_INLINE void blend_pix(value_type* p,
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));
1358         typedef typename color_type::value_type value_type;
1369         static AGG_INLINE void blend_pix(value_type* p,
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));
1402         typedef typename ColorT::value_type value_type;
1403         typedef void (*comp_op_func_type)(value_type* p,
1495         typedef typename color_type::value_type value_type;
1502         static AGG_INLINE void blend_pix(unsigned op, value_type* p,
1520         typedef typename color_type::value_type value_type;
1527         static AGG_INLINE void blend_pix(unsigned op, value_type* p,
1550         typedef typename color_type::value_type value_type;
1557         static AGG_INLINE void blend_pix(unsigned op, value_type* p,
1571         typedef typename color_type::value_type value_type;
1578         static AGG_INLINE void blend_pix(unsigned op, value_type* p,
1598         typedef typename color_type::value_type value_type;
1605         static AGG_INLINE void blend_pix(unsigned op, value_type* p,
1623         typedef typename color_type::value_type value_type;
1630         static AGG_INLINE void blend_pix(unsigned op, value_type* p,
1653         typedef typename color_type::value_type value_type;
1660         static AGG_INLINE void blend_pix(unsigned op, value_type* p,
1685         typedef typename color_type::value_type value_type;
1695         static AGG_INLINE void copy_or_blend_pix(value_type* p,
1716         static AGG_INLINE void copy_or_blend_pix(value_type* p,
1762         typedef typename color_type::value_type value_type;
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;
1829             const value_type* p = (const value_type*)m_rbuf->row_ptr(y);
1844             value_type* p = (value_type*)m_rbuf->row_ptr(x, y, 1) + (x << 2);
1855                 (value_type*)m_rbuf->row_ptr(x, y, 1) + (x << 2),
1866             value_type* p = (value_type*)m_rbuf->row_ptr(x, y, len) + (x << 2);
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;
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;
1893                 value_type* p = (value_type*)m_rbuf->row_ptr(x, y++, 1) + (x << 2);
1908                 value_type* p = (value_type*)m_rbuf->row_ptr(x, y, len) + (x << 2);
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;
1957                 value_type* p;
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;
1968                         p = (value_type*)m_rbuf->row_ptr(x, y++, 1) + (x << 2);
1979                             p = (value_type*)m_rbuf->row_ptr(x, y++, 1) + (x << 2);
1988                             p = (value_type*)m_rbuf->row_ptr(x, y++, 1) + (x << 2);
2006                 value_type* p = (value_type*)m_rbuf->row_ptr(x, y, len) + (x << 2);
2039                     value_type* p = (value_type*)m_rbuf->row_ptr(x, y++, 1) + (x << 2);
2064             value_type* p = (value_type*)m_rbuf->row_ptr(x, y, len) + (x << 2);
2085                 value_type* p = (value_type*)m_rbuf->row_ptr(x, y++, 1) + (x << 2);
2103             value_type* p = (value_type*)m_rbuf->row_ptr(x, y, len) + (x << 2);
2162             value_type* p;
2167                     p = (value_type*)m_rbuf->row_ptr(x, y++, 1) + (x << 2);
2184                         p = (value_type*)m_rbuf->row_ptr(x, y++, 1) + (x << 2);
2198                         p = (value_type*)m_rbuf->row_ptr(x, y++, 1) + (x << 2);
2222                     value_type* p =
2223                         (value_type*)m_rbuf->row_ptr(r.x1, y, len) + (r.x1 << 2);
2282             const value_type* psrc = (value_type*)from.row_ptr(ysrc);
2286                 value_type* pdst =
2287                     (value_type*)m_rbuf->row_ptr(xdst, ydst, len) + (xdst << 2);
2344         typedef typename color_type::value_type value_type;
2351             pix_width  = sizeof(value_type) * 4
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;
2417             const value_type* p = (value_type*)m_rbuf->row_ptr(y) + (x << 2);
2429                 (value_type*)m_rbuf->row_ptr(x, y, 1) + (x << 2),
2438                 (value_type*)m_rbuf->row_ptr(x, y, 1) + (x << 2),
2446             value_type* p = (value_type*)m_rbuf->row_ptr(x, y, len) + (x << 2);;
2462                     (value_type*)m_rbuf->row_ptr(x, y++, 1) + (x << 2),
2473             value_type* p = (value_type*)m_rbuf->row_ptr(x, y, len) + (x << 2);
2491                     (value_type*)m_rbuf->row_ptr(x, y++, 1) + (x << 2),
2502             value_type* p = (value_type*)m_rbuf->row_ptr(x, y, len) + (x << 2);
2521                     (value_type*)m_rbuf->row_ptr(x, y++, 1) + (x << 2),
2534             value_type* p = (value_type*)m_rbuf->row_ptr(x, y, len) + (x << 2);
2554                 value_type* p = (value_type*)m_rbuf->row_ptr(x, y++, 1) + (x << 2);
2570             value_type* p = (value_type*)m_rbuf->row_ptr(x, y, len) + (x << 2);
2596                     (value_type*)m_rbuf->row_ptr(x, y++, 1) + (x << 2),
2618                     value_type* p =
2619                         (value_type*)m_rbuf->row_ptr(r.x1, y, len) + (r.x1 << 2);
2678             const value_type* psrc = (const value_type*)from.row_ptr(ysrc);
2682                 value_type* pdst =
2683                     (value_type*)m_rbuf->row_ptr(xdst, ydst, len) + (xdst << 2);