1 /*
   2  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   3  *
   4  * This code is free software; you can redistribute it and/or modify it
   5  * under the terms of the GNU General Public License version 2 only, as
   6  * published by the Free Software Foundation.  Oracle designates this
   7  * particular file as subject to the "Classpath" exception as provided
   8  * by Oracle in the LICENSE file that accompanied this code.
   9  *
  10  * This code is distributed in the hope that it will be useful, but WITHOUT
  11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  13  * version 2 for more details (a copy is included in the LICENSE file that
  14  * accompanied this code).
  15  *
  16  * You should have received a copy of the GNU General Public License version
  17  * 2 along with this work; if not, write to the Free Software Foundation,
  18  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  19  *
  20  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  21  * or visit www.oracle.com if you need additional information or have any
  22  * questions.
  23  */
  24 
  25 /* pngtrans.c - transforms the data in a row (used by both readers and writers)
  26  *
  27  * This file is available under and governed by the GNU General Public
  28  * License version 2 only, as published by the Free Software Foundation.
  29  * However, the following notice accompanied the original version of this
  30  * file and, per its terms, should not be removed:
  31  *
  32  * Last changed in libpng 1.6.18 [July 23, 2015]
  33  * Copyright (c) 1998-2015 Glenn Randers-Pehrson
  34  * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
  35  * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
  36  *
  37  * This code is released under the libpng license.
  38  * For conditions of distribution and use, see the disclaimer
  39  * and license in png.h
  40  */
  41 
  42 #include "pngpriv.h"
  43 
  44 #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
  45 
  46 #if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED)
  47 /* Turn on BGR-to-RGB mapping */
  48 void PNGAPI
  49 png_set_bgr(png_structrp png_ptr)
  50 {
  51    png_debug(1, "in png_set_bgr");
  52 
  53    if (png_ptr == NULL)
  54       return;
  55 
  56    png_ptr->transformations |= PNG_BGR;
  57 }
  58 #endif
  59 
  60 #if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED)
  61 /* Turn on 16-bit byte swapping */
  62 void PNGAPI
  63 png_set_swap(png_structrp png_ptr)
  64 {
  65    png_debug(1, "in png_set_swap");
  66 
  67    if (png_ptr == NULL)
  68       return;
  69 
  70    if (png_ptr->bit_depth == 16)
  71       png_ptr->transformations |= PNG_SWAP_BYTES;
  72 }
  73 #endif
  74 
  75 #if defined(PNG_READ_PACK_SUPPORTED) || defined(PNG_WRITE_PACK_SUPPORTED)
  76 /* Turn on pixel packing */
  77 void PNGAPI
  78 png_set_packing(png_structrp png_ptr)
  79 {
  80    png_debug(1, "in png_set_packing");
  81 
  82    if (png_ptr == NULL)
  83       return;
  84 
  85    if (png_ptr->bit_depth < 8)
  86    {
  87       png_ptr->transformations |= PNG_PACK;
  88 #     ifdef PNG_WRITE_SUPPORTED
  89          png_ptr->usr_bit_depth = 8;
  90 #     endif
  91    }
  92 }
  93 #endif
  94 
  95 #if defined(PNG_READ_PACKSWAP_SUPPORTED)||defined(PNG_WRITE_PACKSWAP_SUPPORTED)
  96 /* Turn on packed pixel swapping */
  97 void PNGAPI
  98 png_set_packswap(png_structrp png_ptr)
  99 {
 100    png_debug(1, "in png_set_packswap");
 101 
 102    if (png_ptr == NULL)
 103       return;
 104 
 105    if (png_ptr->bit_depth < 8)
 106       png_ptr->transformations |= PNG_PACKSWAP;
 107 }
 108 #endif
 109 
 110 #if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED)
 111 void PNGAPI
 112 png_set_shift(png_structrp png_ptr, png_const_color_8p true_bits)
 113 {
 114    png_debug(1, "in png_set_shift");
 115 
 116    if (png_ptr == NULL)
 117       return;
 118 
 119    png_ptr->transformations |= PNG_SHIFT;
 120    png_ptr->shift = *true_bits;
 121 }
 122 #endif
 123 
 124 #if defined(PNG_READ_INTERLACING_SUPPORTED) || \
 125     defined(PNG_WRITE_INTERLACING_SUPPORTED)
 126 int PNGAPI
 127 png_set_interlace_handling(png_structrp png_ptr)
 128 {
 129    png_debug(1, "in png_set_interlace handling");
 130 
 131    if (png_ptr != 0 && png_ptr->interlaced != 0)
 132    {
 133       png_ptr->transformations |= PNG_INTERLACE;
 134       return (7);
 135    }
 136 
 137    return (1);
 138 }
 139 #endif
 140 
 141 #if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED)
 142 /* Add a filler byte on read, or remove a filler or alpha byte on write.
 143  * The filler type has changed in v0.95 to allow future 2-byte fillers
 144  * for 48-bit input data, as well as to avoid problems with some compilers
 145  * that don't like bytes as parameters.
 146  */
 147 void PNGAPI
 148 png_set_filler(png_structrp png_ptr, png_uint_32 filler, int filler_loc)
 149 {
 150    png_debug(1, "in png_set_filler");
 151 
 152    if (png_ptr == NULL)
 153       return;
 154 
 155    /* In libpng 1.6 it is possible to determine whether this is a read or write
 156     * operation and therefore to do more checking here for a valid call.
 157     */
 158    if ((png_ptr->mode & PNG_IS_READ_STRUCT) != 0)
 159    {
 160 #     ifdef PNG_READ_FILLER_SUPPORTED
 161          /* On read png_set_filler is always valid, regardless of the base PNG
 162           * format, because other transformations can give a format where the
 163           * filler code can execute (basically an 8 or 16-bit component RGB or G
 164           * format.)
 165           *
 166           * NOTE: usr_channels is not used by the read code!  (This has led to
 167           * confusion in the past.)  The filler is only used in the read code.
 168           */
 169          png_ptr->filler = (png_uint_16)filler;
 170 #     else
 171          png_app_error(png_ptr, "png_set_filler not supported on read");
 172          PNG_UNUSED(filler) /* not used in the write case */
 173          return;
 174 #     endif
 175    }
 176 
 177    else /* write */
 178    {
 179 #     ifdef PNG_WRITE_FILLER_SUPPORTED
 180          /* On write the usr_channels parameter must be set correctly at the
 181           * start to record the number of channels in the app-supplied data.
 182           */
 183          switch (png_ptr->color_type)
 184          {
 185             case PNG_COLOR_TYPE_RGB:
 186                png_ptr->usr_channels = 4;
 187                break;
 188 
 189             case PNG_COLOR_TYPE_GRAY:
 190                if (png_ptr->bit_depth >= 8)
 191                {
 192                   png_ptr->usr_channels = 2;
 193                   break;
 194                }
 195 
 196                else
 197                {
 198                   /* There simply isn't any code in libpng to strip out bits
 199                    * from bytes when the components are less than a byte in
 200                    * size!
 201                    */
 202                   png_app_error(png_ptr,
 203                      "png_set_filler is invalid for low bit depth gray output");
 204                   return;
 205                }
 206 
 207             default:
 208                png_app_error(png_ptr,
 209                   "png_set_filler: inappropriate color type");
 210                return;
 211          }
 212 #     else
 213          png_app_error(png_ptr, "png_set_filler not supported on write");
 214          return;
 215 #     endif
 216    }
 217 
 218    /* Here on success - libpng supports the operation, set the transformation
 219     * and the flag to say where the filler channel is.
 220     */
 221    png_ptr->transformations |= PNG_FILLER;
 222 
 223    if (filler_loc == PNG_FILLER_AFTER)
 224       png_ptr->flags |= PNG_FLAG_FILLER_AFTER;
 225 
 226    else
 227       png_ptr->flags &= ~PNG_FLAG_FILLER_AFTER;
 228 }
 229 
 230 /* Added to libpng-1.2.7 */
 231 void PNGAPI
 232 png_set_add_alpha(png_structrp png_ptr, png_uint_32 filler, int filler_loc)
 233 {
 234    png_debug(1, "in png_set_add_alpha");
 235 
 236    if (png_ptr == NULL)
 237       return;
 238 
 239    png_set_filler(png_ptr, filler, filler_loc);
 240    /* The above may fail to do anything. */
 241    if ((png_ptr->transformations & PNG_FILLER) != 0)
 242       png_ptr->transformations |= PNG_ADD_ALPHA;
 243 }
 244 
 245 #endif
 246 
 247 #if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) || \
 248     defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED)
 249 void PNGAPI
 250 png_set_swap_alpha(png_structrp png_ptr)
 251 {
 252    png_debug(1, "in png_set_swap_alpha");
 253 
 254    if (png_ptr == NULL)
 255       return;
 256 
 257    png_ptr->transformations |= PNG_SWAP_ALPHA;
 258 }
 259 #endif
 260 
 261 #if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) || \
 262     defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED)
 263 void PNGAPI
 264 png_set_invert_alpha(png_structrp png_ptr)
 265 {
 266    png_debug(1, "in png_set_invert_alpha");
 267 
 268    if (png_ptr == NULL)
 269       return;
 270 
 271    png_ptr->transformations |= PNG_INVERT_ALPHA;
 272 }
 273 #endif
 274 
 275 #if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED)
 276 void PNGAPI
 277 png_set_invert_mono(png_structrp png_ptr)
 278 {
 279    png_debug(1, "in png_set_invert_mono");
 280 
 281    if (png_ptr == NULL)
 282       return;
 283 
 284    png_ptr->transformations |= PNG_INVERT_MONO;
 285 }
 286 
 287 /* Invert monochrome grayscale data */
 288 void /* PRIVATE */
 289 png_do_invert(png_row_infop row_info, png_bytep row)
 290 {
 291    png_debug(1, "in png_do_invert");
 292 
 293   /* This test removed from libpng version 1.0.13 and 1.2.0:
 294    *   if (row_info->bit_depth == 1 &&
 295    */
 296    if (row_info->color_type == PNG_COLOR_TYPE_GRAY)
 297    {
 298       png_bytep rp = row;
 299       png_size_t i;
 300       png_size_t istop = row_info->rowbytes;
 301 
 302       for (i = 0; i < istop; i++)
 303       {
 304          *rp = (png_byte)(~(*rp));
 305          rp++;
 306       }
 307    }
 308 
 309    else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA &&
 310       row_info->bit_depth == 8)
 311    {
 312       png_bytep rp = row;
 313       png_size_t i;
 314       png_size_t istop = row_info->rowbytes;
 315 
 316       for (i = 0; i < istop; i += 2)
 317       {
 318          *rp = (png_byte)(~(*rp));
 319          rp += 2;
 320       }
 321    }
 322 
 323 #ifdef PNG_16BIT_SUPPORTED
 324    else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA &&
 325       row_info->bit_depth == 16)
 326    {
 327       png_bytep rp = row;
 328       png_size_t i;
 329       png_size_t istop = row_info->rowbytes;
 330 
 331       for (i = 0; i < istop; i += 4)
 332       {
 333          *rp = (png_byte)(~(*rp));
 334          *(rp + 1) = (png_byte)(~(*(rp + 1)));
 335          rp += 4;
 336       }
 337    }
 338 #endif
 339 }
 340 #endif
 341 
 342 #ifdef PNG_16BIT_SUPPORTED
 343 #if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED)
 344 /* Swaps byte order on 16-bit depth images */
 345 void /* PRIVATE */
 346 png_do_swap(png_row_infop row_info, png_bytep row)
 347 {
 348    png_debug(1, "in png_do_swap");
 349 
 350    if (row_info->bit_depth == 16)
 351    {
 352       png_bytep rp = row;
 353       png_uint_32 i;
 354       png_uint_32 istop= row_info->width * row_info->channels;
 355 
 356       for (i = 0; i < istop; i++, rp += 2)
 357       {
 358 #ifdef PNG_BUILTIN_BSWAP16_SUPPORTED
 359          /* Feature added to libpng-1.6.11 for testing purposes, not
 360           * enabled by default.
 361           */
 362          *(png_uint_16*)rp = __builtin_bswap16(*(png_uint_16*)rp);
 363 #else
 364          png_byte t = *rp;
 365          *rp = *(rp + 1);
 366          *(rp + 1) = t;
 367 #endif
 368       }
 369    }
 370 }
 371 #endif
 372 #endif
 373 
 374 #if defined(PNG_READ_PACKSWAP_SUPPORTED)||defined(PNG_WRITE_PACKSWAP_SUPPORTED)
 375 static PNG_CONST png_byte onebppswaptable[256] = {
 376    0x00, 0x80, 0x40, 0xC0, 0x20, 0xA0, 0x60, 0xE0,
 377    0x10, 0x90, 0x50, 0xD0, 0x30, 0xB0, 0x70, 0xF0,
 378    0x08, 0x88, 0x48, 0xC8, 0x28, 0xA8, 0x68, 0xE8,
 379    0x18, 0x98, 0x58, 0xD8, 0x38, 0xB8, 0x78, 0xF8,
 380    0x04, 0x84, 0x44, 0xC4, 0x24, 0xA4, 0x64, 0xE4,
 381    0x14, 0x94, 0x54, 0xD4, 0x34, 0xB4, 0x74, 0xF4,
 382    0x0C, 0x8C, 0x4C, 0xCC, 0x2C, 0xAC, 0x6C, 0xEC,
 383    0x1C, 0x9C, 0x5C, 0xDC, 0x3C, 0xBC, 0x7C, 0xFC,
 384    0x02, 0x82, 0x42, 0xC2, 0x22, 0xA2, 0x62, 0xE2,
 385    0x12, 0x92, 0x52, 0xD2, 0x32, 0xB2, 0x72, 0xF2,
 386    0x0A, 0x8A, 0x4A, 0xCA, 0x2A, 0xAA, 0x6A, 0xEA,
 387    0x1A, 0x9A, 0x5A, 0xDA, 0x3A, 0xBA, 0x7A, 0xFA,
 388    0x06, 0x86, 0x46, 0xC6, 0x26, 0xA6, 0x66, 0xE6,
 389    0x16, 0x96, 0x56, 0xD6, 0x36, 0xB6, 0x76, 0xF6,
 390    0x0E, 0x8E, 0x4E, 0xCE, 0x2E, 0xAE, 0x6E, 0xEE,
 391    0x1E, 0x9E, 0x5E, 0xDE, 0x3E, 0xBE, 0x7E, 0xFE,
 392    0x01, 0x81, 0x41, 0xC1, 0x21, 0xA1, 0x61, 0xE1,
 393    0x11, 0x91, 0x51, 0xD1, 0x31, 0xB1, 0x71, 0xF1,
 394    0x09, 0x89, 0x49, 0xC9, 0x29, 0xA9, 0x69, 0xE9,
 395    0x19, 0x99, 0x59, 0xD9, 0x39, 0xB9, 0x79, 0xF9,
 396    0x05, 0x85, 0x45, 0xC5, 0x25, 0xA5, 0x65, 0xE5,
 397    0x15, 0x95, 0x55, 0xD5, 0x35, 0xB5, 0x75, 0xF5,
 398    0x0D, 0x8D, 0x4D, 0xCD, 0x2D, 0xAD, 0x6D, 0xED,
 399    0x1D, 0x9D, 0x5D, 0xDD, 0x3D, 0xBD, 0x7D, 0xFD,
 400    0x03, 0x83, 0x43, 0xC3, 0x23, 0xA3, 0x63, 0xE3,
 401    0x13, 0x93, 0x53, 0xD3, 0x33, 0xB3, 0x73, 0xF3,
 402    0x0B, 0x8B, 0x4B, 0xCB, 0x2B, 0xAB, 0x6B, 0xEB,
 403    0x1B, 0x9B, 0x5B, 0xDB, 0x3B, 0xBB, 0x7B, 0xFB,
 404    0x07, 0x87, 0x47, 0xC7, 0x27, 0xA7, 0x67, 0xE7,
 405    0x17, 0x97, 0x57, 0xD7, 0x37, 0xB7, 0x77, 0xF7,
 406    0x0F, 0x8F, 0x4F, 0xCF, 0x2F, 0xAF, 0x6F, 0xEF,
 407    0x1F, 0x9F, 0x5F, 0xDF, 0x3F, 0xBF, 0x7F, 0xFF
 408 };
 409 
 410 static PNG_CONST png_byte twobppswaptable[256] = {
 411    0x00, 0x40, 0x80, 0xC0, 0x10, 0x50, 0x90, 0xD0,
 412    0x20, 0x60, 0xA0, 0xE0, 0x30, 0x70, 0xB0, 0xF0,
 413    0x04, 0x44, 0x84, 0xC4, 0x14, 0x54, 0x94, 0xD4,
 414    0x24, 0x64, 0xA4, 0xE4, 0x34, 0x74, 0xB4, 0xF4,
 415    0x08, 0x48, 0x88, 0xC8, 0x18, 0x58, 0x98, 0xD8,
 416    0x28, 0x68, 0xA8, 0xE8, 0x38, 0x78, 0xB8, 0xF8,
 417    0x0C, 0x4C, 0x8C, 0xCC, 0x1C, 0x5C, 0x9C, 0xDC,
 418    0x2C, 0x6C, 0xAC, 0xEC, 0x3C, 0x7C, 0xBC, 0xFC,
 419    0x01, 0x41, 0x81, 0xC1, 0x11, 0x51, 0x91, 0xD1,
 420    0x21, 0x61, 0xA1, 0xE1, 0x31, 0x71, 0xB1, 0xF1,
 421    0x05, 0x45, 0x85, 0xC5, 0x15, 0x55, 0x95, 0xD5,
 422    0x25, 0x65, 0xA5, 0xE5, 0x35, 0x75, 0xB5, 0xF5,
 423    0x09, 0x49, 0x89, 0xC9, 0x19, 0x59, 0x99, 0xD9,
 424    0x29, 0x69, 0xA9, 0xE9, 0x39, 0x79, 0xB9, 0xF9,
 425    0x0D, 0x4D, 0x8D, 0xCD, 0x1D, 0x5D, 0x9D, 0xDD,
 426    0x2D, 0x6D, 0xAD, 0xED, 0x3D, 0x7D, 0xBD, 0xFD,
 427    0x02, 0x42, 0x82, 0xC2, 0x12, 0x52, 0x92, 0xD2,
 428    0x22, 0x62, 0xA2, 0xE2, 0x32, 0x72, 0xB2, 0xF2,
 429    0x06, 0x46, 0x86, 0xC6, 0x16, 0x56, 0x96, 0xD6,
 430    0x26, 0x66, 0xA6, 0xE6, 0x36, 0x76, 0xB6, 0xF6,
 431    0x0A, 0x4A, 0x8A, 0xCA, 0x1A, 0x5A, 0x9A, 0xDA,
 432    0x2A, 0x6A, 0xAA, 0xEA, 0x3A, 0x7A, 0xBA, 0xFA,
 433    0x0E, 0x4E, 0x8E, 0xCE, 0x1E, 0x5E, 0x9E, 0xDE,
 434    0x2E, 0x6E, 0xAE, 0xEE, 0x3E, 0x7E, 0xBE, 0xFE,
 435    0x03, 0x43, 0x83, 0xC3, 0x13, 0x53, 0x93, 0xD3,
 436    0x23, 0x63, 0xA3, 0xE3, 0x33, 0x73, 0xB3, 0xF3,
 437    0x07, 0x47, 0x87, 0xC7, 0x17, 0x57, 0x97, 0xD7,
 438    0x27, 0x67, 0xA7, 0xE7, 0x37, 0x77, 0xB7, 0xF7,
 439    0x0B, 0x4B, 0x8B, 0xCB, 0x1B, 0x5B, 0x9B, 0xDB,
 440    0x2B, 0x6B, 0xAB, 0xEB, 0x3B, 0x7B, 0xBB, 0xFB,
 441    0x0F, 0x4F, 0x8F, 0xCF, 0x1F, 0x5F, 0x9F, 0xDF,
 442    0x2F, 0x6F, 0xAF, 0xEF, 0x3F, 0x7F, 0xBF, 0xFF
 443 };
 444 
 445 static PNG_CONST png_byte fourbppswaptable[256] = {
 446    0x00, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70,
 447    0x80, 0x90, 0xA0, 0xB0, 0xC0, 0xD0, 0xE0, 0xF0,
 448    0x01, 0x11, 0x21, 0x31, 0x41, 0x51, 0x61, 0x71,
 449    0x81, 0x91, 0xA1, 0xB1, 0xC1, 0xD1, 0xE1, 0xF1,
 450    0x02, 0x12, 0x22, 0x32, 0x42, 0x52, 0x62, 0x72,
 451    0x82, 0x92, 0xA2, 0xB2, 0xC2, 0xD2, 0xE2, 0xF2,
 452    0x03, 0x13, 0x23, 0x33, 0x43, 0x53, 0x63, 0x73,
 453    0x83, 0x93, 0xA3, 0xB3, 0xC3, 0xD3, 0xE3, 0xF3,
 454    0x04, 0x14, 0x24, 0x34, 0x44, 0x54, 0x64, 0x74,
 455    0x84, 0x94, 0xA4, 0xB4, 0xC4, 0xD4, 0xE4, 0xF4,
 456    0x05, 0x15, 0x25, 0x35, 0x45, 0x55, 0x65, 0x75,
 457    0x85, 0x95, 0xA5, 0xB5, 0xC5, 0xD5, 0xE5, 0xF5,
 458    0x06, 0x16, 0x26, 0x36, 0x46, 0x56, 0x66, 0x76,
 459    0x86, 0x96, 0xA6, 0xB6, 0xC6, 0xD6, 0xE6, 0xF6,
 460    0x07, 0x17, 0x27, 0x37, 0x47, 0x57, 0x67, 0x77,
 461    0x87, 0x97, 0xA7, 0xB7, 0xC7, 0xD7, 0xE7, 0xF7,
 462    0x08, 0x18, 0x28, 0x38, 0x48, 0x58, 0x68, 0x78,
 463    0x88, 0x98, 0xA8, 0xB8, 0xC8, 0xD8, 0xE8, 0xF8,
 464    0x09, 0x19, 0x29, 0x39, 0x49, 0x59, 0x69, 0x79,
 465    0x89, 0x99, 0xA9, 0xB9, 0xC9, 0xD9, 0xE9, 0xF9,
 466    0x0A, 0x1A, 0x2A, 0x3A, 0x4A, 0x5A, 0x6A, 0x7A,
 467    0x8A, 0x9A, 0xAA, 0xBA, 0xCA, 0xDA, 0xEA, 0xFA,
 468    0x0B, 0x1B, 0x2B, 0x3B, 0x4B, 0x5B, 0x6B, 0x7B,
 469    0x8B, 0x9B, 0xAB, 0xBB, 0xCB, 0xDB, 0xEB, 0xFB,
 470    0x0C, 0x1C, 0x2C, 0x3C, 0x4C, 0x5C, 0x6C, 0x7C,
 471    0x8C, 0x9C, 0xAC, 0xBC, 0xCC, 0xDC, 0xEC, 0xFC,
 472    0x0D, 0x1D, 0x2D, 0x3D, 0x4D, 0x5D, 0x6D, 0x7D,
 473    0x8D, 0x9D, 0xAD, 0xBD, 0xCD, 0xDD, 0xED, 0xFD,
 474    0x0E, 0x1E, 0x2E, 0x3E, 0x4E, 0x5E, 0x6E, 0x7E,
 475    0x8E, 0x9E, 0xAE, 0xBE, 0xCE, 0xDE, 0xEE, 0xFE,
 476    0x0F, 0x1F, 0x2F, 0x3F, 0x4F, 0x5F, 0x6F, 0x7F,
 477    0x8F, 0x9F, 0xAF, 0xBF, 0xCF, 0xDF, 0xEF, 0xFF
 478 };
 479 
 480 /* Swaps pixel packing order within bytes */
 481 void /* PRIVATE */
 482 png_do_packswap(png_row_infop row_info, png_bytep row)
 483 {
 484    png_debug(1, "in png_do_packswap");
 485 
 486    if (row_info->bit_depth < 8)
 487    {
 488       png_bytep rp;
 489       png_const_bytep end, table;
 490 
 491       end = row + row_info->rowbytes;
 492 
 493       if (row_info->bit_depth == 1)
 494          table = onebppswaptable;
 495 
 496       else if (row_info->bit_depth == 2)
 497          table = twobppswaptable;
 498 
 499       else if (row_info->bit_depth == 4)
 500          table = fourbppswaptable;
 501 
 502       else
 503          return;
 504 
 505       for (rp = row; rp < end; rp++)
 506          *rp = table[*rp];
 507    }
 508 }
 509 #endif /* PACKSWAP || WRITE_PACKSWAP */
 510 
 511 #if defined(PNG_WRITE_FILLER_SUPPORTED) || \
 512     defined(PNG_READ_STRIP_ALPHA_SUPPORTED)
 513 /* Remove a channel - this used to be 'png_do_strip_filler' but it used a
 514  * somewhat weird combination of flags to determine what to do.  All the calls
 515  * to png_do_strip_filler are changed in 1.5.2 to call this instead with the
 516  * correct arguments.
 517  *
 518  * The routine isn't general - the channel must be the channel at the start or
 519  * end (not in the middle) of each pixel.
 520  */
 521 void /* PRIVATE */
 522 png_do_strip_channel(png_row_infop row_info, png_bytep row, int at_start)
 523 {
 524    png_bytep sp = row; /* source pointer */
 525    png_bytep dp = row; /* destination pointer */
 526    png_bytep ep = row + row_info->rowbytes; /* One beyond end of row */
 527 
 528    /* At the start sp will point to the first byte to copy and dp to where
 529     * it is copied to.  ep always points just beyond the end of the row, so
 530     * the loop simply copies (channels-1) channels until sp reaches ep.
 531     *
 532     * at_start:        0 -- convert AG, XG, ARGB, XRGB, AAGG, XXGG, etc.
 533     *            nonzero -- convert GA, GX, RGBA, RGBX, GGAA, RRGGBBXX, etc.
 534     */
 535 
 536    /* GA, GX, XG cases */
 537    if (row_info->channels == 2)
 538    {
 539       if (row_info->bit_depth == 8)
 540       {
 541          if (at_start != 0) /* Skip initial filler */
 542             ++sp;
 543          else          /* Skip initial channel and, for sp, the filler */
 544             sp += 2, ++dp;
 545 
 546          /* For a 1 pixel wide image there is nothing to do */
 547          while (sp < ep)
 548             *dp++ = *sp, sp += 2;
 549 
 550          row_info->pixel_depth = 8;
 551       }
 552 
 553       else if (row_info->bit_depth == 16)
 554       {
 555          if (at_start != 0) /* Skip initial filler */
 556             sp += 2;
 557          else          /* Skip initial channel and, for sp, the filler */
 558             sp += 4, dp += 2;
 559 
 560          while (sp < ep)
 561             *dp++ = *sp++, *dp++ = *sp, sp += 3;
 562 
 563          row_info->pixel_depth = 16;
 564       }
 565 
 566       else
 567          return; /* bad bit depth */
 568 
 569       row_info->channels = 1;
 570 
 571       /* Finally fix the color type if it records an alpha channel */
 572       if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
 573          row_info->color_type = PNG_COLOR_TYPE_GRAY;
 574    }
 575 
 576    /* RGBA, RGBX, XRGB cases */
 577    else if (row_info->channels == 4)
 578    {
 579       if (row_info->bit_depth == 8)
 580       {
 581          if (at_start != 0) /* Skip initial filler */
 582             ++sp;
 583          else          /* Skip initial channels and, for sp, the filler */
 584             sp += 4, dp += 3;
 585 
 586          /* Note that the loop adds 3 to dp and 4 to sp each time. */
 587          while (sp < ep)
 588             *dp++ = *sp++, *dp++ = *sp++, *dp++ = *sp, sp += 2;
 589 
 590          row_info->pixel_depth = 24;
 591       }
 592 
 593       else if (row_info->bit_depth == 16)
 594       {
 595          if (at_start != 0) /* Skip initial filler */
 596             sp += 2;
 597          else          /* Skip initial channels and, for sp, the filler */
 598             sp += 8, dp += 6;
 599 
 600          while (sp < ep)
 601          {
 602             /* Copy 6 bytes, skip 2 */
 603             *dp++ = *sp++, *dp++ = *sp++;
 604             *dp++ = *sp++, *dp++ = *sp++;
 605             *dp++ = *sp++, *dp++ = *sp, sp += 3;
 606          }
 607 
 608          row_info->pixel_depth = 48;
 609       }
 610 
 611       else
 612          return; /* bad bit depth */
 613 
 614       row_info->channels = 3;
 615 
 616       /* Finally fix the color type if it records an alpha channel */
 617       if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
 618          row_info->color_type = PNG_COLOR_TYPE_RGB;
 619    }
 620 
 621    else
 622       return; /* The filler channel has gone already */
 623 
 624    /* Fix the rowbytes value. */
 625    row_info->rowbytes = dp-row;
 626 }
 627 #endif
 628 
 629 #if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED)
 630 /* Swaps red and blue bytes within a pixel */
 631 void /* PRIVATE */
 632 png_do_bgr(png_row_infop row_info, png_bytep row)
 633 {
 634    png_debug(1, "in png_do_bgr");
 635 
 636    if ((row_info->color_type & PNG_COLOR_MASK_COLOR) != 0)
 637    {
 638       png_uint_32 row_width = row_info->width;
 639       if (row_info->bit_depth == 8)
 640       {
 641          if (row_info->color_type == PNG_COLOR_TYPE_RGB)
 642          {
 643             png_bytep rp;
 644             png_uint_32 i;
 645 
 646             for (i = 0, rp = row; i < row_width; i++, rp += 3)
 647             {
 648                png_byte save = *rp;
 649                *rp = *(rp + 2);
 650                *(rp + 2) = save;
 651             }
 652          }
 653 
 654          else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
 655          {
 656             png_bytep rp;
 657             png_uint_32 i;
 658 
 659             for (i = 0, rp = row; i < row_width; i++, rp += 4)
 660             {
 661                png_byte save = *rp;
 662                *rp = *(rp + 2);
 663                *(rp + 2) = save;
 664             }
 665          }
 666       }
 667 
 668 #ifdef PNG_16BIT_SUPPORTED
 669       else if (row_info->bit_depth == 16)
 670       {
 671          if (row_info->color_type == PNG_COLOR_TYPE_RGB)
 672          {
 673             png_bytep rp;
 674             png_uint_32 i;
 675 
 676             for (i = 0, rp = row; i < row_width; i++, rp += 6)
 677             {
 678                png_byte save = *rp;
 679                *rp = *(rp + 4);
 680                *(rp + 4) = save;
 681                save = *(rp + 1);
 682                *(rp + 1) = *(rp + 5);
 683                *(rp + 5) = save;
 684             }
 685          }
 686 
 687          else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
 688          {
 689             png_bytep rp;
 690             png_uint_32 i;
 691 
 692             for (i = 0, rp = row; i < row_width; i++, rp += 8)
 693             {
 694                png_byte save = *rp;
 695                *rp = *(rp + 4);
 696                *(rp + 4) = save;
 697                save = *(rp + 1);
 698                *(rp + 1) = *(rp + 5);
 699                *(rp + 5) = save;
 700             }
 701          }
 702       }
 703 #endif
 704    }
 705 }
 706 #endif /* READ_BGR || WRITE_BGR */
 707 
 708 #if defined(PNG_READ_CHECK_FOR_INVALID_INDEX_SUPPORTED) || \
 709     defined(PNG_WRITE_CHECK_FOR_INVALID_INDEX_SUPPORTED)
 710 /* Added at libpng-1.5.10 */
 711 void /* PRIVATE */
 712 png_do_check_palette_indexes(png_structrp png_ptr, png_row_infop row_info)
 713 {
 714    if (png_ptr->num_palette < (1 << row_info->bit_depth) &&
 715       png_ptr->num_palette > 0) /* num_palette can be 0 in MNG files */
 716    {
 717       /* Calculations moved outside switch in an attempt to stop different
 718        * compiler warnings.  'padding' is in *bits* within the last byte, it is
 719        * an 'int' because pixel_depth becomes an 'int' in the expression below,
 720        * and this calculation is used because it avoids warnings that other
 721        * forms produced on either GCC or MSVC.
 722        */
 723       int padding = (-row_info->pixel_depth * row_info->width) & 7;
 724       png_bytep rp = png_ptr->row_buf + row_info->rowbytes;
 725 
 726       switch (row_info->bit_depth)
 727       {
 728          case 1:
 729          {
 730             /* in this case, all bytes must be 0 so we don't need
 731              * to unpack the pixels except for the rightmost one.
 732              */
 733             for (; rp > png_ptr->row_buf; rp--)
 734             {
 735               if ((*rp >> padding) != 0)
 736                  png_ptr->num_palette_max = 1;
 737               padding = 0;
 738             }
 739 
 740             break;
 741          }
 742 
 743          case 2:
 744          {
 745             for (; rp > png_ptr->row_buf; rp--)
 746             {
 747               int i = ((*rp >> padding) & 0x03);
 748 
 749               if (i > png_ptr->num_palette_max)
 750                  png_ptr->num_palette_max = i;
 751 
 752               i = (((*rp >> padding) >> 2) & 0x03);
 753 
 754               if (i > png_ptr->num_palette_max)
 755                  png_ptr->num_palette_max = i;
 756 
 757               i = (((*rp >> padding) >> 4) & 0x03);
 758 
 759               if (i > png_ptr->num_palette_max)
 760                  png_ptr->num_palette_max = i;
 761 
 762               i = (((*rp >> padding) >> 6) & 0x03);
 763 
 764               if (i > png_ptr->num_palette_max)
 765                  png_ptr->num_palette_max = i;
 766 
 767               padding = 0;
 768             }
 769 
 770             break;
 771          }
 772 
 773          case 4:
 774          {
 775             for (; rp > png_ptr->row_buf; rp--)
 776             {
 777               int i = ((*rp >> padding) & 0x0f);
 778 
 779               if (i > png_ptr->num_palette_max)
 780                  png_ptr->num_palette_max = i;
 781 
 782               i = (((*rp >> padding) >> 4) & 0x0f);
 783 
 784               if (i > png_ptr->num_palette_max)
 785                  png_ptr->num_palette_max = i;
 786 
 787               padding = 0;
 788             }
 789 
 790             break;
 791          }
 792 
 793          case 8:
 794          {
 795             for (; rp > png_ptr->row_buf; rp--)
 796             {
 797                if (*rp > png_ptr->num_palette_max)
 798                   png_ptr->num_palette_max = (int) *rp;
 799             }
 800 
 801             break;
 802          }
 803 
 804          default:
 805             break;
 806       }
 807    }
 808 }
 809 #endif /* CHECK_FOR_INVALID_INDEX */
 810 
 811 #if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \
 812     defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)
 813 #ifdef PNG_USER_TRANSFORM_PTR_SUPPORTED
 814 void PNGAPI
 815 png_set_user_transform_info(png_structrp png_ptr, png_voidp
 816    user_transform_ptr, int user_transform_depth, int user_transform_channels)
 817 {
 818    png_debug(1, "in png_set_user_transform_info");
 819 
 820    if (png_ptr == NULL)
 821       return;
 822 
 823 #ifdef PNG_READ_USER_TRANSFORM_SUPPORTED
 824    if ((png_ptr->mode & PNG_IS_READ_STRUCT) != 0 &&
 825       (png_ptr->flags & PNG_FLAG_ROW_INIT) != 0)
 826    {
 827       png_app_error(png_ptr,
 828             "info change after png_start_read_image or png_read_update_info");
 829       return;
 830    }
 831 #endif
 832 
 833    png_ptr->user_transform_ptr = user_transform_ptr;
 834    png_ptr->user_transform_depth = (png_byte)user_transform_depth;
 835    png_ptr->user_transform_channels = (png_byte)user_transform_channels;
 836 }
 837 #endif
 838 
 839 /* This function returns a pointer to the user_transform_ptr associated with
 840  * the user transform functions.  The application should free any memory
 841  * associated with this pointer before png_write_destroy and png_read_destroy
 842  * are called.
 843  */
 844 #ifdef PNG_USER_TRANSFORM_PTR_SUPPORTED
 845 png_voidp PNGAPI
 846 png_get_user_transform_ptr(png_const_structrp png_ptr)
 847 {
 848    if (png_ptr == NULL)
 849       return (NULL);
 850 
 851    return png_ptr->user_transform_ptr;
 852 }
 853 #endif
 854 
 855 #ifdef PNG_USER_TRANSFORM_INFO_SUPPORTED
 856 png_uint_32 PNGAPI
 857 png_get_current_row_number(png_const_structrp png_ptr)
 858 {
 859    /* See the comments in png.h - this is the sub-image row when reading an
 860     * interlaced image.
 861     */
 862    if (png_ptr != NULL)
 863       return png_ptr->row_number;
 864 
 865    return PNG_UINT_32_MAX; /* help the app not to fail silently */
 866 }
 867 
 868 png_byte PNGAPI
 869 png_get_current_pass_number(png_const_structrp png_ptr)
 870 {
 871    if (png_ptr != NULL)
 872       return png_ptr->pass;
 873    return 8; /* invalid */
 874 }
 875 #endif /* USER_TRANSFORM_INFO */
 876 #endif /* READ_USER_TRANSFORM || WRITE_USER_TRANSFORM */
 877 #endif /* READ || WRITE */