agg/inc/agg_pixfmt_gray.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_GRAY_INCLUDED
  25 #define AGG_PIXFMT_GRAY_INCLUDED
  26
  27 #include <string.h>
  28 #include "agg_basics.h"
  29 #include "agg_color_gray.h"
  30 #include "agg_rendering_buffer.h"
  31
  32 namespace agg
  33 {
  34
  35     //============================================================blender_gray
  36     template<class ColorT> struct blender_gray
  37     {
  38         typedef ColorT color_type;
  39         typedef typename color_type::value_type value_type;
  40         typedef typename color_type::calc_type calc_type;
  41         enum { base_shift = color_type::base_shift };
  42
  43         static AGG_INLINE void blend_pix(value_type* p, unsigned cv,
  44                                          unsigned alpha, unsigned)
  45         {
  46             *p = (value_type)((((cv - calc_type(*p)) * alpha) + (calc_type(*p) << base_shift)) >> base_shift);
  47         }
  48     };
  49
  50
  51     //======================================================blender_gray_pre
  52     template<class ColorT> struct blender_gray_pre
  53     {
  54         typedef ColorT color_type;
  55         typedef typename color_type::value_type value_type;
  56         typedef typename color_type::calc_type calc_type;
  57         enum { base_shift = color_type::base_shift };
  58
  59         static AGG_INLINE void blend_pix(value_type* p, unsigned cv,
  60                                          unsigned alpha, unsigned cover)
  61         {
  62             alpha = color_type::base_mask - alpha;
  63             cover = (cover + 1) << (base_shift - 8);
  64             *p = (value_type)((*p * alpha + cv * cover) >> base_shift);
  65         }
  66     };
  67
  68
  69
  70     //=====================================================apply_gamma_dir_gray
  71     template<class ColorT, class GammaLut> class apply_gamma_dir_gray
  72     {
  73     public:
  74         typedef typename ColorT::value_type value_type;
  75
  76         apply_gamma_dir_gray(const GammaLut& gamma) : m_gamma(gamma) {}
  77
  78         AGG_INLINE void operator () (value_type* p)
  79         {
  80             *p = m_gamma.dir(*p);
  81         }
  82
  83     private:
  84         const GammaLut& m_gamma;
  85     };
  86
  87
  88
  89     //=====================================================apply_gamma_inv_gray
  90     template<class ColorT, class GammaLut> class apply_gamma_inv_gray
  91     {
  92     public:
  93         typedef typename ColorT::value_type value_type;
  94
  95         apply_gamma_inv_gray(const GammaLut& gamma) : m_gamma(gamma) {}
  96
  97         AGG_INLINE void operator () (value_type* p)
  98         {
  99             *p = m_gamma.inv(*p);
 100         }
 101
 102     private:
 103         const GammaLut& m_gamma;
 104     };
 105
 106
 107
 108     //======================================================pixel_formats_gray
 109     template<class Blender, unsigned Step=1, unsigned Offset=0>
 110     class pixel_formats_gray
 111     {
 112     public:
 113         typedef rendering_buffer::row_data row_data;
 114         typedef typename Blender::color_type color_type;
 115         typedef typename color_type::value_type value_type;
 116         typedef typename color_type::calc_type calc_type;
 117         enum
 118         {
 119             base_shift = color_type::base_shift,
 120             base_size  = color_type::base_size,
 121             base_mask  = color_type::base_mask
 122         };
 123
 124     private:
 125         //--------------------------------------------------------------------
 126         static AGG_INLINE void copy_or_blend_pix(value_type* p,
 127                                                  const color_type& c,
 128                                                  unsigned cover)
 129         {
 130             if (c.a)
 131             {
 132                 calc_type alpha = (calc_type(c.a) * (cover + 1)) >> 8;
 133                 if(alpha == base_mask)
 134                 {
 135                     *p = c.v;
 136                 }
 137                 else
 138                 {
 139                     Blender::blend_pix(p, c.v, alpha, cover);
 140                 }
 141             }
 142         }
 143
 144         //--------------------------------------------------------------------
 145         static AGG_INLINE void copy_or_blend_opaque_pix(value_type* p,
 146                                                         const color_type& c,
 147                                                         unsigned cover)
 148         {
 149             if(cover == 255)
 150             {
 151                 *p = c.v;
 152             }
 153             else
 154             {
 155                 Blender::blend_pix(p, c.v, (cover + 1) << (base_shift - 8), cover);
 156             }
 157         }
 158
 159     public:
 160         //--------------------------------------------------------------------
 161         pixel_formats_gray(rendering_buffer& rb) :
 162             m_rbuf(&rb)
 163         {}
 164
 165
 166         //--------------------------------------------------------------------
 167         AGG_INLINE unsigned width()  const { return m_rbuf->width();  }
 168         AGG_INLINE unsigned height() const { return m_rbuf->height(); }
 169
 170         //--------------------------------------------------------------------
 171         AGG_INLINE color_type pixel(int x, int y) const
 172         {
 173             value_type* p = (value_type*)m_rbuf->row(y) + x * Step + Offset;
 174             return color_type(*p);
 175         }
 176
 177         //--------------------------------------------------------------------
 178         row_data span(int x, int y) const
 179         {
 180             return row_data(x,
 181                             width() - 1,
 182                             m_rbuf->row(y) +
 183                                 x * Step * sizeof(value_type) +
 184                                 Offset * sizeof(value_type));
 185         }
 186
 187         //--------------------------------------------------------------------
 188         AGG_INLINE void copy_pixel(int x, int y, const color_type& c)
 189         {
 190             *((value_type*)m_rbuf->row(y) + x * Step + Offset) = c.v;
 191         }
 192
 193         //--------------------------------------------------------------------
 194         AGG_INLINE void blend_pixel(int x, int y, const color_type& c, int8u cover)
 195         {
 196             copy_or_blend_pix((value_type*)m_rbuf->row(y) + x * Step + Offset, c, cover);
 197         }
 198
 199
 200         //--------------------------------------------------------------------
 201         AGG_INLINE void copy_hline(int x, int y,
 202                                    unsigned len,
 203                                    const color_type& c)
 204         {
 205             value_type* p = (value_type*)m_rbuf->row(y) + x * Step + Offset;
 206             do
 207             {
 208                 *p = c.v;
 209                 p += Step;
 210             }
 211             while(--len);
 212         }
 213
 214
 215         //--------------------------------------------------------------------
 216         AGG_INLINE void copy_vline(int x, int y,
 217                                    unsigned len,
 218                                    const color_type& c)
 219         {
 220             value_type* p = (value_type*)m_rbuf->row(y) + x * Step + Offset;
 221             do
 222             {
 223                 *p = c.v;
 224                 p = (value_type*)m_rbuf->next_row(p);
 225             }
 226             while(--len);
 227         }
 228
 229
 230         //--------------------------------------------------------------------
 231         void blend_hline(int x, int y,
 232                          unsigned len,
 233                          const color_type& c,
 234                          int8u cover)
 235         {
 236             if (c.a)
 237             {
 238                 value_type* p = (value_type*)m_rbuf->row(y) + x * Step + Offset;
 239                 calc_type alpha = (calc_type(c.a) * (cover + 1)) >> 8;
 240                 if(alpha == base_mask)
 241                 {
 242                     do
 243                     {
 244                         *p = c.v;
 245                         p += Step;
 246                     }
 247                     while(--len);
 248                 }
 249                 else
 250                 {
 251                     do
 252                     {
 253                         Blender::blend_pix(p, c.v, alpha, cover);
 254                         p += Step;
 255                     }
 256                     while(--len);
 257                 }
 258             }
 259         }
 260
 261
 262         //--------------------------------------------------------------------
 263         void blend_vline(int x, int y,
 264                          unsigned len,
 265                          const color_type& c,
 266                          int8u cover)
 267         {
 268             if (c.a)
 269             {
 270                 value_type* p = (value_type*)m_rbuf->row(y) + x * Step + Offset;
 271                 calc_type alpha = (calc_type(c.a) * (cover + 1)) >> 8;
 272                 if(alpha == base_mask)
 273                 {
 274                     do
 275                     {
 276                         *p = c.v;
 277                         p = (value_type*)m_rbuf->next_row(p);
 278                     }
 279                     while(--len);
 280                 }
 281                 else
 282                 {
 283                     do
 284                     {
 285                         Blender::blend_pix(p, c.v, alpha, cover);
 286                         p = (value_type*)m_rbuf->next_row(p);
 287                     }
 288                     while(--len);
 289                 }
 290             }
 291         }
 292
 293
 294         //--------------------------------------------------------------------
 295         void blend_solid_hspan(int x, int y,
 296                                unsigned len,
 297                                const color_type& c,
 298                                const int8u* covers)
 299         {
 300             if (c.a)
 301             {
 302                 value_type* p = (value_type*)m_rbuf->row(y) + x * Step + Offset;
 303                 do
 304                 {
 305                     calc_type alpha = (calc_type(c.a) * (calc_type(*covers) + 1)) >> 8;
 306                     if(alpha == base_mask)
 307                     {
 308                         *p = c.v;
 309                     }
 310                     else
 311                     {
 312                         Blender::blend_pix(p, c.v, alpha, *covers);
 313                     }
 314                     p += Step;
 315                     ++covers;
 316                 }
 317                 while(--len);
 318             }
 319         }
 320
 321
 322         //--------------------------------------------------------------------
 323         void blend_solid_vspan(int x, int y,
 324                                unsigned len,
 325                                const color_type& c,
 326                                const int8u* covers)
 327         {
 328             if (c.a)
 329             {
 330                 value_type* p = (value_type*)m_rbuf->row(y) + x * Step + Offset;
 331                 do
 332                 {
 333                     calc_type alpha = (calc_type(c.a) * (calc_type(*covers) + 1)) >> 8;
 334                     if(alpha == base_mask)
 335                     {
 336                         *p = c.v;
 337                     }
 338                     else
 339                     {
 340                         Blender::blend_pix(p, c.v, alpha, *covers);
 341                     }
 342                     p = (value_type*)m_rbuf->next_row(p);
 343                     ++covers;
 344                 }
 345                 while(--len);
 346             }
 347         }
 348
 349
 350         //--------------------------------------------------------------------
 351         void blend_color_hspan(int x, int y,
 352                                unsigned len,
 353                                const color_type* colors,
 354                                const int8u* covers,
 355                                int8u cover)
 356         {
 357             value_type* p = (value_type*)m_rbuf->row(y) + x * Step + Offset;
 358             if(covers)
 359             {
 360                 do
 361                 {
 362                     copy_or_blend_pix(p, *colors++, *covers++);
 363                     p += Step;
 364                 }
 365                 while(--len);
 366             }
 367             else
 368             {
 369                 if(cover == 255)
 370                 {
 371                     do
 372                     {
 373                         if(colors->a == base_mask)
 374                         {
 375                             *p = colors->v;
 376                         }
 377                         else
 378                         {
 379                             copy_or_blend_pix(p, *colors, 255);
 380                         }
 381                         p += Step;
 382                         ++colors;
 383                     }
 384                     while(--len);
 385                 }
 386                 else
 387                 {
 388                     do
 389                     {
 390                         copy_or_blend_pix(p, *colors++, cover);
 391                         p += Step;
 392                     }
 393                     while(--len);
 394                 }
 395             }
 396         }
 397
 398
 399
 400         //--------------------------------------------------------------------
 401         void blend_color_vspan(int x, int y,
 402                                unsigned len,
 403                                const color_type* colors,
 404                                const int8u* covers,
 405                                int8u cover)
 406         {
 407             value_type* p = (value_type*)m_rbuf->row(y) + x * Step + Offset;
 408             if(covers)
 409             {
 410                 do
 411                 {
 412                     copy_or_blend_pix(p, *colors++, *covers++);
 413                     p = (value_type*)m_rbuf->next_row(p);
 414                 }
 415                 while(--len);
 416             }
 417             else
 418             {
 419                 if(cover == 255)
 420                 {
 421                     do
 422                     {
 423                         if(colors->a == base_mask)
 424                         {
 425                             *p = colors->v;
 426                         }
 427                         else
 428                         {
 429                             copy_or_blend_pix(p, *colors, 255);
 430                         }
 431                         p = (value_type*)m_rbuf->next_row(p);
 432                         ++colors;
 433                     }
 434                     while(--len);
 435                 }
 436                 else
 437                 {
 438                     do
 439                     {
 440                         copy_or_blend_pix(p, *colors++, cover);
 441                         p = (value_type*)m_rbuf->next_row(p);
 442                     }
 443                     while(--len);
 444                 }
 445             }
 446         }
 447
 448         //--------------------------------------------------------------------
 449         void blend_opaque_color_hspan(int x, int y,
 450                                       unsigned len,
 451                                       const color_type* colors,
 452                                       const int8u* covers,
 453                                       int8u cover)
 454         {
 455             value_type* p = (value_type*)m_rbuf->row(y) + x * Step + Offset;
 456             if(covers)
 457             {
 458                 do
 459                 {
 460                     copy_or_blend_opaque_pix(p, *colors++, *covers++);
 461                     p += Step;
 462                 }
 463                 while(--len);
 464             }
 465             else
 466             {
 467                 if(cover == 255)
 468                 {
 469                     do
 470                     {
 471                         *p = colors->v;
 472                         p += Step;
 473                         ++colors;
 474                     }
 475                     while(--len);
 476                 }
 477                 else
 478                 {
 479                     do
 480                     {
 481                         copy_or_blend_opaque_pix(p, *colors++, cover);
 482                         p += Step;
 483                     }
 484                     while(--len);
 485                 }
 486             }
 487         }
 488
 489
 490         //--------------------------------------------------------------------
 491         void blend_opaque_color_vspan(int x, int y,
 492                                       unsigned len,
 493                                       const color_type* colors,
 494                                       const int8u* covers,
 495                                       int8u cover)
 496         {
 497             value_type* p = (value_type*)m_rbuf->row(y) + x * Step + Offset;
 498             if(covers)
 499             {
 500                 do
 501                 {
 502                     copy_or_blend_opaque_pix(p, *colors++, *covers++);
 503                     p = (value_type*)m_rbuf->next_row(p);
 504                 }
 505                 while(--len);
 506             }
 507             else
 508             {
 509                 if(cover == 255)
 510                 {
 511                     do
 512                     {
 513                         *p = colors->v;
 514                         p = (value_type*)m_rbuf->next_row(p);
 515                         ++colors;
 516                     }
 517                     while(--len);
 518                 }
 519                 else
 520                 {
 521                     do
 522                     {
 523                         copy_or_blend_opaque_pix(p, *colors++, cover);
 524                         p = (value_type*)m_rbuf->next_row(p);
 525                     }
 526                     while(--len);
 527                 }
 528             }
 529         }
 530
 531         //--------------------------------------------------------------------
 532         template<class Function> void for_each_pixel(Function f)
 533         {
 534             unsigned y;
 535             for(y = 0; y < height(); ++y)
 536             {
 537                 unsigned len = width();
 538                 value_type* p = (value_type*)m_rbuf->row(y) + Offset;
 539                 do
 540                 {
 541                     f(p);
 542                     p += Step;
 543                 }
 544                 while(--len);
 545             }
 546         }
 547
 548         //--------------------------------------------------------------------
 549         template<class GammaLut> void apply_gamma_dir(const GammaLut& g)
 550         {
 551             for_each_pixel(apply_gamma_dir_gray<color_type, GammaLut>(g));
 552         }
 553
 554         //--------------------------------------------------------------------
 555         template<class GammaLut> void apply_gamma_inv(const GammaLut& g)
 556         {
 557             for_each_pixel(apply_gamma_inv_gray<color_type, GammaLut>(g));
 558         }
 559
 560         //--------------------------------------------------------------------
 561         void copy_from(const rendering_buffer& from,
 562                        int xdst, int ydst,
 563                        int xsrc, int ysrc,
 564                        unsigned len)
 565         {
 566             memmove((value_type*)m_rbuf->row(ydst) + xdst,
 567                     (value_type*)from.row(ysrc) + xsrc,
 568                     sizeof(value_type) * len);
 569         }
 570
 571     private:
 572         rendering_buffer* m_rbuf;
 573     };
 574
 575     typedef blender_gray<gray8>      blender_gray8;
 576     typedef blender_gray_pre<gray8>  blender_gray8_pre;
 577     typedef blender_gray<gray16>     blender_gray16;
 578     typedef blender_gray_pre<gray16> blender_gray16_pre;
 579
 580     typedef pixel_formats_gray<blender_gray8, 1, 0> pixfmt_gray8;         //----pixfmt_gray8
 581
 582     typedef pixel_formats_gray<blender_gray8, 3, 0> pixfmt_gray8_rgb24r;  //----pixfmt_gray8_rgb24r
 583     typedef pixel_formats_gray<blender_gray8, 3, 1> pixfmt_gray8_rgb24g;  //----pixfmt_gray8_rgb24g
 584     typedef pixel_formats_gray<blender_gray8, 3, 2> pixfmt_gray8_rgb24b;  //----pixfmt_gray8_rgb24b
 585
 586     typedef pixel_formats_gray<blender_gray8, 3, 2> pixfmt_gray8_bgr24r;  //----pixfmt_gray8_bgr24r
 587     typedef pixel_formats_gray<blender_gray8, 3, 1> pixfmt_gray8_bgr24g;  //----pixfmt_gray8_bgr24g
 588     typedef pixel_formats_gray<blender_gray8, 3, 0> pixfmt_gray8_bgr24b;  //----pixfmt_gray8_bgr24b
 589
 590     typedef pixel_formats_gray<blender_gray8, 4, 0> pixfmt_gray8_rgba32r; //----pixfmt_gray8_rgba32r
 591     typedef pixel_formats_gray<blender_gray8, 4, 1> pixfmt_gray8_rgba32g; //----pixfmt_gray8_rgba32g
 592     typedef pixel_formats_gray<blender_gray8, 4, 2> pixfmt_gray8_rgba32b; //----pixfmt_gray8_rgba32b
 593     typedef pixel_formats_gray<blender_gray8, 4, 3> pixfmt_gray8_rgba32a; //----pixfmt_gray8_rgba32a
 594
 595     typedef pixel_formats_gray<blender_gray8, 4, 1> pixfmt_gray8_argb32r; //----pixfmt_gray8_argb32r
 596     typedef pixel_formats_gray<blender_gray8, 4, 2> pixfmt_gray8_argb32g; //----pixfmt_gray8_argb32g
 597     typedef pixel_formats_gray<blender_gray8, 4, 3> pixfmt_gray8_argb32b; //----pixfmt_gray8_argb32b
 598     typedef pixel_formats_gray<blender_gray8, 4, 0> pixfmt_gray8_argb32a; //----pixfmt_gray8_argb32a
 599
 600     typedef pixel_formats_gray<blender_gray8, 4, 2> pixfmt_gray8_bgra32r; //----pixfmt_gray8_bgra32r
 601     typedef pixel_formats_gray<blender_gray8, 4, 1> pixfmt_gray8_bgra32g; //----pixfmt_gray8_bgra32g
 602     typedef pixel_formats_gray<blender_gray8, 4, 0> pixfmt_gray8_bgra32b; //----pixfmt_gray8_bgra32b
 603     typedef pixel_formats_gray<blender_gray8, 4, 3> pixfmt_gray8_bgra32a; //----pixfmt_gray8_bgra32a
 604
 605     typedef pixel_formats_gray<blender_gray8, 4, 3> pixfmt_gray8_abgr32r; //----pixfmt_gray8_abgr32r
 606     typedef pixel_formats_gray<blender_gray8, 4, 2> pixfmt_gray8_abgr32g; //----pixfmt_gray8_abgr32g
 607     typedef pixel_formats_gray<blender_gray8, 4, 1> pixfmt_gray8_abgr32b; //----pixfmt_gray8_abgr32b
 608     typedef pixel_formats_gray<blender_gray8, 4, 0> pixfmt_gray8_abgr32a; //----pixfmt_gray8_abgr32a
 609
 610     typedef pixel_formats_gray<blender_gray8_pre, 1, 0> pixfmt_gray8_pre;         //----pixfmt_gray8_pre
 611
 612     typedef pixel_formats_gray<blender_gray8_pre, 3, 0> pixfmt_gray8_pre_rgb24r;  //----pixfmt_gray8_pre_rgb24r
 613     typedef pixel_formats_gray<blender_gray8_pre, 3, 1> pixfmt_gray8_pre_rgb24g;  //----pixfmt_gray8_pre_rgb24g
 614     typedef pixel_formats_gray<blender_gray8_pre, 3, 2> pixfmt_gray8_pre_rgb24b;  //----pixfmt_gray8_pre_rgb24b
 615
 616     typedef pixel_formats_gray<blender_gray8_pre, 3, 2> pixfmt_gray8_pre_bgr24r;  //----pixfmt_gray8_pre_bgr24r
 617     typedef pixel_formats_gray<blender_gray8_pre, 3, 1> pixfmt_gray8_pre_bgr24g;  //----pixfmt_gray8_pre_bgr24g
 618     typedef pixel_formats_gray<blender_gray8_pre, 3, 0> pixfmt_gray8_pre_bgr24b;  //----pixfmt_gray8_pre_bgr24b
 619
 620     typedef pixel_formats_gray<blender_gray8_pre, 4, 0> pixfmt_gray8_pre_rgba32r; //----pixfmt_gray8_pre_rgba32r
 621     typedef pixel_formats_gray<blender_gray8_pre, 4, 1> pixfmt_gray8_pre_rgba32g; //----pixfmt_gray8_pre_rgba32g
 622     typedef pixel_formats_gray<blender_gray8_pre, 4, 2> pixfmt_gray8_pre_rgba32b; //----pixfmt_gray8_pre_rgba32b
 623     typedef pixel_formats_gray<blender_gray8_pre, 4, 3> pixfmt_gray8_pre_rgba32a; //----pixfmt_gray8_pre_rgba32a
 624
 625     typedef pixel_formats_gray<blender_gray8_pre, 4, 1> pixfmt_gray8_pre_argb32r; //----pixfmt_gray8_pre_argb32r
 626     typedef pixel_formats_gray<blender_gray8_pre, 4, 2> pixfmt_gray8_pre_argb32g; //----pixfmt_gray8_pre_argb32g
 627     typedef pixel_formats_gray<blender_gray8_pre, 4, 3> pixfmt_gray8_pre_argb32b; //----pixfmt_gray8_pre_argb32b
 628     typedef pixel_formats_gray<blender_gray8_pre, 4, 0> pixfmt_gray8_pre_argb32a; //----pixfmt_gray8_pre_argb32a
 629
 630     typedef pixel_formats_gray<blender_gray8_pre, 4, 2> pixfmt_gray8_pre_bgra32r; //----pixfmt_gray8_pre_bgra32r
 631     typedef pixel_formats_gray<blender_gray8_pre, 4, 1> pixfmt_gray8_pre_bgra32g; //----pixfmt_gray8_pre_bgra32g
 632     typedef pixel_formats_gray<blender_gray8_pre, 4, 0> pixfmt_gray8_pre_bgra32b; //----pixfmt_gray8_pre_bgra32b
 633     typedef pixel_formats_gray<blender_gray8_pre, 4, 3> pixfmt_gray8_pre_bgra32a; //----pixfmt_gray8_pre_bgra32a
 634
 635     typedef pixel_formats_gray<blender_gray8_pre, 4, 3> pixfmt_gray8_pre_abgr32r; //----pixfmt_gray8_pre_abgr32r
 636     typedef pixel_formats_gray<blender_gray8_pre, 4, 2> pixfmt_gray8_pre_abgr32g; //----pixfmt_gray8_pre_abgr32g
 637     typedef pixel_formats_gray<blender_gray8_pre, 4, 1> pixfmt_gray8_pre_abgr32b; //----pixfmt_gray8_pre_abgr32b
 638     typedef pixel_formats_gray<blender_gray8_pre, 4, 0> pixfmt_gray8_pre_abgr32a; //----pixfmt_gray8_pre_abgr32a
 639
 640     typedef pixel_formats_gray<blender_gray16, 1, 0> pixfmt_gray16;         //----pixfmt_gray16
 641
 642     typedef pixel_formats_gray<blender_gray16, 3, 0> pixfmt_gray16_rgb48r;  //----pixfmt_gray16_rgb48r
 643     typedef pixel_formats_gray<blender_gray16, 3, 1> pixfmt_gray16_rgb48g;  //----pixfmt_gray16_rgb48g
 644     typedef pixel_formats_gray<blender_gray16, 3, 2> pixfmt_gray16_rgb48b;  //----pixfmt_gray16_rgb48b
 645
 646     typedef pixel_formats_gray<blender_gray16, 3, 2> pixfmt_gray16_bgr48r;  //----pixfmt_gray16_bgr48r
 647     typedef pixel_formats_gray<blender_gray16, 3, 1> pixfmt_gray16_bgr48g;  //----pixfmt_gray16_bgr48g
 648     typedef pixel_formats_gray<blender_gray16, 3, 0> pixfmt_gray16_bgr48b;  //----pixfmt_gray16_bgr48b
 649
 650     typedef pixel_formats_gray<blender_gray16, 4, 0> pixfmt_gray16_rgba64r; //----pixfmt_gray16_rgba64r
 651     typedef pixel_formats_gray<blender_gray16, 4, 1> pixfmt_gray16_rgba64g; //----pixfmt_gray16_rgba64g
 652     typedef pixel_formats_gray<blender_gray16, 4, 2> pixfmt_gray16_rgba64b; //----pixfmt_gray16_rgba64b
 653     typedef pixel_formats_gray<blender_gray16, 4, 3> pixfmt_gray16_rgba64a; //----pixfmt_gray16_rgba64a
 654
 655     typedef pixel_formats_gray<blender_gray16, 4, 1> pixfmt_gray16_argb64r; //----pixfmt_gray16_argb64r
 656     typedef pixel_formats_gray<blender_gray16, 4, 2> pixfmt_gray16_argb64g; //----pixfmt_gray16_argb64g
 657     typedef pixel_formats_gray<blender_gray16, 4, 3> pixfmt_gray16_argb64b; //----pixfmt_gray16_argb64b
 658     typedef pixel_formats_gray<blender_gray16, 4, 0> pixfmt_gray16_argb64a; //----pixfmt_gray16_argb64a
 659
 660     typedef pixel_formats_gray<blender_gray16, 4, 2> pixfmt_gray16_bgra64r; //----pixfmt_gray16_bgra64r
 661     typedef pixel_formats_gray<blender_gray16, 4, 1> pixfmt_gray16_bgra64g; //----pixfmt_gray16_bgra64g
 662     typedef pixel_formats_gray<blender_gray16, 4, 0> pixfmt_gray16_bgra64b; //----pixfmt_gray16_bgra64b
 663     typedef pixel_formats_gray<blender_gray16, 4, 3> pixfmt_gray16_bgra64a; //----pixfmt_gray16_bgra64a
 664
 665     typedef pixel_formats_gray<blender_gray16, 4, 3> pixfmt_gray16_abgr64r; //----pixfmt_gray16_abgr64r
 666     typedef pixel_formats_gray<blender_gray16, 4, 2> pixfmt_gray16_abgr64g; //----pixfmt_gray16_abgr64g
 667     typedef pixel_formats_gray<blender_gray16, 4, 1> pixfmt_gray16_abgr64b; //----pixfmt_gray16_abgr64b
 668     typedef pixel_formats_gray<blender_gray16, 4, 0> pixfmt_gray16_abgr64a; //----pixfmt_gray16_abgr64a
 669
 670     typedef pixel_formats_gray<blender_gray16_pre, 1, 0> pixfmt_gray16_pre;         //----pixfmt_gray16_pre
 671
 672     typedef pixel_formats_gray<blender_gray16_pre, 3, 0> pixfmt_gray16_pre_rgb48r;  //----pixfmt_gray16_pre_rgb48r
 673     typedef pixel_formats_gray<blender_gray16_pre, 3, 1> pixfmt_gray16_pre_rgb48g;  //----pixfmt_gray16_pre_rgb48g
 674     typedef pixel_formats_gray<blender_gray16_pre, 3, 2> pixfmt_gray16_pre_rgb48b;  //----pixfmt_gray16_pre_rgb48b
 675
 676     typedef pixel_formats_gray<blender_gray16_pre, 3, 2> pixfmt_gray16_pre_bgr48r;  //----pixfmt_gray16_pre_bgr48r
 677     typedef pixel_formats_gray<blender_gray16_pre, 3, 1> pixfmt_gray16_pre_bgr48g;  //----pixfmt_gray16_pre_bgr48g
 678     typedef pixel_formats_gray<blender_gray16_pre, 3, 0> pixfmt_gray16_pre_bgr48b;  //----pixfmt_gray16_pre_bgr48b
 679
 680     typedef pixel_formats_gray<blender_gray16_pre, 4, 0> pixfmt_gray16_pre_rgba64r; //----pixfmt_gray16_pre_rgba64r
 681     typedef pixel_formats_gray<blender_gray16_pre, 4, 1> pixfmt_gray16_pre_rgba64g; //----pixfmt_gray16_pre_rgba64g
 682     typedef pixel_formats_gray<blender_gray16_pre, 4, 2> pixfmt_gray16_pre_rgba64b; //----pixfmt_gray16_pre_rgba64b
 683     typedef pixel_formats_gray<blender_gray16_pre, 4, 3> pixfmt_gray16_pre_rgba64a; //----pixfmt_gray16_pre_rgba64a
 684
 685     typedef pixel_formats_gray<blender_gray16_pre, 4, 1> pixfmt_gray16_pre_argb64r; //----pixfmt_gray16_pre_argb64r
 686     typedef pixel_formats_gray<blender_gray16_pre, 4, 2> pixfmt_gray16_pre_argb64g; //----pixfmt_gray16_pre_argb64g
 687     typedef pixel_formats_gray<blender_gray16_pre, 4, 3> pixfmt_gray16_pre_argb64b; //----pixfmt_gray16_pre_argb64b
 688     typedef pixel_formats_gray<blender_gray16_pre, 4, 0> pixfmt_gray16_pre_argb64a; //----pixfmt_gray16_pre_argb64a
 689
 690     typedef pixel_formats_gray<blender_gray16_pre, 4, 2> pixfmt_gray16_pre_bgra64r; //----pixfmt_gray16_pre_bgra64r
 691     typedef pixel_formats_gray<blender_gray16_pre, 4, 1> pixfmt_gray16_pre_bgra64g; //----pixfmt_gray16_pre_bgra64g
 692     typedef pixel_formats_gray<blender_gray16_pre, 4, 0> pixfmt_gray16_pre_bgra64b; //----pixfmt_gray16_pre_bgra64b
 693     typedef pixel_formats_gray<blender_gray16_pre, 4, 3> pixfmt_gray16_pre_bgra64a; //----pixfmt_gray16_pre_bgra64a
 694
 695     typedef pixel_formats_gray<blender_gray16_pre, 4, 3> pixfmt_gray16_pre_abgr64r; //----pixfmt_gray16_pre_abgr64r
 696     typedef pixel_formats_gray<blender_gray16_pre, 4, 2> pixfmt_gray16_pre_abgr64g; //----pixfmt_gray16_pre_abgr64g
 697     typedef pixel_formats_gray<blender_gray16_pre, 4, 1> pixfmt_gray16_pre_abgr64b; //----pixfmt_gray16_pre_abgr64b
 698     typedef pixel_formats_gray<blender_gray16_pre, 4, 0> pixfmt_gray16_pre_abgr64a; //----pixfmt_gray16_pre_abgr64a
 699
 700 }
 701
 702 #endif
 703