1.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     1.2 +++ b/libs/libpng/pngtrans.c	Thu Sep 08 06:28:38 2011 +0300
     1.3 @@ -0,0 +1,662 @@
     1.4 +
     1.5 +/* pngtrans.c - transforms the data in a row (used by both readers and writers)
     1.6 + *
     1.7 + * Last changed in libpng 1.2.30 [August 15, 2008]
     1.8 + * For conditions of distribution and use, see copyright notice in png.h
     1.9 + * Copyright (c) 1998-2008 Glenn Randers-Pehrson
    1.10 + * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
    1.11 + * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
    1.12 + */
    1.13 +
    1.14 +#define PNG_INTERNAL
    1.15 +#include "png.h"
    1.16 +#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
    1.17 +
    1.18 +#if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED)
    1.19 +/* turn on BGR-to-RGB mapping */
    1.20 +void PNGAPI
    1.21 +png_set_bgr(png_structp png_ptr)
    1.22 +{
    1.23 +   png_debug(1, "in png_set_bgr\n");
    1.24 +   if (png_ptr == NULL) return;
    1.25 +   png_ptr->transformations |= PNG_BGR;
    1.26 +}
    1.27 +#endif
    1.28 +
    1.29 +#if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED)
    1.30 +/* turn on 16 bit byte swapping */
    1.31 +void PNGAPI
    1.32 +png_set_swap(png_structp png_ptr)
    1.33 +{
    1.34 +   png_debug(1, "in png_set_swap\n");
    1.35 +   if (png_ptr == NULL) return;
    1.36 +   if (png_ptr->bit_depth == 16)
    1.37 +      png_ptr->transformations |= PNG_SWAP_BYTES;
    1.38 +}
    1.39 +#endif
    1.40 +
    1.41 +#if defined(PNG_READ_PACK_SUPPORTED) || defined(PNG_WRITE_PACK_SUPPORTED)
    1.42 +/* turn on pixel packing */
    1.43 +void PNGAPI
    1.44 +png_set_packing(png_structp png_ptr)
    1.45 +{
    1.46 +   png_debug(1, "in png_set_packing\n");
    1.47 +   if (png_ptr == NULL) return;
    1.48 +   if (png_ptr->bit_depth < 8)
    1.49 +   {
    1.50 +      png_ptr->transformations |= PNG_PACK;
    1.51 +      png_ptr->usr_bit_depth = 8;
    1.52 +   }
    1.53 +}
    1.54 +#endif
    1.55 +
    1.56 +#if defined(PNG_READ_PACKSWAP_SUPPORTED)||defined(PNG_WRITE_PACKSWAP_SUPPORTED)
    1.57 +/* turn on packed pixel swapping */
    1.58 +void PNGAPI
    1.59 +png_set_packswap(png_structp png_ptr)
    1.60 +{
    1.61 +   png_debug(1, "in png_set_packswap\n");
    1.62 +   if (png_ptr == NULL) return;
    1.63 +   if (png_ptr->bit_depth < 8)
    1.64 +      png_ptr->transformations |= PNG_PACKSWAP;
    1.65 +}
    1.66 +#endif
    1.67 +
    1.68 +#if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED)
    1.69 +void PNGAPI
    1.70 +png_set_shift(png_structp png_ptr, png_color_8p true_bits)
    1.71 +{
    1.72 +   png_debug(1, "in png_set_shift\n");
    1.73 +   if (png_ptr == NULL) return;
    1.74 +   png_ptr->transformations |= PNG_SHIFT;
    1.75 +   png_ptr->shift = *true_bits;
    1.76 +}
    1.77 +#endif
    1.78 +
    1.79 +#if defined(PNG_READ_INTERLACING_SUPPORTED) || \
    1.80 +    defined(PNG_WRITE_INTERLACING_SUPPORTED)
    1.81 +int PNGAPI
    1.82 +png_set_interlace_handling(png_structp png_ptr)
    1.83 +{
    1.84 +   png_debug(1, "in png_set_interlace handling\n");
    1.85 +   if (png_ptr && png_ptr->interlaced)
    1.86 +   {
    1.87 +      png_ptr->transformations |= PNG_INTERLACE;
    1.88 +      return (7);
    1.89 +   }
    1.90 +
    1.91 +   return (1);
    1.92 +}
    1.93 +#endif
    1.94 +
    1.95 +#if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED)
    1.96 +/* Add a filler byte on read, or remove a filler or alpha byte on write.
    1.97 + * The filler type has changed in v0.95 to allow future 2-byte fillers
    1.98 + * for 48-bit input data, as well as to avoid problems with some compilers
    1.99 + * that don't like bytes as parameters.
   1.100 + */
   1.101 +void PNGAPI
   1.102 +png_set_filler(png_structp png_ptr, png_uint_32 filler, int filler_loc)
   1.103 +{
   1.104 +   png_debug(1, "in png_set_filler\n");
   1.105 +   if (png_ptr == NULL) return;
   1.106 +   png_ptr->transformations |= PNG_FILLER;
   1.107 +   png_ptr->filler = (png_byte)filler;
   1.108 +   if (filler_loc == PNG_FILLER_AFTER)
   1.109 +      png_ptr->flags |= PNG_FLAG_FILLER_AFTER;
   1.110 +   else
   1.111 +      png_ptr->flags &= ~PNG_FLAG_FILLER_AFTER;
   1.112 +
   1.113 +   /* This should probably go in the "do_read_filler" routine.
   1.114 +    * I attempted to do that in libpng-1.0.1a but that caused problems
   1.115 +    * so I restored it in libpng-1.0.2a
   1.116 +   */
   1.117 +
   1.118 +   if (png_ptr->color_type == PNG_COLOR_TYPE_RGB)
   1.119 +   {
   1.120 +      png_ptr->usr_channels = 4;
   1.121 +   }
   1.122 +
   1.123 +   /* Also I added this in libpng-1.0.2a (what happens when we expand
   1.124 +    * a less-than-8-bit grayscale to GA? */
   1.125 +
   1.126 +   if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY && png_ptr->bit_depth >= 8)
   1.127 +   {
   1.128 +      png_ptr->usr_channels = 2;
   1.129 +   }
   1.130 +}
   1.131 +
   1.132 +#if !defined(PNG_1_0_X)
   1.133 +/* Added to libpng-1.2.7 */
   1.134 +void PNGAPI
   1.135 +png_set_add_alpha(png_structp png_ptr, png_uint_32 filler, int filler_loc)
   1.136 +{
   1.137 +   png_debug(1, "in png_set_add_alpha\n");
   1.138 +   if (png_ptr == NULL) return;
   1.139 +   png_set_filler(png_ptr, filler, filler_loc);
   1.140 +   png_ptr->transformations |= PNG_ADD_ALPHA;
   1.141 +}
   1.142 +#endif
   1.143 +
   1.144 +#endif
   1.145 +
   1.146 +#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) || \
   1.147 +    defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED)
   1.148 +void PNGAPI
   1.149 +png_set_swap_alpha(png_structp png_ptr)
   1.150 +{
   1.151 +   png_debug(1, "in png_set_swap_alpha\n");
   1.152 +   if (png_ptr == NULL) return;
   1.153 +   png_ptr->transformations |= PNG_SWAP_ALPHA;
   1.154 +}
   1.155 +#endif
   1.156 +
   1.157 +#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) || \
   1.158 +    defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED)
   1.159 +void PNGAPI
   1.160 +png_set_invert_alpha(png_structp png_ptr)
   1.161 +{
   1.162 +   png_debug(1, "in png_set_invert_alpha\n");
   1.163 +   if (png_ptr == NULL) return;
   1.164 +   png_ptr->transformations |= PNG_INVERT_ALPHA;
   1.165 +}
   1.166 +#endif
   1.167 +
   1.168 +#if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED)
   1.169 +void PNGAPI
   1.170 +png_set_invert_mono(png_structp png_ptr)
   1.171 +{
   1.172 +   png_debug(1, "in png_set_invert_mono\n");
   1.173 +   if (png_ptr == NULL) return;
   1.174 +   png_ptr->transformations |= PNG_INVERT_MONO;
   1.175 +}
   1.176 +
   1.177 +/* invert monochrome grayscale data */
   1.178 +void /* PRIVATE */
   1.179 +png_do_invert(png_row_infop row_info, png_bytep row)
   1.180 +{
   1.181 +   png_debug(1, "in png_do_invert\n");
   1.182 +  /* This test removed from libpng version 1.0.13 and 1.2.0:
   1.183 +   *   if (row_info->bit_depth == 1 &&
   1.184 +   */
   1.185 +#if defined(PNG_USELESS_TESTS_SUPPORTED)
   1.186 +   if (row == NULL || row_info == NULL)
   1.187 +     return;
   1.188 +#endif
   1.189 +   if (row_info->color_type == PNG_COLOR_TYPE_GRAY)
   1.190 +   {
   1.191 +      png_bytep rp = row;
   1.192 +      png_uint_32 i;
   1.193 +      png_uint_32 istop = row_info->rowbytes;
   1.194 +
   1.195 +      for (i = 0; i < istop; i++)
   1.196 +      {
   1.197 +         *rp = (png_byte)(~(*rp));
   1.198 +         rp++;
   1.199 +      }
   1.200 +   }
   1.201 +   else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA &&
   1.202 +      row_info->bit_depth == 8)
   1.203 +   {
   1.204 +      png_bytep rp = row;
   1.205 +      png_uint_32 i;
   1.206 +      png_uint_32 istop = row_info->rowbytes;
   1.207 +
   1.208 +      for (i = 0; i < istop; i+=2)
   1.209 +      {
   1.210 +         *rp = (png_byte)(~(*rp));
   1.211 +         rp+=2;
   1.212 +      }
   1.213 +   }
   1.214 +   else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA &&
   1.215 +      row_info->bit_depth == 16)
   1.216 +   {
   1.217 +      png_bytep rp = row;
   1.218 +      png_uint_32 i;
   1.219 +      png_uint_32 istop = row_info->rowbytes;
   1.220 +
   1.221 +      for (i = 0; i < istop; i+=4)
   1.222 +      {
   1.223 +         *rp = (png_byte)(~(*rp));
   1.224 +         *(rp+1) = (png_byte)(~(*(rp+1)));
   1.225 +         rp+=4;
   1.226 +      }
   1.227 +   }
   1.228 +}
   1.229 +#endif
   1.230 +
   1.231 +#if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED)
   1.232 +/* swaps byte order on 16 bit depth images */
   1.233 +void /* PRIVATE */
   1.234 +png_do_swap(png_row_infop row_info, png_bytep row)
   1.235 +{
   1.236 +   png_debug(1, "in png_do_swap\n");
   1.237 +   if (
   1.238 +#if defined(PNG_USELESS_TESTS_SUPPORTED)
   1.239 +       row != NULL && row_info != NULL &&
   1.240 +#endif
   1.241 +       row_info->bit_depth == 16)
   1.242 +   {
   1.243 +      png_bytep rp = row;
   1.244 +      png_uint_32 i;
   1.245 +      png_uint_32 istop= row_info->width * row_info->channels;
   1.246 +
   1.247 +      for (i = 0; i < istop; i++, rp += 2)
   1.248 +      {
   1.249 +         png_byte t = *rp;
   1.250 +         *rp = *(rp + 1);
   1.251 +         *(rp + 1) = t;
   1.252 +      }
   1.253 +   }
   1.254 +}
   1.255 +#endif
   1.256 +
   1.257 +#if defined(PNG_READ_PACKSWAP_SUPPORTED)||defined(PNG_WRITE_PACKSWAP_SUPPORTED)
   1.258 +static PNG_CONST png_byte onebppswaptable[256] = {
   1.259 +   0x00, 0x80, 0x40, 0xC0, 0x20, 0xA0, 0x60, 0xE0,
   1.260 +   0x10, 0x90, 0x50, 0xD0, 0x30, 0xB0, 0x70, 0xF0,
   1.261 +   0x08, 0x88, 0x48, 0xC8, 0x28, 0xA8, 0x68, 0xE8,
   1.262 +   0x18, 0x98, 0x58, 0xD8, 0x38, 0xB8, 0x78, 0xF8,
   1.263 +   0x04, 0x84, 0x44, 0xC4, 0x24, 0xA4, 0x64, 0xE4,
   1.264 +   0x14, 0x94, 0x54, 0xD4, 0x34, 0xB4, 0x74, 0xF4,
   1.265 +   0x0C, 0x8C, 0x4C, 0xCC, 0x2C, 0xAC, 0x6C, 0xEC,
   1.266 +   0x1C, 0x9C, 0x5C, 0xDC, 0x3C, 0xBC, 0x7C, 0xFC,
   1.267 +   0x02, 0x82, 0x42, 0xC2, 0x22, 0xA2, 0x62, 0xE2,
   1.268 +   0x12, 0x92, 0x52, 0xD2, 0x32, 0xB2, 0x72, 0xF2,
   1.269 +   0x0A, 0x8A, 0x4A, 0xCA, 0x2A, 0xAA, 0x6A, 0xEA,
   1.270 +   0x1A, 0x9A, 0x5A, 0xDA, 0x3A, 0xBA, 0x7A, 0xFA,
   1.271 +   0x06, 0x86, 0x46, 0xC6, 0x26, 0xA6, 0x66, 0xE6,
   1.272 +   0x16, 0x96, 0x56, 0xD6, 0x36, 0xB6, 0x76, 0xF6,
   1.273 +   0x0E, 0x8E, 0x4E, 0xCE, 0x2E, 0xAE, 0x6E, 0xEE,
   1.274 +   0x1E, 0x9E, 0x5E, 0xDE, 0x3E, 0xBE, 0x7E, 0xFE,
   1.275 +   0x01, 0x81, 0x41, 0xC1, 0x21, 0xA1, 0x61, 0xE1,
   1.276 +   0x11, 0x91, 0x51, 0xD1, 0x31, 0xB1, 0x71, 0xF1,
   1.277 +   0x09, 0x89, 0x49, 0xC9, 0x29, 0xA9, 0x69, 0xE9,
   1.278 +   0x19, 0x99, 0x59, 0xD9, 0x39, 0xB9, 0x79, 0xF9,
   1.279 +   0x05, 0x85, 0x45, 0xC5, 0x25, 0xA5, 0x65, 0xE5,
   1.280 +   0x15, 0x95, 0x55, 0xD5, 0x35, 0xB5, 0x75, 0xF5,
   1.281 +   0x0D, 0x8D, 0x4D, 0xCD, 0x2D, 0xAD, 0x6D, 0xED,
   1.282 +   0x1D, 0x9D, 0x5D, 0xDD, 0x3D, 0xBD, 0x7D, 0xFD,
   1.283 +   0x03, 0x83, 0x43, 0xC3, 0x23, 0xA3, 0x63, 0xE3,
   1.284 +   0x13, 0x93, 0x53, 0xD3, 0x33, 0xB3, 0x73, 0xF3,
   1.285 +   0x0B, 0x8B, 0x4B, 0xCB, 0x2B, 0xAB, 0x6B, 0xEB,
   1.286 +   0x1B, 0x9B, 0x5B, 0xDB, 0x3B, 0xBB, 0x7B, 0xFB,
   1.287 +   0x07, 0x87, 0x47, 0xC7, 0x27, 0xA7, 0x67, 0xE7,
   1.288 +   0x17, 0x97, 0x57, 0xD7, 0x37, 0xB7, 0x77, 0xF7,
   1.289 +   0x0F, 0x8F, 0x4F, 0xCF, 0x2F, 0xAF, 0x6F, 0xEF,
   1.290 +   0x1F, 0x9F, 0x5F, 0xDF, 0x3F, 0xBF, 0x7F, 0xFF
   1.291 +};
   1.292 +
   1.293 +static PNG_CONST png_byte twobppswaptable[256] = {
   1.294 +   0x00, 0x40, 0x80, 0xC0, 0x10, 0x50, 0x90, 0xD0,
   1.295 +   0x20, 0x60, 0xA0, 0xE0, 0x30, 0x70, 0xB0, 0xF0,
   1.296 +   0x04, 0x44, 0x84, 0xC4, 0x14, 0x54, 0x94, 0xD4,
   1.297 +   0x24, 0x64, 0xA4, 0xE4, 0x34, 0x74, 0xB4, 0xF4,
   1.298 +   0x08, 0x48, 0x88, 0xC8, 0x18, 0x58, 0x98, 0xD8,
   1.299 +   0x28, 0x68, 0xA8, 0xE8, 0x38, 0x78, 0xB8, 0xF8,
   1.300 +   0x0C, 0x4C, 0x8C, 0xCC, 0x1C, 0x5C, 0x9C, 0xDC,
   1.301 +   0x2C, 0x6C, 0xAC, 0xEC, 0x3C, 0x7C, 0xBC, 0xFC,
   1.302 +   0x01, 0x41, 0x81, 0xC1, 0x11, 0x51, 0x91, 0xD1,
   1.303 +   0x21, 0x61, 0xA1, 0xE1, 0x31, 0x71, 0xB1, 0xF1,
   1.304 +   0x05, 0x45, 0x85, 0xC5, 0x15, 0x55, 0x95, 0xD5,
   1.305 +   0x25, 0x65, 0xA5, 0xE5, 0x35, 0x75, 0xB5, 0xF5,
   1.306 +   0x09, 0x49, 0x89, 0xC9, 0x19, 0x59, 0x99, 0xD9,
   1.307 +   0x29, 0x69, 0xA9, 0xE9, 0x39, 0x79, 0xB9, 0xF9,
   1.308 +   0x0D, 0x4D, 0x8D, 0xCD, 0x1D, 0x5D, 0x9D, 0xDD,
   1.309 +   0x2D, 0x6D, 0xAD, 0xED, 0x3D, 0x7D, 0xBD, 0xFD,
   1.310 +   0x02, 0x42, 0x82, 0xC2, 0x12, 0x52, 0x92, 0xD2,
   1.311 +   0x22, 0x62, 0xA2, 0xE2, 0x32, 0x72, 0xB2, 0xF2,
   1.312 +   0x06, 0x46, 0x86, 0xC6, 0x16, 0x56, 0x96, 0xD6,
   1.313 +   0x26, 0x66, 0xA6, 0xE6, 0x36, 0x76, 0xB6, 0xF6,
   1.314 +   0x0A, 0x4A, 0x8A, 0xCA, 0x1A, 0x5A, 0x9A, 0xDA,
   1.315 +   0x2A, 0x6A, 0xAA, 0xEA, 0x3A, 0x7A, 0xBA, 0xFA,
   1.316 +   0x0E, 0x4E, 0x8E, 0xCE, 0x1E, 0x5E, 0x9E, 0xDE,
   1.317 +   0x2E, 0x6E, 0xAE, 0xEE, 0x3E, 0x7E, 0xBE, 0xFE,
   1.318 +   0x03, 0x43, 0x83, 0xC3, 0x13, 0x53, 0x93, 0xD3,
   1.319 +   0x23, 0x63, 0xA3, 0xE3, 0x33, 0x73, 0xB3, 0xF3,
   1.320 +   0x07, 0x47, 0x87, 0xC7, 0x17, 0x57, 0x97, 0xD7,
   1.321 +   0x27, 0x67, 0xA7, 0xE7, 0x37, 0x77, 0xB7, 0xF7,
   1.322 +   0x0B, 0x4B, 0x8B, 0xCB, 0x1B, 0x5B, 0x9B, 0xDB,
   1.323 +   0x2B, 0x6B, 0xAB, 0xEB, 0x3B, 0x7B, 0xBB, 0xFB,
   1.324 +   0x0F, 0x4F, 0x8F, 0xCF, 0x1F, 0x5F, 0x9F, 0xDF,
   1.325 +   0x2F, 0x6F, 0xAF, 0xEF, 0x3F, 0x7F, 0xBF, 0xFF
   1.326 +};
   1.327 +
   1.328 +static PNG_CONST png_byte fourbppswaptable[256] = {
   1.329 +   0x00, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70,
   1.330 +   0x80, 0x90, 0xA0, 0xB0, 0xC0, 0xD0, 0xE0, 0xF0,
   1.331 +   0x01, 0x11, 0x21, 0x31, 0x41, 0x51, 0x61, 0x71,
   1.332 +   0x81, 0x91, 0xA1, 0xB1, 0xC1, 0xD1, 0xE1, 0xF1,
   1.333 +   0x02, 0x12, 0x22, 0x32, 0x42, 0x52, 0x62, 0x72,
   1.334 +   0x82, 0x92, 0xA2, 0xB2, 0xC2, 0xD2, 0xE2, 0xF2,
   1.335 +   0x03, 0x13, 0x23, 0x33, 0x43, 0x53, 0x63, 0x73,
   1.336 +   0x83, 0x93, 0xA3, 0xB3, 0xC3, 0xD3, 0xE3, 0xF3,
   1.337 +   0x04, 0x14, 0x24, 0x34, 0x44, 0x54, 0x64, 0x74,
   1.338 +   0x84, 0x94, 0xA4, 0xB4, 0xC4, 0xD4, 0xE4, 0xF4,
   1.339 +   0x05, 0x15, 0x25, 0x35, 0x45, 0x55, 0x65, 0x75,
   1.340 +   0x85, 0x95, 0xA5, 0xB5, 0xC5, 0xD5, 0xE5, 0xF5,
   1.341 +   0x06, 0x16, 0x26, 0x36, 0x46, 0x56, 0x66, 0x76,
   1.342 +   0x86, 0x96, 0xA6, 0xB6, 0xC6, 0xD6, 0xE6, 0xF6,
   1.343 +   0x07, 0x17, 0x27, 0x37, 0x47, 0x57, 0x67, 0x77,
   1.344 +   0x87, 0x97, 0xA7, 0xB7, 0xC7, 0xD7, 0xE7, 0xF7,
   1.345 +   0x08, 0x18, 0x28, 0x38, 0x48, 0x58, 0x68, 0x78,
   1.346 +   0x88, 0x98, 0xA8, 0xB8, 0xC8, 0xD8, 0xE8, 0xF8,
   1.347 +   0x09, 0x19, 0x29, 0x39, 0x49, 0x59, 0x69, 0x79,
   1.348 +   0x89, 0x99, 0xA9, 0xB9, 0xC9, 0xD9, 0xE9, 0xF9,
   1.349 +   0x0A, 0x1A, 0x2A, 0x3A, 0x4A, 0x5A, 0x6A, 0x7A,
   1.350 +   0x8A, 0x9A, 0xAA, 0xBA, 0xCA, 0xDA, 0xEA, 0xFA,
   1.351 +   0x0B, 0x1B, 0x2B, 0x3B, 0x4B, 0x5B, 0x6B, 0x7B,
   1.352 +   0x8B, 0x9B, 0xAB, 0xBB, 0xCB, 0xDB, 0xEB, 0xFB,
   1.353 +   0x0C, 0x1C, 0x2C, 0x3C, 0x4C, 0x5C, 0x6C, 0x7C,
   1.354 +   0x8C, 0x9C, 0xAC, 0xBC, 0xCC, 0xDC, 0xEC, 0xFC,
   1.355 +   0x0D, 0x1D, 0x2D, 0x3D, 0x4D, 0x5D, 0x6D, 0x7D,
   1.356 +   0x8D, 0x9D, 0xAD, 0xBD, 0xCD, 0xDD, 0xED, 0xFD,
   1.357 +   0x0E, 0x1E, 0x2E, 0x3E, 0x4E, 0x5E, 0x6E, 0x7E,
   1.358 +   0x8E, 0x9E, 0xAE, 0xBE, 0xCE, 0xDE, 0xEE, 0xFE,
   1.359 +   0x0F, 0x1F, 0x2F, 0x3F, 0x4F, 0x5F, 0x6F, 0x7F,
   1.360 +   0x8F, 0x9F, 0xAF, 0xBF, 0xCF, 0xDF, 0xEF, 0xFF
   1.361 +};
   1.362 +
   1.363 +/* swaps pixel packing order within bytes */
   1.364 +void /* PRIVATE */
   1.365 +png_do_packswap(png_row_infop row_info, png_bytep row)
   1.366 +{
   1.367 +   png_debug(1, "in png_do_packswap\n");
   1.368 +   if (
   1.369 +#if defined(PNG_USELESS_TESTS_SUPPORTED)
   1.370 +       row != NULL && row_info != NULL &&
   1.371 +#endif
   1.372 +       row_info->bit_depth < 8)
   1.373 +   {
   1.374 +      png_bytep rp, end, table;
   1.375 +
   1.376 +      end = row + row_info->rowbytes;
   1.377 +
   1.378 +      if (row_info->bit_depth == 1)
   1.379 +         table = (png_bytep)onebppswaptable;
   1.380 +      else if (row_info->bit_depth == 2)
   1.381 +         table = (png_bytep)twobppswaptable;
   1.382 +      else if (row_info->bit_depth == 4)
   1.383 +         table = (png_bytep)fourbppswaptable;
   1.384 +      else
   1.385 +         return;
   1.386 +
   1.387 +      for (rp = row; rp < end; rp++)
   1.388 +         *rp = table[*rp];
   1.389 +   }
   1.390 +}
   1.391 +#endif /* PNG_READ_PACKSWAP_SUPPORTED or PNG_WRITE_PACKSWAP_SUPPORTED */
   1.392 +
   1.393 +#if defined(PNG_WRITE_FILLER_SUPPORTED) || \
   1.394 +    defined(PNG_READ_STRIP_ALPHA_SUPPORTED)
   1.395 +/* remove filler or alpha byte(s) */
   1.396 +void /* PRIVATE */
   1.397 +png_do_strip_filler(png_row_infop row_info, png_bytep row, png_uint_32 flags)
   1.398 +{
   1.399 +   png_debug(1, "in png_do_strip_filler\n");
   1.400 +#if defined(PNG_USELESS_TESTS_SUPPORTED)
   1.401 +   if (row != NULL && row_info != NULL)
   1.402 +#endif
   1.403 +   {
   1.404 +      png_bytep sp=row;
   1.405 +      png_bytep dp=row;
   1.406 +      png_uint_32 row_width=row_info->width;
   1.407 +      png_uint_32 i;
   1.408 +
   1.409 +      if ((row_info->color_type == PNG_COLOR_TYPE_RGB ||
   1.410 +         (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA &&
   1.411 +         (flags & PNG_FLAG_STRIP_ALPHA))) &&
   1.412 +         row_info->channels == 4)
   1.413 +      {
   1.414 +         if (row_info->bit_depth == 8)
   1.415 +         {
   1.416 +            /* This converts from RGBX or RGBA to RGB */
   1.417 +            if (flags & PNG_FLAG_FILLER_AFTER)
   1.418 +            {
   1.419 +               dp+=3; sp+=4;
   1.420 +               for (i = 1; i < row_width; i++)
   1.421 +               {
   1.422 +                  *dp++ = *sp++;
   1.423 +                  *dp++ = *sp++;
   1.424 +                  *dp++ = *sp++;
   1.425 +                  sp++;
   1.426 +               }
   1.427 +            }
   1.428 +            /* This converts from XRGB or ARGB to RGB */
   1.429 +            else
   1.430 +            {
   1.431 +               for (i = 0; i < row_width; i++)
   1.432 +               {
   1.433 +                  sp++;
   1.434 +                  *dp++ = *sp++;
   1.435 +                  *dp++ = *sp++;
   1.436 +                  *dp++ = *sp++;
   1.437 +               }
   1.438 +            }
   1.439 +            row_info->pixel_depth = 24;
   1.440 +            row_info->rowbytes = row_width * 3;
   1.441 +         }
   1.442 +         else /* if (row_info->bit_depth == 16) */
   1.443 +         {
   1.444 +            if (flags & PNG_FLAG_FILLER_AFTER)
   1.445 +            {
   1.446 +               /* This converts from RRGGBBXX or RRGGBBAA to RRGGBB */
   1.447 +               sp += 8; dp += 6;
   1.448 +               for (i = 1; i < row_width; i++)
   1.449 +               {
   1.450 +                  /* This could be (although png_memcpy is probably slower):
   1.451 +                  png_memcpy(dp, sp, 6);
   1.452 +                  sp += 8;
   1.453 +                  dp += 6;
   1.454 +                  */
   1.455 +
   1.456 +                  *dp++ = *sp++;
   1.457 +                  *dp++ = *sp++;
   1.458 +                  *dp++ = *sp++;
   1.459 +                  *dp++ = *sp++;
   1.460 +                  *dp++ = *sp++;
   1.461 +                  *dp++ = *sp++;
   1.462 +                  sp += 2;
   1.463 +               }
   1.464 +            }
   1.465 +            else
   1.466 +            {
   1.467 +               /* This converts from XXRRGGBB or AARRGGBB to RRGGBB */
   1.468 +               for (i = 0; i < row_width; i++)
   1.469 +               {
   1.470 +                  /* This could be (although png_memcpy is probably slower):
   1.471 +                  png_memcpy(dp, sp, 6);
   1.472 +                  sp += 8;
   1.473 +                  dp += 6;
   1.474 +                  */
   1.475 +
   1.476 +                  sp+=2;
   1.477 +                  *dp++ = *sp++;
   1.478 +                  *dp++ = *sp++;
   1.479 +                  *dp++ = *sp++;
   1.480 +                  *dp++ = *sp++;
   1.481 +                  *dp++ = *sp++;
   1.482 +                  *dp++ = *sp++;
   1.483 +               }
   1.484 +            }
   1.485 +            row_info->pixel_depth = 48;
   1.486 +            row_info->rowbytes = row_width * 6;
   1.487 +         }
   1.488 +         row_info->channels = 3;
   1.489 +      }
   1.490 +      else if ((row_info->color_type == PNG_COLOR_TYPE_GRAY ||
   1.491 +         (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA &&
   1.492 +         (flags & PNG_FLAG_STRIP_ALPHA))) &&
   1.493 +          row_info->channels == 2)
   1.494 +      {
   1.495 +         if (row_info->bit_depth == 8)
   1.496 +         {
   1.497 +            /* This converts from GX or GA to G */
   1.498 +            if (flags & PNG_FLAG_FILLER_AFTER)
   1.499 +            {
   1.500 +               for (i = 0; i < row_width; i++)
   1.501 +               {
   1.502 +                  *dp++ = *sp++;
   1.503 +                  sp++;
   1.504 +               }
   1.505 +            }
   1.506 +            /* This converts from XG or AG to G */
   1.507 +            else
   1.508 +            {
   1.509 +               for (i = 0; i < row_width; i++)
   1.510 +               {
   1.511 +                  sp++;
   1.512 +                  *dp++ = *sp++;
   1.513 +               }
   1.514 +            }
   1.515 +            row_info->pixel_depth = 8;
   1.516 +            row_info->rowbytes = row_width;
   1.517 +         }
   1.518 +         else /* if (row_info->bit_depth == 16) */
   1.519 +         {
   1.520 +            if (flags & PNG_FLAG_FILLER_AFTER)
   1.521 +            {
   1.522 +               /* This converts from GGXX or GGAA to GG */
   1.523 +               sp += 4; dp += 2;
   1.524 +               for (i = 1; i < row_width; i++)
   1.525 +               {
   1.526 +                  *dp++ = *sp++;
   1.527 +                  *dp++ = *sp++;
   1.528 +                  sp += 2;
   1.529 +               }
   1.530 +            }
   1.531 +            else
   1.532 +            {
   1.533 +               /* This converts from XXGG or AAGG to GG */
   1.534 +               for (i = 0; i < row_width; i++)
   1.535 +               {
   1.536 +                  sp += 2;
   1.537 +                  *dp++ = *sp++;
   1.538 +                  *dp++ = *sp++;
   1.539 +               }
   1.540 +            }
   1.541 +            row_info->pixel_depth = 16;
   1.542 +            row_info->rowbytes = row_width * 2;
   1.543 +         }
   1.544 +         row_info->channels = 1;
   1.545 +      }
   1.546 +      if (flags & PNG_FLAG_STRIP_ALPHA)
   1.547 +        row_info->color_type &= ~PNG_COLOR_MASK_ALPHA;
   1.548 +   }
   1.549 +}
   1.550 +#endif
   1.551 +
   1.552 +#if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED)
   1.553 +/* swaps red and blue bytes within a pixel */
   1.554 +void /* PRIVATE */
   1.555 +png_do_bgr(png_row_infop row_info, png_bytep row)
   1.556 +{
   1.557 +   png_debug(1, "in png_do_bgr\n");
   1.558 +   if (
   1.559 +#if defined(PNG_USELESS_TESTS_SUPPORTED)
   1.560 +       row != NULL && row_info != NULL &&
   1.561 +#endif
   1.562 +       (row_info->color_type & PNG_COLOR_MASK_COLOR))
   1.563 +   {
   1.564 +      png_uint_32 row_width = row_info->width;
   1.565 +      if (row_info->bit_depth == 8)
   1.566 +      {
   1.567 +         if (row_info->color_type == PNG_COLOR_TYPE_RGB)
   1.568 +         {
   1.569 +            png_bytep rp;
   1.570 +            png_uint_32 i;
   1.571 +
   1.572 +            for (i = 0, rp = row; i < row_width; i++, rp += 3)
   1.573 +            {
   1.574 +               png_byte save = *rp;
   1.575 +               *rp = *(rp + 2);
   1.576 +               *(rp + 2) = save;
   1.577 +            }
   1.578 +         }
   1.579 +         else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
   1.580 +         {
   1.581 +            png_bytep rp;
   1.582 +            png_uint_32 i;
   1.583 +
   1.584 +            for (i = 0, rp = row; i < row_width; i++, rp += 4)
   1.585 +            {
   1.586 +               png_byte save = *rp;
   1.587 +               *rp = *(rp + 2);
   1.588 +               *(rp + 2) = save;
   1.589 +            }
   1.590 +         }
   1.591 +      }
   1.592 +      else if (row_info->bit_depth == 16)
   1.593 +      {
   1.594 +         if (row_info->color_type == PNG_COLOR_TYPE_RGB)
   1.595 +         {
   1.596 +            png_bytep rp;
   1.597 +            png_uint_32 i;
   1.598 +
   1.599 +            for (i = 0, rp = row; i < row_width; i++, rp += 6)
   1.600 +            {
   1.601 +               png_byte save = *rp;
   1.602 +               *rp = *(rp + 4);
   1.603 +               *(rp + 4) = save;
   1.604 +               save = *(rp + 1);
   1.605 +               *(rp + 1) = *(rp + 5);
   1.606 +               *(rp + 5) = save;
   1.607 +            }
   1.608 +         }
   1.609 +         else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
   1.610 +         {
   1.611 +            png_bytep rp;
   1.612 +            png_uint_32 i;
   1.613 +
   1.614 +            for (i = 0, rp = row; i < row_width; i++, rp += 8)
   1.615 +            {
   1.616 +               png_byte save = *rp;
   1.617 +               *rp = *(rp + 4);
   1.618 +               *(rp + 4) = save;
   1.619 +               save = *(rp + 1);
   1.620 +               *(rp + 1) = *(rp + 5);
   1.621 +               *(rp + 5) = save;
   1.622 +            }
   1.623 +         }
   1.624 +      }
   1.625 +   }
   1.626 +}
   1.627 +#endif /* PNG_READ_BGR_SUPPORTED or PNG_WRITE_BGR_SUPPORTED */
   1.628 +
   1.629 +#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \
   1.630 +    defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) || \
   1.631 +    defined(PNG_LEGACY_SUPPORTED)
   1.632 +void PNGAPI
   1.633 +png_set_user_transform_info(png_structp png_ptr, png_voidp
   1.634 +   user_transform_ptr, int user_transform_depth, int user_transform_channels)
   1.635 +{
   1.636 +   png_debug(1, "in png_set_user_transform_info\n");
   1.637 +   if (png_ptr == NULL) return;
   1.638 +#if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED)
   1.639 +   png_ptr->user_transform_ptr = user_transform_ptr;
   1.640 +   png_ptr->user_transform_depth = (png_byte)user_transform_depth;
   1.641 +   png_ptr->user_transform_channels = (png_byte)user_transform_channels;
   1.642 +#else
   1.643 +   if (user_transform_ptr || user_transform_depth || user_transform_channels)
   1.644 +      png_warning(png_ptr,
   1.645 +        "This version of libpng does not support user transform info");
   1.646 +#endif
   1.647 +}
   1.648 +#endif
   1.649 +
   1.650 +/* This function returns a pointer to the user_transform_ptr associated with
   1.651 + * the user transform functions.  The application should free any memory
   1.652 + * associated with this pointer before png_write_destroy and png_read_destroy
   1.653 + * are called.
   1.654 + */
   1.655 +png_voidp PNGAPI
   1.656 +png_get_user_transform_ptr(png_structp png_ptr)
   1.657 +{
   1.658 +   if (png_ptr == NULL) return (NULL);
   1.659 +#if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED)
   1.660 +   return ((png_voidp)png_ptr->user_transform_ptr);
   1.661 +#else
   1.662 +   return (NULL);
   1.663 +#endif
   1.664 +}
   1.665 +#endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */