agg/inc/agg_pixfmt_rgba.h

   1 //----------------------------------------------------------------------------
   2 // Anti-Grain Geometry - Version 2.3
   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 "agg_basics.h"
  29 #include "agg_color_rgba.h"
  30 #include "agg_rendering_buffer.h"
  31
  32 namespace agg
  33 {
  34
  35     //=========================================================multiplier_rgba
  36     template<class ColorT, class Order> struct multiplier_rgba
  37     {
  38         typedef typename ColorT::value_type value_type;
  39         typedef typename ColorT::calc_type calc_type;
  40
  41         //--------------------------------------------------------------------
  42         static AGG_INLINE void premultiply(value_type* p)
  43         {
  44             calc_type a = p[Order::A];
  45             if(a < ColorT::base_mask)
  46             {
  47                 if(a == 0)
  48                 {
  49                     p[Order::R] = p[Order::G] = p[Order::B] = 0;
  50                     return;
  51                 }
  52                 p[Order::R] = value_type((p[Order::R] * a) >> ColorT::base_shift);
  53                 p[Order::G] = value_type((p[Order::G] * a) >> ColorT::base_shift);
  54                 p[Order::B] = value_type((p[Order::B] * a) >> ColorT::base_shift);
  55             }
  56         }
  57
  58
  59         //--------------------------------------------------------------------
  60         static AGG_INLINE void demultiply(value_type* p)
  61         {
  62             calc_type a = p[Order::A];
  63             if(a < ColorT::base_mask)
  64             {
  65                 if(a == 0)
  66                 {
  67                     p[Order::R] = p[Order::G] = p[Order::B] = 0;
  68                     return;
  69                 }
  70                 calc_type r = (calc_type(p[Order::R]) * ColorT::base_mask) / a;
  71                 calc_type g = (calc_type(p[Order::G]) * ColorT::base_mask) / a;
  72                 calc_type b = (calc_type(p[Order::B]) * ColorT::base_mask) / a;
  73                 p[Order::R] = value_type((r > ColorT::base_mask) ? ColorT::base_mask : r);
  74                 p[Order::G] = value_type((g > ColorT::base_mask) ? ColorT::base_mask : g);
  75                 p[Order::B] = value_type((b > ColorT::base_mask) ? ColorT::base_mask : b);
  76             }
  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
 101
 102     //=====================================================apply_gamma_inv_rgba
 103     template<class ColorT, class Order, class GammaLut> class apply_gamma_inv_rgba
 104     {
 105     public:
 106         typedef typename ColorT::value_type value_type;
 107
 108         apply_gamma_inv_rgba(const GammaLut& gamma) : m_gamma(gamma) {}
 109
 110         AGG_INLINE void operator () (value_type* p)
 111         {
 112             p[Order::R] = m_gamma.inv(p[Order::R]);
 113             p[Order::G] = m_gamma.inv(p[Order::G]);
 114             p[Order::B] = m_gamma.inv(p[Order::B]);
 115         }
 116
 117     private:
 118         const GammaLut& m_gamma;
 119     };
 120
 121
 122
 123     //=============================================================blender_rgba
 124     template<class ColorT, class Order, class PixelT> struct blender_rgba
 125     {
 126         typedef ColorT color_type;
 127         typedef PixelT pixel_type;
 128         typedef Order order_type;
 129         typedef typename color_type::value_type value_type;
 130         typedef typename color_type::calc_type calc_type;
 131         enum
 132         {
 133             base_shift = color_type::base_shift,
 134             base_mask  = color_type::base_mask
 135         };
 136
 137         //--------------------------------------------------------------------
 138         static AGG_INLINE void blend_pix(value_type* p,
 139                                          unsigned cr, unsigned cg, unsigned cb,
 140                                          unsigned alpha,
 141                                          unsigned)
 142         {
 143             calc_type r = p[Order::R];
 144             calc_type g = p[Order::G];
 145             calc_type b = p[Order::B];
 146             calc_type a = p[Order::A];
 147             p[Order::R] = (value_type)(((cr - r) * alpha + (r << base_shift)) >> base_shift);
 148             p[Order::G] = (value_type)(((cg - g) * alpha + (g << base_shift)) >> base_shift);
 149             p[Order::B] = (value_type)(((cb - b) * alpha + (b << base_shift)) >> base_shift);
 150             p[Order::A] = (value_type)((alpha + a) - ((alpha * a + base_mask) >> base_shift));
 151         }
 152     };
 153
 154
 155     //=========================================================blender_rgba_pre
 156     template<class ColorT, class Order, class PixelT> struct blender_rgba_pre
 157     {
 158         typedef ColorT color_type;
 159         typedef PixelT pixel_type;
 160         typedef Order order_type;
 161         typedef typename color_type::value_type value_type;
 162         typedef typename color_type::calc_type calc_type;
 163         enum
 164         {
 165             base_shift = color_type::base_shift,
 166             base_mask  = color_type::base_mask
 167         };
 168
 169         //--------------------------------------------------------------------
 170         static AGG_INLINE void blend_pix(value_type* p,
 171                                          unsigned cr, unsigned cg, unsigned cb,
 172                                          unsigned alpha,
 173                                          unsigned cover)
 174         {
 175             alpha = color_type::base_mask - alpha;
 176             cover = (cover + 1) << (base_shift - 8);
 177             p[Order::R] = (value_type)((p[Order::R] * alpha + cr * cover) >> base_shift);
 178             p[Order::G] = (value_type)((p[Order::G] * alpha + cg * cover) >> base_shift);
 179             p[Order::B] = (value_type)((p[Order::B] * alpha + cb * cover) >> base_shift);
 180             p[Order::A] = (value_type)(base_mask - ((alpha * (base_mask - p[Order::A])) >> base_shift));
 181         }
 182     };
 183
 184
 185
 186     //======================================================blender_rgba_plain
 187     template<class ColorT, class Order, class PixelT> struct blender_rgba_plain
 188     {
 189         typedef ColorT color_type;
 190         typedef PixelT pixel_type;
 191         typedef Order order_type;
 192         typedef typename color_type::value_type value_type;
 193         typedef typename color_type::calc_type calc_type;
 194         enum { base_shift = color_type::base_shift };
 195
 196         //--------------------------------------------------------------------
 197         static AGG_INLINE void blend_pix(value_type* p,
 198                                          unsigned cr, unsigned cg, unsigned cb,
 199                                          unsigned alpha,
 200                                          unsigned)
 201         {
 202             if(alpha == 0) return;
 203             calc_type a = p[Order::A];
 204             calc_type r = p[Order::R] * a;
 205             calc_type g = p[Order::G] * a;
 206             calc_type b = p[Order::B] * a;
 207             a = ((alpha + a) << base_shift) - alpha * a;
 208             p[Order::A] = (value_type)(a >> base_shift);
 209             p[Order::R] = (value_type)((((cr << base_shift) - r) * alpha + (r << base_shift)) / a);
 210             p[Order::G] = (value_type)((((cg << base_shift) - g) * alpha + (g << base_shift)) / a);
 211             p[Order::B] = (value_type)((((cb << base_shift) - b) * alpha + (b << base_shift)) / a);
 212         }
 213     };
 214
 215
 216     //====================================================blender_rgba_wrapper
 217     template<class Blender> struct blender_rgba_wrapper
 218     {
 219         typedef typename Blender::color_type color_type;
 220         typedef typename Blender::order_type order_type;
 221         typedef typename Blender::pixel_type pixel_type;
 222         typedef typename color_type::value_type value_type;
 223         typedef typename color_type::calc_type calc_type;
 224         enum
 225         {
 226             base_shift = color_type::base_shift,
 227             base_size  = color_type::base_size,
 228             base_mask  = color_type::base_mask
 229         };
 230
 231         //--------------------------------------------------------------------
 232         static AGG_INLINE void blend_pix(value_type* p,
 233                                          unsigned cr, unsigned cg, unsigned cb,
 234                                          unsigned alpha,
 235                                          unsigned cover)
 236         {
 237             Blender::blend_pix(p, cr, cg, cb, alpha, cover);
 238         }
 239
 240         //--------------------------------------------------------------------
 241         static AGG_INLINE void copy_or_blend_pix(value_type* p,
 242                                                  const color_type& c,
 243                                                  unsigned cover)
 244         {
 245             if (c.a)
 246             {
 247                 calc_type alpha = (calc_type(c.a) * (cover + 1)) >> 8;
 248                 if(alpha == base_mask)
 249                 {
 250                     p[order_type::R] = c.r;
 251                     p[order_type::G] = c.g;
 252                     p[order_type::B] = c.b;
 253                     p[order_type::A] = c.a;
 254                 }
 255                 else
 256                 {
 257                     Blender::blend_pix(p, c.r, c.g, c.b, alpha, cover);
 258                 }
 259             }
 260         }
 261
 262         //--------------------------------------------------------------------
 263         static AGG_INLINE void copy_or_blend_opaque_pix(value_type* p,
 264                                                         const color_type& c,
 265                                                         unsigned cover)
 266         {
 267             if(cover == 255)
 268             {
 269                 p[order_type::R] = c.r;
 270                 p[order_type::G] = c.g;
 271                 p[order_type::B] = c.b;
 272                 p[order_type::A] = base_mask;
 273             }
 274             else
 275             {
 276                 Blender::blend_pix(p, c.r, c.g, c.b, (cover + 1) << (base_shift - 8), cover);
 277             }
 278         }
 279     };
 280
 281
 282
 283
 284     //=======================================================pixel_formats_rgba
 285     template<class Blender> class pixel_formats_rgba
 286     {
 287     public:
 288         typedef rendering_buffer::row_data row_data;
 289         typedef typename Blender::color_type color_type;
 290         typedef typename Blender::order_type order_type;
 291         typedef typename Blender::pixel_type pixel_type;
 292         typedef typename color_type::value_type value_type;
 293         typedef typename color_type::calc_type calc_type;
 294         typedef blender_rgba_wrapper<Blender> blender_type;
 295         enum
 296         {
 297             base_shift = color_type::base_shift,
 298             base_size  = color_type::base_size,
 299             base_mask  = color_type::base_mask
 300         };
 301
 302         //--------------------------------------------------------------------
 303         pixel_formats_rgba(rendering_buffer& rb) :
 304             m_rbuf(&rb)
 305         {}
 306
 307         //--------------------------------------------------------------------
 308         AGG_INLINE unsigned width()  const { return m_rbuf->width();  }
 309         AGG_INLINE unsigned height() const { return m_rbuf->height(); }
 310
 311         //--------------------------------------------------------------------
 312         AGG_INLINE color_type pixel(int x, int y) const
 313         {
 314             const value_type* p = (value_type*)m_rbuf->row(y) + (x << 2);
 315             return color_type(p[order_type::R],
 316                               p[order_type::G],
 317                               p[order_type::B],
 318                               p[order_type::A]);
 319         }
 320
 321         //--------------------------------------------------------------------
 322         row_data span(int x, int y) const
 323         {
 324             return row_data(x,
 325                             width() - 1,
 326                             m_rbuf->row(y) + x * 4 * sizeof(value_type));
 327         }
 328
 329         //--------------------------------------------------------------------
 330         AGG_INLINE void copy_pixel(int x, int y, const color_type& c)
 331         {
 332             value_type* p = (value_type*)m_rbuf->row(y) + (x << 2);
 333             p[order_type::R] = c.r;
 334             p[order_type::G] = c.g;
 335             p[order_type::B] = c.b;
 336             p[order_type::A] = c.a;
 337         }
 338
 339         //--------------------------------------------------------------------
 340         AGG_INLINE void blend_pixel(int x, int y, const color_type& c, int8u cover)
 341         {
 342             blender_type::copy_or_blend_pix((value_type*)m_rbuf->row(y) + (x << 2), c, cover);
 343         }
 344
 345
 346         //--------------------------------------------------------------------
 347         AGG_INLINE void copy_hline(int x, int y,
 348                                    unsigned len,
 349                                    const color_type& c)
 350         {
 351             value_type* p = (value_type*)m_rbuf->row(y) + (x << 2);
 352             pixel_type v;
 353             ((value_type*)&v)[order_type::R] = c.r;
 354             ((value_type*)&v)[order_type::G] = c.g;
 355             ((value_type*)&v)[order_type::B] = c.b;
 356             ((value_type*)&v)[order_type::A] = c.a;
 357             do
 358             {
 359                 *(pixel_type*)p = v;
 360                 p += 4;
 361             }
 362             while(--len);
 363         }
 364
 365
 366         //--------------------------------------------------------------------
 367         AGG_INLINE void copy_vline(int x, int y,
 368                                    unsigned len,
 369                                    const color_type& c)
 370         {
 371             value_type* p = (value_type*)m_rbuf->row(y) + (x << 2);
 372             pixel_type v;
 373             ((value_type*)&v)[order_type::R] = c.r;
 374             ((value_type*)&v)[order_type::G] = c.g;
 375             ((value_type*)&v)[order_type::B] = c.b;
 376             ((value_type*)&v)[order_type::A] = c.a;
 377             do
 378             {
 379                 *(pixel_type*)p = v;
 380                 p = (value_type*)m_rbuf->next_row(p);
 381             }
 382             while(--len);
 383         }
 384
 385
 386         //--------------------------------------------------------------------
 387         void blend_hline(int x, int y,
 388                          unsigned len,
 389                          const color_type& c,
 390                          int8u cover)
 391         {
 392             if (c.a)
 393             {
 394                 value_type* p = (value_type*)m_rbuf->row(y) + (x << 2);
 395                 calc_type alpha = (calc_type(c.a) * (cover + 1)) >> 8;
 396                 if(alpha == base_mask)
 397                 {
 398                     pixel_type v;
 399                     ((value_type*)&v)[order_type::R] = c.r;
 400                     ((value_type*)&v)[order_type::G] = c.g;
 401                     ((value_type*)&v)[order_type::B] = c.b;
 402                     ((value_type*)&v)[order_type::A] = c.a;
 403                     do
 404                     {
 405                         *(pixel_type*)p = v;
 406                         p += 4;
 407                     }
 408                     while(--len);
 409                 }
 410                 else
 411                 {
 412                     do
 413                     {
 414                         blender_type::blend_pix(p, c.r, c.g, c.b, alpha, cover);
 415                         p += 4;
 416                     }
 417                     while(--len);
 418                 }
 419             }
 420         }
 421
 422
 423         //--------------------------------------------------------------------
 424         void blend_vline(int x, int y,
 425                          unsigned len,
 426                          const color_type& c,
 427                          int8u cover)
 428         {
 429             if (c.a)
 430             {
 431                 value_type* p = (value_type*)m_rbuf->row(y) + (x << 2);
 432                 calc_type alpha = (calc_type(c.a) * (cover + 1)) >> 8;
 433                 if(alpha == base_mask)
 434                 {
 435                     pixel_type v;
 436                     ((value_type*)&v)[order_type::R] = c.r;
 437                     ((value_type*)&v)[order_type::G] = c.g;
 438                     ((value_type*)&v)[order_type::B] = c.b;
 439                     ((value_type*)&v)[order_type::A] = c.a;
 440                     do
 441                     {
 442                         *(pixel_type*)p = v;
 443                         p = (value_type*)m_rbuf->next_row(p);
 444                     }
 445                     while(--len);
 446                 }
 447                 else
 448                 {
 449                     do
 450                     {
 451                         blender_type::blend_pix(p, c.r, c.g, c.b, alpha, cover);
 452                         p = (value_type*)m_rbuf->next_row(p);
 453                     }
 454                     while(--len);
 455                 }
 456             }
 457         }
 458
 459
 460         //--------------------------------------------------------------------
 461         void blend_solid_hspan(int x, int y,
 462                                unsigned len,
 463                                const color_type& c,
 464                                const int8u* covers)
 465         {
 466             if (c.a)
 467             {
 468                 value_type* p = (value_type*)m_rbuf->row(y) + (x << 2);
 469                 do
 470                 {
 471                     calc_type alpha = (calc_type(c.a) * (calc_type(*covers) + 1)) >> 8;
 472                     if(alpha == base_mask)
 473                     {
 474                         p[order_type::R] = c.r;
 475                         p[order_type::G] = c.g;
 476                         p[order_type::B] = c.b;
 477                         p[order_type::A] = base_mask;
 478                     }
 479                     else
 480                     {
 481                         blender_type::blend_pix(p, c.r, c.g, c.b, alpha, *covers);
 482                     }
 483                     p += 4;
 484                     ++covers;
 485                 }
 486                 while(--len);
 487             }
 488         }
 489
 490
 491         //--------------------------------------------------------------------
 492         void blend_solid_vspan(int x, int y,
 493                                unsigned len,
 494                                const color_type& c,
 495                                const int8u* covers)
 496         {
 497             if (c.a)
 498             {
 499                 value_type* p = (value_type*)m_rbuf->row(y) + (x << 2);
 500                 do
 501                 {
 502                     calc_type alpha = (calc_type(c.a) * (calc_type(*covers) + 1)) >> 8;
 503                     if(alpha == base_mask)
 504                     {
 505                         p[order_type::R] = c.r;
 506                         p[order_type::G] = c.g;
 507                         p[order_type::B] = c.b;
 508                         p[order_type::A] = base_mask;
 509                     }
 510                     else
 511                     {
 512                         blender_type::blend_pix(p, c.r, c.g, c.b, alpha, *covers);
 513                     }
 514                     p = (value_type*)m_rbuf->next_row(p);
 515                     ++covers;
 516                 }
 517                 while(--len);
 518             }
 519         }
 520
 521
 522         //--------------------------------------------------------------------
 523         void blend_color_hspan(int x, int y,
 524                                unsigned len,
 525                                const color_type* colors,
 526                                const int8u* covers,
 527                                int8u cover)
 528         {
 529             value_type* p = (value_type*)m_rbuf->row(y) + (x << 2);
 530             if(covers)
 531             {
 532                 do
 533                 {
 534                     blender_type::copy_or_blend_pix(p, *colors++, *covers++);
 535                     p += 4;
 536                 }
 537                 while(--len);
 538             }
 539             else
 540             {
 541                 if(cover == 255)
 542                 {
 543                     do
 544                     {
 545                         if(colors->a == base_mask)
 546                         {
 547                             p[order_type::R] = colors->r;
 548                             p[order_type::G] = colors->g;
 549                             p[order_type::B] = colors->b;
 550                             p[order_type::A] = base_mask;
 551                         }
 552                         else
 553                         {
 554                             blender_type::copy_or_blend_pix(p, *colors, 255);
 555                         }
 556                         p += 4;
 557                         ++colors;
 558                     }
 559                     while(--len);
 560                 }
 561                 else
 562                 {
 563                     do
 564                     {
 565                         blender_type::copy_or_blend_pix(p, *colors++, cover);
 566                         p += 4;
 567                     }
 568                     while(--len);
 569                 }
 570             }
 571         }
 572
 573
 574
 575         //--------------------------------------------------------------------
 576         void blend_color_vspan(int x, int y,
 577                                unsigned len,
 578                                const color_type* colors,
 579                                const int8u* covers,
 580                                int8u cover)
 581         {
 582             value_type* p = (value_type*)m_rbuf->row(y) + (x << 2);
 583             if(covers)
 584             {
 585                 do
 586                 {
 587                     blender_type::copy_or_blend_pix(p, *colors++, *covers++);
 588                     p = (value_type*)m_rbuf->next_row(p);
 589                 }
 590                 while(--len);
 591             }
 592             else
 593             {
 594                 if(cover == 255)
 595                 {
 596                     do
 597                     {
 598                         if(colors->a == base_mask)
 599                         {
 600                             p[order_type::R] = colors->r;
 601                             p[order_type::G] = colors->g;
 602                             p[order_type::B] = colors->b;
 603                             p[order_type::A] = base_mask;
 604                         }
 605                         else
 606                         {
 607                             blender_type::copy_or_blend_pix(p, *colors, 255);
 608                         }
 609                         p = (value_type*)m_rbuf->next_row(p);
 610                         ++colors;
 611                     }
 612                     while(--len);
 613                 }
 614                 else
 615                 {
 616                     do
 617                     {
 618                         blender_type::copy_or_blend_pix(p, *colors++, cover);
 619                         p = (value_type*)m_rbuf->next_row(p);
 620                     }
 621                     while(--len);
 622                 }
 623             }
 624         }
 625
 626
 627         //--------------------------------------------------------------------
 628         void blend_opaque_color_hspan(int x, int y,
 629                                       unsigned len,
 630                                       const color_type* colors,
 631                                       const int8u* covers,
 632                                       int8u cover)
 633         {
 634             value_type* p = (value_type*)m_rbuf->row(y) + (x << 2);
 635             if(covers)
 636             {
 637                 do
 638                 {
 639                     blender_type::copy_or_blend_opaque_pix(p, *colors++, *covers++);
 640                     p += 4;
 641                 }
 642                 while(--len);
 643             }
 644             else
 645             {
 646                 if(cover == 255)
 647                 {
 648                     do
 649                     {
 650                         p[order_type::R] = colors->r;
 651                         p[order_type::G] = colors->g;
 652                         p[order_type::B] = colors->b;
 653                         p[order_type::A] = base_mask;
 654                         p += 4;
 655                         ++colors;
 656                     }
 657                     while(--len);
 658                 }
 659                 else
 660                 {
 661                     do
 662                     {
 663                         blender_type::copy_or_blend_opaque_pix(p, *colors++, cover);
 664                         p += 4;
 665                     }
 666                     while(--len);
 667                 }
 668             }
 669         }
 670
 671
 672         //--------------------------------------------------------------------
 673         void blend_opaque_color_vspan(int x, int y,
 674                                       unsigned len,
 675                                       const color_type* colors,
 676                                       const int8u* covers,
 677                                       int8u cover)
 678         {
 679             value_type* p = (value_type*)m_rbuf->row(y) + (x << 2);
 680             if(covers)
 681             {
 682                 do
 683                 {
 684                     blender_type::copy_or_blend_opaque_pix(p, *colors++, *covers++);
 685                     p = (value_type*)m_rbuf->next_row(p);
 686                 }
 687                 while(--len);
 688             }
 689             else
 690             {
 691                 if(cover == 255)
 692                 {
 693                     do
 694                     {
 695                         p[order_type::R] = colors->r;
 696                         p[order_type::G] = colors->g;
 697                         p[order_type::B] = colors->b;
 698                         p[order_type::A] = base_mask;
 699                         p = (value_type*)m_rbuf->next_row(p);
 700                         ++colors;
 701                     }
 702                     while(--len);
 703                 }
 704                 else
 705                 {
 706                     do
 707                     {
 708                         blender_type::copy_or_blend_opaque_pix(p, *colors++, cover);
 709                         p = (value_type*)m_rbuf->next_row(p);
 710                     }
 711                     while(--len);
 712                 }
 713             }
 714         }
 715
 716
 717         //--------------------------------------------------------------------
 718         template<class Function> void for_each_pixel(Function f)
 719         {
 720             unsigned y;
 721             for(y = 0; y < height(); ++y)
 722             {
 723                 unsigned len = width();
 724                 value_type* p = (value_type*)m_rbuf->row(y);
 725                 do
 726                 {
 727                     f(p);
 728                     p += 4;
 729                 }
 730                 while(--len);
 731             }
 732         }
 733
 734         //--------------------------------------------------------------------
 735         void premultiply()
 736         {
 737             for_each_pixel(multiplier_rgba<color_type, order_type>::premultiply);
 738         }
 739
 740         //--------------------------------------------------------------------
 741         void demultiply()
 742         {
 743             for_each_pixel(multiplier_rgba<color_type, order_type>::demultiply);
 744         }
 745
 746         //--------------------------------------------------------------------
 747         template<class GammaLut> void apply_gamma_dir(const GammaLut& g)
 748         {
 749             for_each_pixel(apply_gamma_dir_rgba<color_type, order_type, GammaLut>(g));
 750         }
 751
 752         //--------------------------------------------------------------------
 753         template<class GammaLut> void apply_gamma_inv(const GammaLut& g)
 754         {
 755             for_each_pixel(apply_gamma_inv_rgba<color_type, order_type, GammaLut>(g));
 756         }
 757
 758         //--------------------------------------------------------------------
 759         void copy_from(const rendering_buffer& from,
 760                        int xdst, int ydst,
 761                        int xsrc, int ysrc,
 762                        unsigned len)
 763         {
 764             memmove((value_type*)m_rbuf->row(ydst) + xdst * 4,
 765                     (value_type*)from.row(ysrc) + xsrc * 4,
 766                     sizeof(value_type) * 4 * len);
 767         }
 768
 769
 770         //--------------------------------------------------------------------
 771         template<class SrcPixelFormatRenderer>
 772         void blend_from(const SrcPixelFormatRenderer& from,
 773                         const int8u* psrc_,
 774                         int xdst, int ydst,
 775                         int xsrc, int ysrc,
 776                         unsigned len)
 777         {
 778             typedef typename SrcPixelFormatRenderer::order_type src_order;
 779
 780             const value_type* psrc = (const value_type*)psrc_;
 781             value_type* pdst = (value_type*)m_rbuf->row(ydst) + (xdst << 2);
 782             int incp = 4;
 783             if(xdst > xsrc)
 784             {
 785                 psrc += (len-1) << 2;
 786                 pdst += (len-1) << 2;
 787                 incp = -4;
 788             }
 789             do
 790             {
 791                 value_type alpha = psrc[src_order::A];
 792
 793                 if(alpha)
 794                 {
 795                     if(alpha == base_mask)
 796                     {
 797                         pdst[order_type::R] = psrc[src_order::R];
 798                         pdst[order_type::G] = psrc[src_order::G];
 799                         pdst[order_type::B] = psrc[src_order::B];
 800                         pdst[order_type::A] = psrc[src_order::A];
 801                     }
 802                     else
 803                     {
 804                         blender_type::blend_pix(pdst,
 805                                                 psrc[src_order::R],
 806                                                 psrc[src_order::G],
 807                                                 psrc[src_order::B],
 808                                                 alpha,
 809                                                 255);
 810                     }
 811                 }
 812                 psrc += incp;
 813                 pdst += incp;
 814             }
 815             while(--len);
 816         }
 817
 818     private:
 819         rendering_buffer* m_rbuf;
 820     };
 821
 822
 823
 824
 825     //================================================pixfmt_custom_rbuf_rgba
 826     template<class Blender, class RenBuf> class pixfmt_custom_rbuf_rgba
 827     {
 828     public:
 829         typedef typename Blender::color_type color_type;
 830         typedef typename Blender::order_type order_type;
 831         typedef typename Blender::pixel_type pixel_type;
 832         typedef typename color_type::value_type value_type;
 833         typedef typename color_type::calc_type calc_type;
 834         typedef blender_rgba_wrapper<Blender> blender_type;
 835         enum
 836         {
 837             base_shift = color_type::base_shift,
 838             base_size  = color_type::base_size,
 839             base_mask  = color_type::base_mask
 840         };
 841
 842         typedef RenBuf rbuf_type;
 843         typedef typename rbuf_type::row_data row_data;
 844
 845         //--------------------------------------------------------------------
 846         pixfmt_custom_rbuf_rgba(rbuf_type& rb) : m_rbuf(&rb) {}
 847
 848         //--------------------------------------------------------------------
 849         unsigned width()  const { return m_rbuf->width();  }
 850         unsigned height() const { return m_rbuf->height(); }
 851
 852         //--------------------------------------------------------------------
 853         color_type pixel(int x, int y) const
 854         {
 855             const value_type* p = m_rbuf->span_ptr(x, y, 1);
 856             return p ? color_type(p[order_type::R],
 857                                   p[order_type::G],
 858                                   p[order_type::B],
 859                                   p[order_type::A]) :
 860                        color_type::no_color();
 861         }
 862
 863         //--------------------------------------------------------------------
 864         row_data span(int x, int y) const
 865         {
 866             return m_rbuf->span(x, y);
 867         }
 868
 869         //--------------------------------------------------------------------
 870         void copy_pixel(int x, int y, const color_type& c)
 871         {
 872             int8u* p = m_rbuf->span_ptr(x, y, 1);
 873             p[order_type::R] = c.r;
 874             p[order_type::G] = c.g;
 875             p[order_type::B] = c.b;
 876             p[order_type::A] = c.b;
 877         }
 878
 879         //--------------------------------------------------------------------
 880         void blend_pixel(int x, int y, const color_type& c, int8u cover)
 881         {
 882             blender_type::copy_or_blend_pix((value_type*)m_rbuf->span_ptr(x, y, 1), c, cover);
 883         }
 884
 885         //--------------------------------------------------------------------
 886         void copy_hline(int x, int y, unsigned len, const color_type& c)
 887         {
 888             value_type* p = (value_type*)m_rbuf->span_ptr(x, y, len);
 889             pixel_type v;
 890             ((value_type*)&v)[order_type::R] = c.r;
 891             ((value_type*)&v)[order_type::G] = c.g;
 892             ((value_type*)&v)[order_type::B] = c.b;
 893             ((value_type*)&v)[order_type::A] = c.a;
 894             do
 895             {
 896                 *(pixel_type*)p = v;
 897                 p += 4;
 898             }
 899             while(--len);
 900         }
 901
 902         //--------------------------------------------------------------------
 903         void copy_vline(int x, int y, unsigned len, const color_type& c)
 904         {
 905             pixel_type v;
 906             ((value_type*)&v)[order_type::R] = c.r;
 907             ((value_type*)&v)[order_type::G] = c.g;
 908             ((value_type*)&v)[order_type::B] = c.b;
 909             ((value_type*)&v)[order_type::A] = c.a;
 910             do
 911             {
 912                 *(pixel_type*)(m_rbuf->span_ptr(x, y++, 1)) = v;
 913             }
 914             while(--len);
 915         }
 916
 917         //--------------------------------------------------------------------
 918         void blend_hline(int x, int y, unsigned len,
 919                          const color_type& c, int8u cover)
 920         {
 921             if (c.a)
 922             {
 923                 value_type* p = (value_type*)m_rbuf->span_ptr(x, y, len);
 924                 calc_type alpha = (calc_type(c.a) * (cover + 1)) >> 8;
 925                 if(alpha == base_mask)
 926                 {
 927                     pixel_type v;
 928                     ((value_type*)&v)[order_type::R] = c.r;
 929                     ((value_type*)&v)[order_type::G] = c.g;
 930                     ((value_type*)&v)[order_type::B] = c.b;
 931                     ((value_type*)&v)[order_type::A] = c.a;
 932                     do
 933                     {
 934                         *(pixel_type*)p = v;
 935                         p += 4;
 936                     }
 937                     while(--len);
 938                 }
 939                 else
 940                 {
 941                     do
 942                     {
 943                         blender_type::blend_pix(p, c.r, c.g, c.b, alpha, cover);
 944                         p += 4;
 945                     }
 946                     while(--len);
 947                 }
 948             }
 949         }
 950
 951         //--------------------------------------------------------------------
 952         void blend_vline(int x, int y, unsigned len,
 953                          const color_type& c, int8u cover)
 954         {
 955             if (c.a)
 956             {
 957                 calc_type alpha = (calc_type(c.a) * (cover + 1)) >> 8;
 958                 if(alpha == base_mask)
 959                 {
 960                     pixel_type v;
 961                     ((value_type*)&v)[order_type::R] = c.r;
 962                     ((value_type*)&v)[order_type::G] = c.g;
 963                     ((value_type*)&v)[order_type::B] = c.b;
 964                     ((value_type*)&v)[order_type::A] = c.a;
 965                     do
 966                     {
 967                         *(pixel_type*)(m_rbuf->span_ptr(x, y++, 1)) = v;
 968                     }
 969                     while(--len);
 970                 }
 971                 else
 972                 {
 973                     do
 974                     {
 975                         blender_type::blend_pix(*(pixel_type*)m_rbuf->span_ptr(x, y++, 1),
 976                                                 c.r, c.g, c.b, alpha, cover);
 977                     }
 978                     while(--len);
 979                 }
 980             }
 981         }
 982
 983
 984         //--------------------------------------------------------------------
 985         void blend_solid_hspan(int x, int y, unsigned len,
 986                                const color_type& c, const int8u* covers)
 987         {
 988             value_type* p = (value_type*)m_rbuf->span_ptr(x, y, len);
 989             do
 990             {
 991                 blender_type::copy_or_blend_pix(p, c, *covers++);
 992                 p += 4;
 993             }
 994             while(--len);
 995         }
 996
 997
 998
 999         //--------------------------------------------------------------------
1000         void blend_solid_vspan(int x, int y, unsigned len,
1001                                const color_type& c, const int8u* covers)
1002         {
1003             do
1004             {
1005                 blender_type::copy_or_blend_pix((value_type*)m_rbuf->span_ptr(x, y++, 1),
1006                                                 c,
1007                                                 *covers++);
1008             }
1009             while(--len);
1010         }
1011
1012
1013         //--------------------------------------------------------------------
1014         void blend_color_hspan(int x, int y, unsigned len,
1015                                const color_type* colors,
1016                                const int8u* covers,
1017                                int8u cover)
1018         {
1019             value_type* p = (value_type*)m_rbuf->span_ptr(x, y, len);
1020             do
1021             {
1022                 blender_type::copy_or_blend_pix(p, *colors++, covers ? *covers++ : cover);
1023                 p += 4;
1024             }
1025             while(--len);
1026         }
1027
1028
1029         //--------------------------------------------------------------------
1030         void blend_color_vspan(int x, int y, unsigned len,
1031                                const color_type* colors,
1032                                const int8u* covers,
1033                                int8u cover)
1034         {
1035             do
1036             {
1037                 blender_type::copy_or_blend_pix((value_type*)m_rbuf->span_ptr(x, y++, 1),
1038                                                 *colors++, covers ? *covers++ : cover);
1039             }
1040             while(--len);
1041         }
1042
1043
1044         //--------------------------------------------------------------------
1045         void blend_opaque_color_hspan(int x, int y,
1046                                       unsigned len,
1047                                       const color_type* colors,
1048                                       const int8u* covers,
1049                                       int8u cover)
1050         {
1051             value_type* p = (value_type*)m_rbuf->span_ptr(x, y, len);
1052             if(covers)
1053             {
1054                 do
1055                 {
1056                     blender_type::copy_or_blend_opaque_pix(p, *colors++, *covers++);
1057                     p += 4;
1058                 }
1059                 while(--len);
1060             }
1061             else
1062             {
1063                 if(cover == 255)
1064                 {
1065                     do
1066                     {
1067                         p[order_type::R] = colors->r;
1068                         p[order_type::G] = colors->g;
1069                         p[order_type::B] = colors->b;
1070                         p[order_type::A] = base_mask;
1071                         p += 4;
1072                         ++colors;
1073                     }
1074                     while(--len);
1075                 }
1076                 else
1077                 {
1078                     do
1079                     {
1080                         blender_type::copy_or_blend_opaque_pix(p, *colors++, cover);
1081                         p += 4;
1082                     }
1083                     while(--len);
1084                 }
1085             }
1086         }
1087
1088
1089         //--------------------------------------------------------------------
1090         void blend_opaque_color_vspan(int x, int y,
1091                                       unsigned len,
1092                                       const color_type* colors,
1093                                       const int8u* covers,
1094                                       int8u cover)
1095         {
1096             if(covers)
1097             {
1098                 do
1099                 {
1100                     blender_type::copy_or_blend_opaque_pix((value_type*)m_rbuf->span_ptr(x, y++, 1),
1101                                                            *colors++, *covers++);
1102                 }
1103                 while(--len);
1104             }
1105             else
1106             {
1107                 if(cover == 255)
1108                 {
1109                     do
1110                     {
1111                         value_type* p = (value_type*)m_rbuf->span_ptr(x, y++, 1);
1112                         p[order_type::R] = colors->r;
1113                         p[order_type::G] = colors->g;
1114                         p[order_type::B] = colors->b;
1115                         p[order_type::A] = base_mask;
1116                         ++colors;
1117                     }
1118                     while(--len);
1119                 }
1120                 else
1121                 {
1122                     do
1123                     {
1124                         blender_type::copy_or_blend_opaque_pix((value_type*)m_rbuf->span_ptr(x, y++, 1),
1125                                                                *colors++, cover);
1126                     }
1127                     while(--len);
1128                 }
1129             }
1130         }
1131
1132
1133
1134         //--------------------------------------------------------------------
1135         template<class Function> void for_each_pixel(Function f)
1136         {
1137             unsigned y;
1138             for(y = 0; y < height(); ++y)
1139             {
1140                 row_data sp = span(0, y);
1141                 if(sp.ptr)
1142                 {
1143                     value_type* p = (value_type*)sp.ptr;
1144                     while(sp.x1 <= sp.x2)
1145                     {
1146                         f(p);
1147                         p += 4;
1148                         ++sp.x1;
1149                     }
1150                 }
1151             }
1152         }
1153
1154
1155         //--------------------------------------------------------------------
1156         void premultiply()
1157         {
1158             for_each_pixel(multiplier_rgba<color_type, order_type>::premultiply);
1159         }
1160
1161         //--------------------------------------------------------------------
1162         void demultiply()
1163         {
1164             for_each_pixel(multiplier_rgba<color_type, order_type>::demultiply);
1165         }
1166
1167         //--------------------------------------------------------------------
1168         template<class GammaLut> void apply_gamma_dir(const GammaLut& g)
1169         {
1170             for_each_pixel(apply_gamma_dir_rgba<color_type, order_type, GammaLut>(g));
1171         }
1172
1173         //--------------------------------------------------------------------
1174         template<class GammaLut> void apply_gamma_inv(const GammaLut& g)
1175         {
1176             for_each_pixel(apply_gamma_inv_rgba<color_type, order_type, GammaLut>(g));
1177         }
1178
1179         //--------------------------------------------------------------------
1180         template<class RenBuf2> void copy_from(const RenBuf2& from,
1181                                                int xdst, int ydst,
1182                                                int xsrc, int ysrc,
1183                                                unsigned len)
1184         {
1185             const int8u* p = from.row(ysrc);
1186             if(p)
1187             {
1188                 p += xsrc * 4 * sizeof(value_type);
1189                 memmove(m_rbuf->span_ptr(xdst, ydst, len),
1190                         p,
1191                         len * 4 * sizeof(value_type));
1192             }
1193         }
1194
1195
1196
1197         //--------------------------------------------------------------------
1198         template<class SrcPixelFormatRenderer>
1199         void blend_from(const SrcPixelFormatRenderer& from,
1200                         const int8u* psrc_,
1201                         int xdst, int ydst,
1202                         int xsrc, int ysrc,
1203                         unsigned len)
1204         {
1205             typedef typename SrcPixelFormatRenderer::order_type src_order;
1206             const value_type* psrc = (const value_type*)psrc_;
1207             value_type* pdst = (value_type*)m_rbuf->span_ptr(xdst, ydst, len);
1208
1209             int incp = 4;
1210             if(xdst > xsrc)
1211             {
1212                 psrc += (len-1) << 2;
1213                 pdst += (len-1) << 2;
1214                 incp = -4;
1215             }
1216             do
1217             {
1218                 value_type alpha = psrc[src_order::A];
1219
1220                 if(alpha)
1221                 {
1222                     if(alpha == base_mask)
1223                     {
1224                         pdst[order_type::R] = psrc[src_order::R];
1225                         pdst[order_type::G] = psrc[src_order::G];
1226                         pdst[order_type::B] = psrc[src_order::B];
1227                         pdst[order_type::A] = psrc[src_order::A];
1228                     }
1229                     else
1230                     {
1231                         blender_type::blend_pix(pdst,
1232                                                 psrc[src_order::R],
1233                                                 psrc[src_order::G],
1234                                                 psrc[src_order::B],
1235                                                 alpha,
1236                                                 255);
1237                     }
1238                 }
1239                 psrc += incp;
1240                 pdst += incp;
1241             }
1242             while(--len);
1243         }
1244
1245
1246     private:
1247         rbuf_type* m_rbuf;
1248     };
1249
1250
1251
1252
1253
1254
1255
1256     //-----------------------------------------------------------------------
1257     typedef blender_rgba<rgba8, order_rgba, int32u> blender_rgba32; //----blender_rgba32
1258     typedef blender_rgba<rgba8, order_argb, int32u> blender_argb32; //----blender_argb32
1259     typedef blender_rgba<rgba8, order_abgr, int32u> blender_abgr32; //----blender_abgr32
1260     typedef blender_rgba<rgba8, order_bgra, int32u> blender_bgra32; //----blender_bgra32
1261
1262     typedef blender_rgba_pre<rgba8, order_rgba, int32u> blender_rgba32_pre; //----blender_rgba32_pre
1263     typedef blender_rgba_pre<rgba8, order_argb, int32u> blender_argb32_pre; //----blender_argb32_pre
1264     typedef blender_rgba_pre<rgba8, order_abgr, int32u> blender_abgr32_pre; //----blender_abgr32_pre
1265     typedef blender_rgba_pre<rgba8, order_bgra, int32u> blender_bgra32_pre; //----blender_bgra32_pre
1266
1267     typedef blender_rgba_plain<rgba8, order_rgba, int32u> blender_rgba32_plain; //----blender_rgba32_plain
1268     typedef blender_rgba_plain<rgba8, order_argb, int32u> blender_argb32_plain; //----blender_argb32_plain
1269     typedef blender_rgba_plain<rgba8, order_abgr, int32u> blender_abgr32_plain; //----blender_abgr32_plain
1270     typedef blender_rgba_plain<rgba8, order_bgra, int32u> blender_bgra32_plain; //----blender_bgra32_plain
1271
1272     struct  pixel64_type { int16u c[4]; };
1273     typedef blender_rgba<rgba16, order_rgba, pixel64_type> blender_rgba64; //----blender_rgba64
1274     typedef blender_rgba<rgba16, order_argb, pixel64_type> blender_argb64; //----blender_argb64
1275     typedef blender_rgba<rgba16, order_abgr, pixel64_type> blender_abgr64; //----blender_abgr64
1276     typedef blender_rgba<rgba16, order_bgra, pixel64_type> blender_bgra64; //----blender_bgra64
1277
1278     typedef blender_rgba_pre<rgba16, order_rgba, pixel64_type> blender_rgba64_pre; //----blender_rgba64_pre
1279     typedef blender_rgba_pre<rgba16, order_argb, pixel64_type> blender_argb64_pre; //----blender_argb64_pre
1280     typedef blender_rgba_pre<rgba16, order_abgr, pixel64_type> blender_abgr64_pre; //----blender_abgr64_pre
1281     typedef blender_rgba_pre<rgba16, order_bgra, pixel64_type> blender_bgra64_pre; //----blender_bgra64_pre
1282
1283
1284     //-----------------------------------------------------------------------
1285     typedef pixel_formats_rgba<blender_rgba32> pixfmt_rgba32; //----pixfmt_rgba32
1286     typedef pixel_formats_rgba<blender_argb32> pixfmt_argb32; //----pixfmt_argb32
1287     typedef pixel_formats_rgba<blender_abgr32> pixfmt_abgr32; //----pixfmt_abgr32
1288     typedef pixel_formats_rgba<blender_bgra32> pixfmt_bgra32; //----pixfmt_bgra32
1289
1290     typedef pixel_formats_rgba<blender_rgba32_pre> pixfmt_rgba32_pre; //----pixfmt_rgba32_pre
1291     typedef pixel_formats_rgba<blender_argb32_pre> pixfmt_argb32_pre; //----pixfmt_argb32_pre
1292     typedef pixel_formats_rgba<blender_abgr32_pre> pixfmt_abgr32_pre; //----pixfmt_abgr32_pre
1293     typedef pixel_formats_rgba<blender_bgra32_pre> pixfmt_bgra32_pre; //----pixfmt_bgra32_pre
1294
1295     typedef pixel_formats_rgba<blender_rgba32_plain> pixfmt_rgba32_plain; //----pixfmt_rgba32_plain
1296     typedef pixel_formats_rgba<blender_argb32_plain> pixfmt_argb32_plain; //----pixfmt_argb32_plain
1297     typedef pixel_formats_rgba<blender_abgr32_plain> pixfmt_abgr32_plain; //----pixfmt_abgr32_plain
1298     typedef pixel_formats_rgba<blender_bgra32_plain> pixfmt_bgra32_plain; //----pixfmt_bgra32_plain
1299
1300     typedef pixel_formats_rgba<blender_rgba64> pixfmt_rgba64; //----pixfmt_rgba64
1301     typedef pixel_formats_rgba<blender_argb64> pixfmt_argb64; //----pixfmt_argb64
1302     typedef pixel_formats_rgba<blender_abgr64> pixfmt_abgr64; //----pixfmt_abgr64
1303     typedef pixel_formats_rgba<blender_bgra64> pixfmt_bgra64; //----pixfmt_bgra64
1304
1305     typedef pixel_formats_rgba<blender_rgba64_pre> pixfmt_rgba64_pre; //----pixfmt_rgba64_pre
1306     typedef pixel_formats_rgba<blender_argb64_pre> pixfmt_argb64_pre; //----pixfmt_argb64_pre
1307     typedef pixel_formats_rgba<blender_abgr64_pre> pixfmt_abgr64_pre; //----pixfmt_abgr64_pre
1308     typedef pixel_formats_rgba<blender_bgra64_pre> pixfmt_bgra64_pre; //----pixfmt_bgra64_pre
1309 }
1310
1311 #endif
1312