src/png/pngtrans.c

   1
   2 /* pngtrans.c - transforms the data in a row (used by both readers and writers)
   3  *
   4  * libpng 1.0.1
   5  * For conditions of distribution and use, see copyright notice in png.h
   6  * Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
   7  * Copyright (c) 1996, 1997 Andreas Dilger
   8  * Copyright (c) 1998, Glenn Randers-Pehrson
   9  * March 15, 1998
  10  */
  11
  12 #define PNG_INTERNAL
  13 #include "png.h"
  14
  15 #if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED)
  16 /* turn on bgr to rgb mapping */
  17 void
  18 png_set_bgr(png_structp png_ptr)
  19 {
  20    png_debug(1, "in png_set_bgr\n");
  21    png_ptr->transformations |= PNG_BGR;
  22 }
  23 #endif
  24
  25 #if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED)
  26 /* turn on 16 bit byte swapping */
  27 void
  28 png_set_swap(png_structp png_ptr)
  29 {
  30    png_debug(1, "in png_set_swap\n");
  31    if (png_ptr->bit_depth == 16)
  32       png_ptr->transformations |= PNG_SWAP_BYTES;
  33 }
  34 #endif
  35
  36 #if defined(PNG_READ_PACK_SUPPORTED) || defined(PNG_WRITE_PACK_SUPPORTED)
  37 /* turn on pixel packing */
  38 void
  39 png_set_packing(png_structp png_ptr)
  40 {
  41    png_debug(1, "in png_set_packing\n");
  42    if (png_ptr->bit_depth < 8)
  43    {
  44       png_ptr->transformations |= PNG_PACK;
  45       png_ptr->usr_bit_depth = 8;
  46    }
  47 }
  48 #endif
  49
  50 #if defined(PNG_READ_PACKSWAP_SUPPORTED)||defined(PNG_WRITE_PACKSWAP_SUPPORTED)
  51 /* turn on packed pixel swapping */
  52 void
  53 png_set_packswap(png_structp png_ptr)
  54 {
  55    png_debug(1, "in png_set_packswap\n");
  56    if (png_ptr->bit_depth < 8)
  57       png_ptr->transformations |= PNG_PACKSWAP;
  58 }
  59 #endif
  60
  61 #if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED)
  62 void
  63 png_set_shift(png_structp png_ptr, png_color_8p true_bits)
  64 {
  65    png_debug(1, "in png_set_shift\n");
  66    png_ptr->transformations |= PNG_SHIFT;
  67    png_ptr->shift = *true_bits;
  68 }
  69 #endif
  70
  71 #if defined(PNG_READ_INTERLACING_SUPPORTED) || \
  72     defined(PNG_WRITE_INTERLACING_SUPPORTED)
  73 int
  74 png_set_interlace_handling(png_structp png_ptr)
  75 {
  76    png_debug(1, "in png_set_interlace handling\n");
  77    if (png_ptr->interlaced)
  78    {
  79       png_ptr->transformations |= PNG_INTERLACE;
  80       return (7);
  81    }
  82
  83    return (1);
  84 }
  85 #endif
  86
  87 #if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED)
  88 /* Add a filler byte on read, or remove a filler or alpha byte on write.
  89  * The filler type has changed in v0.95 to allow future 2-byte fillers
  90  * for 48-bit input data, as well as avoiding problems with some compilers
  91  * which don't like bytes as parameters.
  92  */
  93 void
  94 png_set_filler(png_structp png_ptr, png_uint_32 filler, int filler_loc)
  95 {
  96    png_debug(1, "in png_set_filler\n");
  97    png_ptr->transformations |= PNG_FILLER;
  98    png_ptr->filler = (png_byte)filler;
  99    if (filler_loc == PNG_FILLER_AFTER)
 100       png_ptr->flags |= PNG_FLAG_FILLER_AFTER;
 101    else
 102       png_ptr->flags &= ~PNG_FLAG_FILLER_AFTER;
 103
 104    /* This should probably go in the "do_filler" routine */
 105    if (png_ptr->color_type == PNG_COLOR_TYPE_RGB && png_ptr->bit_depth == 8)
 106    {
 107       png_ptr->usr_channels = 4;
 108    }
 109 }
 110 #endif
 111
 112 #if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) || \
 113     defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED)
 114 void
 115 png_set_swap_alpha(png_structp png_ptr)
 116 {
 117    png_debug(1, "in png_set_swap_alpha\n");
 118    png_ptr->transformations |= PNG_SWAP_ALPHA;
 119 }
 120 #endif
 121
 122 #if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) || \
 123     defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED)
 124 void
 125 png_set_invert_alpha(png_structp png_ptr)
 126 {
 127    png_debug(1, "in png_set_invert_alpha\n");
 128    png_ptr->transformations |= PNG_INVERT_ALPHA;
 129 }
 130 #endif
 131
 132 #if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED)
 133 void
 134 png_set_invert_mono(png_structp png_ptr)
 135 {
 136    png_debug(1, "in png_set_invert_mono\n");
 137    png_ptr->transformations |= PNG_INVERT_MONO;
 138 }
 139
 140 /* invert monocrome grayscale data */
 141 void
 142 png_do_invert(png_row_infop row_info, png_bytep row)
 143 {
 144    png_debug(1, "in png_do_invert\n");
 145    if (row_info->bit_depth == 1 &&
 146 #if defined(PNG_USELESS_TESTS_SUPPORTED)
 147        row != NULL && row_info != NULL &&
 148 #endif
 149        row_info->color_type == PNG_COLOR_TYPE_GRAY)
 150    {
 151       png_bytep rp;
 152       png_uint_32 i;
 153
 154       for (i = 0, rp = row; i < row_info->rowbytes; i++, rp++)
 155       {
 156          *rp = (png_byte)(~(*rp));
 157       }
 158    }
 159 }
 160 #endif
 161
 162 #if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED)
 163 /* swaps byte order on 16 bit depth images */
 164 void
 165 png_do_swap(png_row_infop row_info, png_bytep row)
 166 {
 167    png_debug(1, "in png_do_swap\n");
 168    if (
 169 #if defined(PNG_USELESS_TESTS_SUPPORTED)
 170        row != NULL && row_info != NULL &&
 171 #endif
 172        row_info->bit_depth == 16)
 173    {
 174       png_bytep rp;
 175       png_byte t;
 176       png_uint_32 i;
 177
 178       for (i = 0, rp = row;
 179          i < row_info->width * row_info->channels;
 180          i++, rp += 2)
 181       {
 182          t = *rp;
 183          *rp = *(rp + 1);
 184          *(rp + 1) = t;
 185       }
 186    }
 187 }
 188 #endif
 189
 190 #if defined(PNG_READ_PACKSWAP_SUPPORTED)||defined(PNG_WRITE_PACKSWAP_SUPPORTED)
 191 static png_byte onebppswaptable[256] = {
 192    0x00, 0x80, 0x40, 0xC0, 0x20, 0xA0, 0x60, 0xE0,
 193    0x10, 0x90, 0x50, 0xD0, 0x30, 0xB0, 0x70, 0xF0,
 194    0x08, 0x88, 0x48, 0xC8, 0x28, 0xA8, 0x68, 0xE8,
 195    0x18, 0x98, 0x58, 0xD8, 0x38, 0xB8, 0x78, 0xF8,
 196    0x04, 0x84, 0x44, 0xC4, 0x24, 0xA4, 0x64, 0xE4,
 197    0x14, 0x94, 0x54, 0xD4, 0x34, 0xB4, 0x74, 0xF4,
 198    0x0C, 0x8C, 0x4C, 0xCC, 0x2C, 0xAC, 0x6C, 0xEC,
 199    0x1C, 0x9C, 0x5C, 0xDC, 0x3C, 0xBC, 0x7C, 0xFC,
 200    0x02, 0x82, 0x42, 0xC2, 0x22, 0xA2, 0x62, 0xE2,
 201    0x12, 0x92, 0x52, 0xD2, 0x32, 0xB2, 0x72, 0xF2,
 202    0x0A, 0x8A, 0x4A, 0xCA, 0x2A, 0xAA, 0x6A, 0xEA,
 203    0x1A, 0x9A, 0x5A, 0xDA, 0x3A, 0xBA, 0x7A, 0xFA,
 204    0x06, 0x86, 0x46, 0xC6, 0x26, 0xA6, 0x66, 0xE6,
 205    0x16, 0x96, 0x56, 0xD6, 0x36, 0xB6, 0x76, 0xF6,
 206    0x0E, 0x8E, 0x4E, 0xCE, 0x2E, 0xAE, 0x6E, 0xEE,
 207    0x1E, 0x9E, 0x5E, 0xDE, 0x3E, 0xBE, 0x7E, 0xFE,
 208    0x01, 0x81, 0x41, 0xC1, 0x21, 0xA1, 0x61, 0xE1,
 209    0x11, 0x91, 0x51, 0xD1, 0x31, 0xB1, 0x71, 0xF1,
 210    0x09, 0x89, 0x49, 0xC9, 0x29, 0xA9, 0x69, 0xE9,
 211    0x19, 0x99, 0x59, 0xD9, 0x39, 0xB9, 0x79, 0xF9,
 212    0x05, 0x85, 0x45, 0xC5, 0x25, 0xA5, 0x65, 0xE5,
 213    0x15, 0x95, 0x55, 0xD5, 0x35, 0xB5, 0x75, 0xF5,
 214    0x0D, 0x8D, 0x4D, 0xCD, 0x2D, 0xAD, 0x6D, 0xED,
 215    0x1D, 0x9D, 0x5D, 0xDD, 0x3D, 0xBD, 0x7D, 0xFD,
 216    0x03, 0x83, 0x43, 0xC3, 0x23, 0xA3, 0x63, 0xE3,
 217    0x13, 0x93, 0x53, 0xD3, 0x33, 0xB3, 0x73, 0xF3,
 218    0x0B, 0x8B, 0x4B, 0xCB, 0x2B, 0xAB, 0x6B, 0xEB,
 219    0x1B, 0x9B, 0x5B, 0xDB, 0x3B, 0xBB, 0x7B, 0xFB,
 220    0x07, 0x87, 0x47, 0xC7, 0x27, 0xA7, 0x67, 0xE7,
 221    0x17, 0x97, 0x57, 0xD7, 0x37, 0xB7, 0x77, 0xF7,
 222    0x0F, 0x8F, 0x4F, 0xCF, 0x2F, 0xAF, 0x6F, 0xEF,
 223    0x1F, 0x9F, 0x5F, 0xDF, 0x3F, 0xBF, 0x7F, 0xFF
 224 };
 225
 226 static png_byte twobppswaptable[256] = {
 227    0x00, 0x40, 0x80, 0xC0, 0x10, 0x50, 0x90, 0xD0,
 228    0x20, 0x60, 0xA0, 0xE0, 0x30, 0x70, 0xB0, 0xF0,
 229    0x04, 0x44, 0x84, 0xC4, 0x14, 0x54, 0x94, 0xD4,
 230    0x24, 0x64, 0xA4, 0xE4, 0x34, 0x74, 0xB4, 0xF4,
 231    0x08, 0x48, 0x88, 0xC8, 0x18, 0x58, 0x98, 0xD8,
 232    0x28, 0x68, 0xA8, 0xE8, 0x38, 0x78, 0xB8, 0xF8,
 233    0x0C, 0x4C, 0x8C, 0xCC, 0x1C, 0x5C, 0x9C, 0xDC,
 234    0x2C, 0x6C, 0xAC, 0xEC, 0x3C, 0x7C, 0xBC, 0xFC,
 235    0x01, 0x41, 0x81, 0xC1, 0x11, 0x51, 0x91, 0xD1,
 236    0x21, 0x61, 0xA1, 0xE1, 0x31, 0x71, 0xB1, 0xF1,
 237    0x05, 0x45, 0x85, 0xC5, 0x15, 0x55, 0x95, 0xD5,
 238    0x25, 0x65, 0xA5, 0xE5, 0x35, 0x75, 0xB5, 0xF5,
 239    0x09, 0x49, 0x89, 0xC9, 0x19, 0x59, 0x99, 0xD9,
 240    0x29, 0x69, 0xA9, 0xE9, 0x39, 0x79, 0xB9, 0xF9,
 241    0x0D, 0x4D, 0x8D, 0xCD, 0x1D, 0x5D, 0x9D, 0xDD,
 242    0x2D, 0x6D, 0xAD, 0xED, 0x3D, 0x7D, 0xBD, 0xFD,
 243    0x02, 0x42, 0x82, 0xC2, 0x12, 0x52, 0x92, 0xD2,
 244    0x22, 0x62, 0xA2, 0xE2, 0x32, 0x72, 0xB2, 0xF2,
 245    0x06, 0x46, 0x86, 0xC6, 0x16, 0x56, 0x96, 0xD6,
 246    0x26, 0x66, 0xA6, 0xE6, 0x36, 0x76, 0xB6, 0xF6,
 247    0x0A, 0x4A, 0x8A, 0xCA, 0x1A, 0x5A, 0x9A, 0xDA,
 248    0x2A, 0x6A, 0xAA, 0xEA, 0x3A, 0x7A, 0xBA, 0xFA,
 249    0x0E, 0x4E, 0x8E, 0xCE, 0x1E, 0x5E, 0x9E, 0xDE,
 250    0x2E, 0x6E, 0xAE, 0xEE, 0x3E, 0x7E, 0xBE, 0xFE,
 251    0x03, 0x43, 0x83, 0xC3, 0x13, 0x53, 0x93, 0xD3,
 252    0x23, 0x63, 0xA3, 0xE3, 0x33, 0x73, 0xB3, 0xF3,
 253    0x07, 0x47, 0x87, 0xC7, 0x17, 0x57, 0x97, 0xD7,
 254    0x27, 0x67, 0xA7, 0xE7, 0x37, 0x77, 0xB7, 0xF7,
 255    0x0B, 0x4B, 0x8B, 0xCB, 0x1B, 0x5B, 0x9B, 0xDB,
 256    0x2B, 0x6B, 0xAB, 0xEB, 0x3B, 0x7B, 0xBB, 0xFB,
 257    0x0F, 0x4F, 0x8F, 0xCF, 0x1F, 0x5F, 0x9F, 0xDF,
 258    0x2F, 0x6F, 0xAF, 0xEF, 0x3F, 0x7F, 0xBF, 0xFF
 259 };
 260
 261 static png_byte fourbppswaptable[256] = {
 262    0x00, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70,
 263    0x80, 0x90, 0xA0, 0xB0, 0xC0, 0xD0, 0xE0, 0xF0,
 264    0x01, 0x11, 0x21, 0x31, 0x41, 0x51, 0x61, 0x71,
 265    0x81, 0x91, 0xA1, 0xB1, 0xC1, 0xD1, 0xE1, 0xF1,
 266    0x02, 0x12, 0x22, 0x32, 0x42, 0x52, 0x62, 0x72,
 267    0x82, 0x92, 0xA2, 0xB2, 0xC2, 0xD2, 0xE2, 0xF2,
 268    0x03, 0x13, 0x23, 0x33, 0x43, 0x53, 0x63, 0x73,
 269    0x83, 0x93, 0xA3, 0xB3, 0xC3, 0xD3, 0xE3, 0xF3,
 270    0x04, 0x14, 0x24, 0x34, 0x44, 0x54, 0x64, 0x74,
 271    0x84, 0x94, 0xA4, 0xB4, 0xC4, 0xD4, 0xE4, 0xF4,
 272    0x05, 0x15, 0x25, 0x35, 0x45, 0x55, 0x65, 0x75,
 273    0x85, 0x95, 0xA5, 0xB5, 0xC5, 0xD5, 0xE5, 0xF5,
 274    0x06, 0x16, 0x26, 0x36, 0x46, 0x56, 0x66, 0x76,
 275    0x86, 0x96, 0xA6, 0xB6, 0xC6, 0xD6, 0xE6, 0xF6,
 276    0x07, 0x17, 0x27, 0x37, 0x47, 0x57, 0x67, 0x77,
 277    0x87, 0x97, 0xA7, 0xB7, 0xC7, 0xD7, 0xE7, 0xF7,
 278    0x08, 0x18, 0x28, 0x38, 0x48, 0x58, 0x68, 0x78,
 279    0x88, 0x98, 0xA8, 0xB8, 0xC8, 0xD8, 0xE8, 0xF8,
 280    0x09, 0x19, 0x29, 0x39, 0x49, 0x59, 0x69, 0x79,
 281    0x89, 0x99, 0xA9, 0xB9, 0xC9, 0xD9, 0xE9, 0xF9,
 282    0x0A, 0x1A, 0x2A, 0x3A, 0x4A, 0x5A, 0x6A, 0x7A,
 283    0x8A, 0x9A, 0xAA, 0xBA, 0xCA, 0xDA, 0xEA, 0xFA,
 284    0x0B, 0x1B, 0x2B, 0x3B, 0x4B, 0x5B, 0x6B, 0x7B,
 285    0x8B, 0x9B, 0xAB, 0xBB, 0xCB, 0xDB, 0xEB, 0xFB,
 286    0x0C, 0x1C, 0x2C, 0x3C, 0x4C, 0x5C, 0x6C, 0x7C,
 287    0x8C, 0x9C, 0xAC, 0xBC, 0xCC, 0xDC, 0xEC, 0xFC,
 288    0x0D, 0x1D, 0x2D, 0x3D, 0x4D, 0x5D, 0x6D, 0x7D,
 289    0x8D, 0x9D, 0xAD, 0xBD, 0xCD, 0xDD, 0xED, 0xFD,
 290    0x0E, 0x1E, 0x2E, 0x3E, 0x4E, 0x5E, 0x6E, 0x7E,
 291    0x8E, 0x9E, 0xAE, 0xBE, 0xCE, 0xDE, 0xEE, 0xFE,
 292    0x0F, 0x1F, 0x2F, 0x3F, 0x4F, 0x5F, 0x6F, 0x7F,
 293    0x8F, 0x9F, 0xAF, 0xBF, 0xCF, 0xDF, 0xEF, 0xFF
 294 };
 295
 296 /* swaps pixel packing order within bytes */
 297 void
 298 png_do_packswap(png_row_infop row_info, png_bytep row)
 299 {
 300    png_debug(1, "in png_do_packswap\n");
 301    if (
 302 #if defined(PNG_USELESS_TESTS_SUPPORTED)
 303        row != NULL && row_info != NULL &&
 304 #endif
 305        row_info->bit_depth < 8)
 306    {
 307       png_bytep rp, end, table;
 308
 309       end = row + row_info->rowbytes;
 310
 311       if (row_info->bit_depth == 1)
 312          table = onebppswaptable;
 313       else if (row_info->bit_depth == 2)
 314          table = twobppswaptable;
 315       else if (row_info->bit_depth == 4)
 316          table = fourbppswaptable;
 317       else
 318          return;
 319
 320       for (rp = row; rp < end; rp++)
 321          *rp = table[*rp];
 322    }
 323 }
 324 #endif /* PNG_READ_PACKSWAP_SUPPORTED or PNG_WRITE_PACKSWAP_SUPPORTED */
 325
 326 #if defined(PNG_WRITE_FILLER_SUPPORTED) || \
 327     defined(PNG_READ_STRIP_ALPHA_SUPPORTED)
 328 /* remove filler or alpha byte(s) */
 329 void
 330 png_do_strip_filler(png_row_infop row_info, png_bytep row, png_uint_32 flags)
 331 {
 332    png_debug(1, "in png_do_strip_filler\n");
 333 #if defined(PNG_USELESS_TESTS_SUPPORTED)
 334    if (row != NULL && row_info != NULL)
 335 #endif
 336    {
 337 /*
 338       if (row_info->color_type == PNG_COLOR_TYPE_RGB ||
 339           row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
 340 */
 341       if (row_info->channels == 4)
 342       {
 343          if (row_info->bit_depth == 8)
 344          {
 345             /* This converts from RGBX or RGBA to RGB */
 346             if (flags & PNG_FLAG_FILLER_AFTER)
 347             {
 348                png_bytep sp, dp;
 349                png_uint_32 i;
 350
 351                for (i = 1, sp = row + 4, dp = row + 3; i < row_info->width; i++)
 352                {
 353                   *dp++ = *sp++;
 354                   *dp++ = *sp++;
 355                   *dp++ = *sp++;
 356                   sp++;
 357                }
 358             }
 359             /* This converts from XRGB or ARGB to RGB */
 360             else
 361             {
 362                png_bytep sp, dp;
 363                png_uint_32 i;
 364
 365                for (i = 0, sp = row, dp = row; i < row_info->width; i++)
 366                {
 367                   sp++;
 368                   *dp++ = *sp++;
 369                   *dp++ = *sp++;
 370                   *dp++ = *sp++;
 371                }
 372             }
 373             row_info->pixel_depth = 24;
 374             row_info->rowbytes = row_info->width * 3;
 375          }
 376          else /* if (row_info->bit_depth == 16) */
 377          {
 378             if (flags & PNG_FLAG_FILLER_AFTER)
 379             {
 380                png_bytep sp, dp;
 381                png_uint_32 i;
 382
 383                /* This converts from RRGGBBXX or RRGGBBAA to RRGGBB */
 384                for (i = 1, sp = row + 8, dp = row + 6; i < row_info->width; i++)
 385                {
 386                   /* This could be (although memcpy is probably slower):
 387                   png_memcpy(dp, sp, 6);
 388                   sp += 8;
 389                   dp += 6;
 390                   */
 391                   *dp++ = *sp++;
 392                   *dp++ = *sp++;
 393                   *dp++ = *sp++;
 394                   *dp++ = *sp++;
 395                   *dp++ = *sp++;
 396                   *dp++ = *sp++;
 397                   sp += 2;
 398                }
 399             }
 400             else
 401             {
 402                png_bytep sp, dp;
 403                png_uint_32 i;
 404
 405                /* This converts from XXRRGGBB or AARRGGBB to RRGGBB */
 406                for (i = 0, sp = row + 2, dp = row; i < row_info->width; i++)
 407                {
 408                   /* This could be (although memcpy is probably slower):
 409                   png_memcpy(dp, sp, 6);
 410                   sp += 8;
 411                   dp += 6;
 412                   */
 413                   *dp++ = *sp++;
 414                   *dp++ = *sp++;
 415                   *dp++ = *sp++;
 416                   *dp++ = *sp++;
 417                   *dp++ = *sp++;
 418                   *dp++ = *sp++;
 419                }
 420             }
 421             row_info->pixel_depth = 48;
 422             row_info->rowbytes = row_info->width * 6;
 423          }
 424          row_info->channels = 3;
 425       }
 426 /*
 427       else if (row_info->color_type == PNG_COLOR_TYPE_GRAY ||
 428                row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
 429 */
 430       else if (row_info->channels == 2)
 431       {
 432          if (row_info->bit_depth == 8)
 433          {
 434             /* This converts from GX or GA to G */
 435             if (flags & PNG_FLAG_FILLER_AFTER)
 436             {
 437                png_bytep sp, dp;
 438                png_uint_32 i;
 439
 440                for (i = 1, sp = row + 2, dp = row + 1; i < row_info->width; i++)
 441                {
 442                   *dp++ = *sp++;
 443                   sp++;
 444                }
 445             }
 446             /* This converts from XG or AG to G */
 447             else
 448             {
 449                png_bytep sp, dp;
 450                png_uint_32 i;
 451
 452                for (i = 0, sp = row, dp = row; i < row_info->width; i++)
 453                {
 454                   sp++;
 455                   *dp++ = *sp++;
 456                }
 457             }
 458             row_info->pixel_depth = 8;
 459             row_info->rowbytes = row_info->width;
 460          }
 461          else /* if (row_info->bit_depth == 16) */
 462          {
 463             if (flags & PNG_FLAG_FILLER_AFTER)
 464             {
 465                png_bytep sp, dp;
 466                png_uint_32 i;
 467
 468                /* This converts from GGXX or GGAA to GG */
 469                for (i = 1, sp = row + 4, dp = row + 2; i < row_info->width; i++)
 470                {
 471                   *dp++ = *sp++;
 472                   *dp++ = *sp++;
 473                   sp += 2;
 474                }
 475             }
 476             else
 477             {
 478                png_bytep sp, dp;
 479                png_uint_32 i;
 480
 481                /* This converts from XXGG or AAGG to GG */
 482                for (i = 0, sp = row, dp = row; i < row_info->width; i++)
 483                {
 484                   sp += 2;
 485                   *dp++ = *sp++;
 486                   *dp++ = *sp++;
 487                }
 488             }
 489             row_info->pixel_depth = 16;
 490             row_info->rowbytes = row_info->width * 2;
 491          }
 492          row_info->channels = 1;
 493       }
 494    }
 495 }
 496 #endif
 497
 498 #if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED)
 499 /* swaps red and blue bytes within a pixel */
 500 void
 501 png_do_bgr(png_row_infop row_info, png_bytep row)
 502 {
 503    png_debug(1, "in png_do_bgr\n");
 504    if (
 505 #if defined(PNG_USELESS_TESTS_SUPPORTED)
 506        row != NULL && row_info != NULL &&
 507 #endif
 508        (row_info->color_type & PNG_COLOR_MASK_COLOR))
 509    {
 510       if (row_info->bit_depth == 8)
 511       {
 512          if (row_info->color_type == PNG_COLOR_TYPE_RGB)
 513          {
 514             png_bytep rp;
 515             png_byte save;
 516             png_uint_32 i;
 517
 518             for (i = 0, rp = row; i < row_info->width; i++, rp += 3)
 519             {
 520                save = *rp;
 521                *rp = *(rp + 2);
 522                *(rp + 2) = save;
 523             }
 524          }
 525          else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
 526          {
 527             png_bytep rp;
 528             png_byte save;
 529             png_uint_32 i;
 530
 531             for (i = 0, rp = row; i < row_info->width; i++, rp += 4)
 532             {
 533                save = *rp;
 534                *rp = *(rp + 2);
 535                *(rp + 2) = save;
 536             }
 537          }
 538       }
 539       else if (row_info->bit_depth == 16)
 540       {
 541          if (row_info->color_type == PNG_COLOR_TYPE_RGB)
 542          {
 543             png_bytep rp;
 544             png_byte save[2];
 545             png_uint_32 i;
 546
 547             for (i = 0, rp = row; i < row_info->width; i++, rp += 6)
 548             {
 549                save[0] = *rp;
 550                save[1] = *(rp + 1);
 551                *rp = *(rp + 4);
 552                *(rp + 1) = *(rp + 5);
 553                *(rp + 4) = save[0];
 554                *(rp + 5) = save[1];
 555             }
 556          }
 557          else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
 558          {
 559             png_bytep rp;
 560             png_byte save[2];
 561             png_uint_32 i;
 562
 563             for (i = 0, rp = row; i < row_info->width; i++, rp += 8)
 564             {
 565                save[0] = *rp;
 566                save[1] = *(rp + 1);
 567                *rp = *(rp + 4);
 568                *(rp + 1) = *(rp + 5);
 569                *(rp + 4) = save[0];
 570                *(rp + 5) = save[1];
 571             }
 572          }
 573       }
 574    }
 575 }
 576 #endif /* PNG_READ_BGR_SUPPORTED or PNG_WRITE_BGR_SUPPORTED */
 577