src/png/pngtrans.c

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