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