rev 55557 : 8217676: Upgrade libpng to 1.6.37
Reviewed-by: prr, jdv

   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  * Copyright (c) 2018 Cosmin Truta
  33  * Copyright (c) 1998-2002,2004,2006-2018 Glenn Randers-Pehrson
  34  * Copyright (c) 1996-1997 Andreas Dilger
  35  * 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"
 204                       " low bit depth gray output");
 205                   return;
 206                }
 207 
 208             default:
 209                png_app_error(png_ptr,
 210                    "png_set_filler: inappropriate color type");
 211                return;
 212          }
 213 #     else
 214          png_app_error(png_ptr, "png_set_filler not supported on write");
 215          return;
 216 #     endif
 217    }
 218 
 219    /* Here on success - libpng supports the operation, set the transformation
 220     * and the flag to say where the filler channel is.
 221     */
 222    png_ptr->transformations |= PNG_FILLER;
 223 
 224    if (filler_loc == PNG_FILLER_AFTER)
 225       png_ptr->flags |= PNG_FLAG_FILLER_AFTER;
 226 
 227    else
 228       png_ptr->flags &= ~PNG_FLAG_FILLER_AFTER;
 229 }
 230 
 231 /* Added to libpng-1.2.7 */
 232 void PNGAPI
 233 png_set_add_alpha(png_structrp png_ptr, png_uint_32 filler, int filler_loc)
 234 {
 235    png_debug(1, "in png_set_add_alpha");
 236 
 237    if (png_ptr == NULL)
 238       return;
 239 
 240    png_set_filler(png_ptr, filler, filler_loc);
 241    /* The above may fail to do anything. */
 242    if ((png_ptr->transformations & PNG_FILLER) != 0)
 243       png_ptr->transformations |= PNG_ADD_ALPHA;
 244 }
 245 
 246 #endif
 247 
 248 #if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) || \
 249     defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED)
 250 void PNGAPI
 251 png_set_swap_alpha(png_structrp png_ptr)
 252 {
 253    png_debug(1, "in png_set_swap_alpha");
 254 
 255    if (png_ptr == NULL)
 256       return;
 257 
 258    png_ptr->transformations |= PNG_SWAP_ALPHA;
 259 }
 260 #endif
 261 
 262 #if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) || \
 263     defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED)
 264 void PNGAPI
 265 png_set_invert_alpha(png_structrp png_ptr)
 266 {
 267    png_debug(1, "in png_set_invert_alpha");
 268 
 269    if (png_ptr == NULL)
 270       return;
 271 
 272    png_ptr->transformations |= PNG_INVERT_ALPHA;
 273 }
 274 #endif
 275 
 276 #if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED)
 277 void PNGAPI
 278 png_set_invert_mono(png_structrp png_ptr)
 279 {
 280    png_debug(1, "in png_set_invert_mono");
 281 
 282    if (png_ptr == NULL)
 283       return;
 284 
 285    png_ptr->transformations |= PNG_INVERT_MONO;
 286 }
 287 
 288 /* Invert monochrome grayscale data */
 289 void /* PRIVATE */
 290 png_do_invert(png_row_infop row_info, png_bytep row)
 291 {
 292    png_debug(1, "in png_do_invert");
 293 
 294   /* This test removed from libpng version 1.0.13 and 1.2.0:
 295    *   if (row_info->bit_depth == 1 &&
 296    */
 297    if (row_info->color_type == PNG_COLOR_TYPE_GRAY)
 298    {
 299       png_bytep rp = row;
 300       size_t i;
 301       size_t istop = row_info->rowbytes;
 302 
 303       for (i = 0; i < istop; i++)
 304       {
 305          *rp = (png_byte)(~(*rp));
 306          rp++;
 307       }
 308    }
 309 
 310    else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA &&
 311       row_info->bit_depth == 8)
 312    {
 313       png_bytep rp = row;
 314       size_t i;
 315       size_t istop = row_info->rowbytes;
 316 
 317       for (i = 0; i < istop; i += 2)
 318       {
 319          *rp = (png_byte)(~(*rp));
 320          rp += 2;
 321       }
 322    }
 323 
 324 #ifdef PNG_16BIT_SUPPORTED
 325    else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA &&
 326       row_info->bit_depth == 16)
 327    {
 328       png_bytep rp = row;
 329       size_t i;
 330       size_t istop = row_info->rowbytes;
 331 
 332       for (i = 0; i < istop; i += 4)
 333       {
 334          *rp = (png_byte)(~(*rp));
 335          *(rp + 1) = (png_byte)(~(*(rp + 1)));
 336          rp += 4;
 337       }
 338    }
 339 #endif
 340 }
 341 #endif
 342 
 343 #ifdef PNG_16BIT_SUPPORTED
 344 #if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED)
 345 /* Swaps byte order on 16-bit depth images */
 346 void /* PRIVATE */
 347 png_do_swap(png_row_infop row_info, png_bytep row)
 348 {
 349    png_debug(1, "in png_do_swap");
 350 
 351    if (row_info->bit_depth == 16)
 352    {
 353       png_bytep rp = row;
 354       png_uint_32 i;
 355       png_uint_32 istop= row_info->width * row_info->channels;
 356 
 357       for (i = 0; i < istop; i++, rp += 2)
 358       {
 359 #ifdef PNG_BUILTIN_BSWAP16_SUPPORTED
 360          /* Feature added to libpng-1.6.11 for testing purposes, not
 361           * enabled by default.
 362           */
 363          *(png_uint_16*)rp = __builtin_bswap16(*(png_uint_16*)rp);
 364 #else
 365          png_byte t = *rp;
 366          *rp = *(rp + 1);
 367          *(rp + 1) = t;
 368 #endif
 369       }
 370    }
 371 }
 372 #endif
 373 #endif
 374 
 375 #if defined(PNG_READ_PACKSWAP_SUPPORTED)||defined(PNG_WRITE_PACKSWAP_SUPPORTED)
 376 static const png_byte onebppswaptable[256] = {
 377    0x00, 0x80, 0x40, 0xC0, 0x20, 0xA0, 0x60, 0xE0,
 378    0x10, 0x90, 0x50, 0xD0, 0x30, 0xB0, 0x70, 0xF0,
 379    0x08, 0x88, 0x48, 0xC8, 0x28, 0xA8, 0x68, 0xE8,
 380    0x18, 0x98, 0x58, 0xD8, 0x38, 0xB8, 0x78, 0xF8,
 381    0x04, 0x84, 0x44, 0xC4, 0x24, 0xA4, 0x64, 0xE4,
 382    0x14, 0x94, 0x54, 0xD4, 0x34, 0xB4, 0x74, 0xF4,
 383    0x0C, 0x8C, 0x4C, 0xCC, 0x2C, 0xAC, 0x6C, 0xEC,
 384    0x1C, 0x9C, 0x5C, 0xDC, 0x3C, 0xBC, 0x7C, 0xFC,
 385    0x02, 0x82, 0x42, 0xC2, 0x22, 0xA2, 0x62, 0xE2,
 386    0x12, 0x92, 0x52, 0xD2, 0x32, 0xB2, 0x72, 0xF2,
 387    0x0A, 0x8A, 0x4A, 0xCA, 0x2A, 0xAA, 0x6A, 0xEA,
 388    0x1A, 0x9A, 0x5A, 0xDA, 0x3A, 0xBA, 0x7A, 0xFA,
 389    0x06, 0x86, 0x46, 0xC6, 0x26, 0xA6, 0x66, 0xE6,
 390    0x16, 0x96, 0x56, 0xD6, 0x36, 0xB6, 0x76, 0xF6,
 391    0x0E, 0x8E, 0x4E, 0xCE, 0x2E, 0xAE, 0x6E, 0xEE,
 392    0x1E, 0x9E, 0x5E, 0xDE, 0x3E, 0xBE, 0x7E, 0xFE,
 393    0x01, 0x81, 0x41, 0xC1, 0x21, 0xA1, 0x61, 0xE1,
 394    0x11, 0x91, 0x51, 0xD1, 0x31, 0xB1, 0x71, 0xF1,
 395    0x09, 0x89, 0x49, 0xC9, 0x29, 0xA9, 0x69, 0xE9,
 396    0x19, 0x99, 0x59, 0xD9, 0x39, 0xB9, 0x79, 0xF9,
 397    0x05, 0x85, 0x45, 0xC5, 0x25, 0xA5, 0x65, 0xE5,
 398    0x15, 0x95, 0x55, 0xD5, 0x35, 0xB5, 0x75, 0xF5,
 399    0x0D, 0x8D, 0x4D, 0xCD, 0x2D, 0xAD, 0x6D, 0xED,
 400    0x1D, 0x9D, 0x5D, 0xDD, 0x3D, 0xBD, 0x7D, 0xFD,
 401    0x03, 0x83, 0x43, 0xC3, 0x23, 0xA3, 0x63, 0xE3,
 402    0x13, 0x93, 0x53, 0xD3, 0x33, 0xB3, 0x73, 0xF3,
 403    0x0B, 0x8B, 0x4B, 0xCB, 0x2B, 0xAB, 0x6B, 0xEB,
 404    0x1B, 0x9B, 0x5B, 0xDB, 0x3B, 0xBB, 0x7B, 0xFB,
 405    0x07, 0x87, 0x47, 0xC7, 0x27, 0xA7, 0x67, 0xE7,
 406    0x17, 0x97, 0x57, 0xD7, 0x37, 0xB7, 0x77, 0xF7,
 407    0x0F, 0x8F, 0x4F, 0xCF, 0x2F, 0xAF, 0x6F, 0xEF,
 408    0x1F, 0x9F, 0x5F, 0xDF, 0x3F, 0xBF, 0x7F, 0xFF
 409 };
 410 
 411 static const png_byte twobppswaptable[256] = {
 412    0x00, 0x40, 0x80, 0xC0, 0x10, 0x50, 0x90, 0xD0,
 413    0x20, 0x60, 0xA0, 0xE0, 0x30, 0x70, 0xB0, 0xF0,
 414    0x04, 0x44, 0x84, 0xC4, 0x14, 0x54, 0x94, 0xD4,
 415    0x24, 0x64, 0xA4, 0xE4, 0x34, 0x74, 0xB4, 0xF4,
 416    0x08, 0x48, 0x88, 0xC8, 0x18, 0x58, 0x98, 0xD8,
 417    0x28, 0x68, 0xA8, 0xE8, 0x38, 0x78, 0xB8, 0xF8,
 418    0x0C, 0x4C, 0x8C, 0xCC, 0x1C, 0x5C, 0x9C, 0xDC,
 419    0x2C, 0x6C, 0xAC, 0xEC, 0x3C, 0x7C, 0xBC, 0xFC,
 420    0x01, 0x41, 0x81, 0xC1, 0x11, 0x51, 0x91, 0xD1,
 421    0x21, 0x61, 0xA1, 0xE1, 0x31, 0x71, 0xB1, 0xF1,
 422    0x05, 0x45, 0x85, 0xC5, 0x15, 0x55, 0x95, 0xD5,
 423    0x25, 0x65, 0xA5, 0xE5, 0x35, 0x75, 0xB5, 0xF5,
 424    0x09, 0x49, 0x89, 0xC9, 0x19, 0x59, 0x99, 0xD9,
 425    0x29, 0x69, 0xA9, 0xE9, 0x39, 0x79, 0xB9, 0xF9,
 426    0x0D, 0x4D, 0x8D, 0xCD, 0x1D, 0x5D, 0x9D, 0xDD,
 427    0x2D, 0x6D, 0xAD, 0xED, 0x3D, 0x7D, 0xBD, 0xFD,
 428    0x02, 0x42, 0x82, 0xC2, 0x12, 0x52, 0x92, 0xD2,
 429    0x22, 0x62, 0xA2, 0xE2, 0x32, 0x72, 0xB2, 0xF2,
 430    0x06, 0x46, 0x86, 0xC6, 0x16, 0x56, 0x96, 0xD6,
 431    0x26, 0x66, 0xA6, 0xE6, 0x36, 0x76, 0xB6, 0xF6,
 432    0x0A, 0x4A, 0x8A, 0xCA, 0x1A, 0x5A, 0x9A, 0xDA,
 433    0x2A, 0x6A, 0xAA, 0xEA, 0x3A, 0x7A, 0xBA, 0xFA,
 434    0x0E, 0x4E, 0x8E, 0xCE, 0x1E, 0x5E, 0x9E, 0xDE,
 435    0x2E, 0x6E, 0xAE, 0xEE, 0x3E, 0x7E, 0xBE, 0xFE,
 436    0x03, 0x43, 0x83, 0xC3, 0x13, 0x53, 0x93, 0xD3,
 437    0x23, 0x63, 0xA3, 0xE3, 0x33, 0x73, 0xB3, 0xF3,
 438    0x07, 0x47, 0x87, 0xC7, 0x17, 0x57, 0x97, 0xD7,
 439    0x27, 0x67, 0xA7, 0xE7, 0x37, 0x77, 0xB7, 0xF7,
 440    0x0B, 0x4B, 0x8B, 0xCB, 0x1B, 0x5B, 0x9B, 0xDB,
 441    0x2B, 0x6B, 0xAB, 0xEB, 0x3B, 0x7B, 0xBB, 0xFB,
 442    0x0F, 0x4F, 0x8F, 0xCF, 0x1F, 0x5F, 0x9F, 0xDF,
 443    0x2F, 0x6F, 0xAF, 0xEF, 0x3F, 0x7F, 0xBF, 0xFF
 444 };
 445 
 446 static const png_byte fourbppswaptable[256] = {
 447    0x00, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70,
 448    0x80, 0x90, 0xA0, 0xB0, 0xC0, 0xD0, 0xE0, 0xF0,
 449    0x01, 0x11, 0x21, 0x31, 0x41, 0x51, 0x61, 0x71,
 450    0x81, 0x91, 0xA1, 0xB1, 0xC1, 0xD1, 0xE1, 0xF1,
 451    0x02, 0x12, 0x22, 0x32, 0x42, 0x52, 0x62, 0x72,
 452    0x82, 0x92, 0xA2, 0xB2, 0xC2, 0xD2, 0xE2, 0xF2,
 453    0x03, 0x13, 0x23, 0x33, 0x43, 0x53, 0x63, 0x73,
 454    0x83, 0x93, 0xA3, 0xB3, 0xC3, 0xD3, 0xE3, 0xF3,
 455    0x04, 0x14, 0x24, 0x34, 0x44, 0x54, 0x64, 0x74,
 456    0x84, 0x94, 0xA4, 0xB4, 0xC4, 0xD4, 0xE4, 0xF4,
 457    0x05, 0x15, 0x25, 0x35, 0x45, 0x55, 0x65, 0x75,
 458    0x85, 0x95, 0xA5, 0xB5, 0xC5, 0xD5, 0xE5, 0xF5,
 459    0x06, 0x16, 0x26, 0x36, 0x46, 0x56, 0x66, 0x76,
 460    0x86, 0x96, 0xA6, 0xB6, 0xC6, 0xD6, 0xE6, 0xF6,
 461    0x07, 0x17, 0x27, 0x37, 0x47, 0x57, 0x67, 0x77,
 462    0x87, 0x97, 0xA7, 0xB7, 0xC7, 0xD7, 0xE7, 0xF7,
 463    0x08, 0x18, 0x28, 0x38, 0x48, 0x58, 0x68, 0x78,
 464    0x88, 0x98, 0xA8, 0xB8, 0xC8, 0xD8, 0xE8, 0xF8,
 465    0x09, 0x19, 0x29, 0x39, 0x49, 0x59, 0x69, 0x79,
 466    0x89, 0x99, 0xA9, 0xB9, 0xC9, 0xD9, 0xE9, 0xF9,
 467    0x0A, 0x1A, 0x2A, 0x3A, 0x4A, 0x5A, 0x6A, 0x7A,
 468    0x8A, 0x9A, 0xAA, 0xBA, 0xCA, 0xDA, 0xEA, 0xFA,
 469    0x0B, 0x1B, 0x2B, 0x3B, 0x4B, 0x5B, 0x6B, 0x7B,
 470    0x8B, 0x9B, 0xAB, 0xBB, 0xCB, 0xDB, 0xEB, 0xFB,
 471    0x0C, 0x1C, 0x2C, 0x3C, 0x4C, 0x5C, 0x6C, 0x7C,
 472    0x8C, 0x9C, 0xAC, 0xBC, 0xCC, 0xDC, 0xEC, 0xFC,
 473    0x0D, 0x1D, 0x2D, 0x3D, 0x4D, 0x5D, 0x6D, 0x7D,
 474    0x8D, 0x9D, 0xAD, 0xBD, 0xCD, 0xDD, 0xED, 0xFD,
 475    0x0E, 0x1E, 0x2E, 0x3E, 0x4E, 0x5E, 0x6E, 0x7E,
 476    0x8E, 0x9E, 0xAE, 0xBE, 0xCE, 0xDE, 0xEE, 0xFE,
 477    0x0F, 0x1F, 0x2F, 0x3F, 0x4F, 0x5F, 0x6F, 0x7F,
 478    0x8F, 0x9F, 0xAF, 0xBF, 0xCF, 0xDF, 0xEF, 0xFF
 479 };
 480 
 481 /* Swaps pixel packing order within bytes */
 482 void /* PRIVATE */
 483 png_do_packswap(png_row_infop row_info, png_bytep row)
 484 {
 485    png_debug(1, "in png_do_packswap");
 486 
 487    if (row_info->bit_depth < 8)
 488    {
 489       png_bytep rp;
 490       png_const_bytep end, table;
 491 
 492       end = row + row_info->rowbytes;
 493 
 494       if (row_info->bit_depth == 1)
 495          table = onebppswaptable;
 496 
 497       else if (row_info->bit_depth == 2)
 498          table = twobppswaptable;
 499 
 500       else if (row_info->bit_depth == 4)
 501          table = fourbppswaptable;
 502 
 503       else
 504          return;
 505 
 506       for (rp = row; rp < end; rp++)
 507          *rp = table[*rp];
 508    }
 509 }
 510 #endif /* PACKSWAP || WRITE_PACKSWAP */
 511 
 512 #if defined(PNG_WRITE_FILLER_SUPPORTED) || \
 513     defined(PNG_READ_STRIP_ALPHA_SUPPORTED)
 514 /* Remove a channel - this used to be 'png_do_strip_filler' but it used a
 515  * somewhat weird combination of flags to determine what to do.  All the calls
 516  * to png_do_strip_filler are changed in 1.5.2 to call this instead with the
 517  * correct arguments.
 518  *
 519  * The routine isn't general - the channel must be the channel at the start or
 520  * end (not in the middle) of each pixel.
 521  */
 522 void /* PRIVATE */
 523 png_do_strip_channel(png_row_infop row_info, png_bytep row, int at_start)
 524 {
 525    png_bytep sp = row; /* source pointer */
 526    png_bytep dp = row; /* destination pointer */
 527    png_bytep ep = row + row_info->rowbytes; /* One beyond end of row */
 528 
 529    /* At the start sp will point to the first byte to copy and dp to where
 530     * it is copied to.  ep always points just beyond the end of the row, so
 531     * the loop simply copies (channels-1) channels until sp reaches ep.
 532     *
 533     * at_start:        0 -- convert AG, XG, ARGB, XRGB, AAGG, XXGG, etc.
 534     *            nonzero -- convert GA, GX, RGBA, RGBX, GGAA, RRGGBBXX, etc.
 535     */
 536 
 537    /* GA, GX, XG cases */
 538    if (row_info->channels == 2)
 539    {
 540       if (row_info->bit_depth == 8)
 541       {
 542          if (at_start != 0) /* Skip initial filler */
 543             ++sp;
 544          else          /* Skip initial channel and, for sp, the filler */
 545          {
 546             sp += 2; ++dp;
 547          }
 548 
 549          /* For a 1 pixel wide image there is nothing to do */
 550          while (sp < ep)
 551          {
 552             *dp++ = *sp; sp += 2;
 553          }
 554 
 555          row_info->pixel_depth = 8;
 556       }
 557 
 558       else if (row_info->bit_depth == 16)
 559       {
 560          if (at_start != 0) /* Skip initial filler */
 561             sp += 2;
 562          else          /* Skip initial channel and, for sp, the filler */
 563          {
 564             sp += 4; dp += 2;
 565          }
 566 
 567          while (sp < ep)
 568          {
 569             *dp++ = *sp++; *dp++ = *sp; sp += 3;
 570          }
 571 
 572          row_info->pixel_depth = 16;
 573       }
 574 
 575       else
 576          return; /* bad bit depth */
 577 
 578       row_info->channels = 1;
 579 
 580       /* Finally fix the color type if it records an alpha channel */
 581       if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
 582          row_info->color_type = PNG_COLOR_TYPE_GRAY;
 583    }
 584 
 585    /* RGBA, RGBX, XRGB cases */
 586    else if (row_info->channels == 4)
 587    {
 588       if (row_info->bit_depth == 8)
 589       {
 590          if (at_start != 0) /* Skip initial filler */
 591             ++sp;
 592          else          /* Skip initial channels and, for sp, the filler */
 593          {
 594             sp += 4; dp += 3;
 595          }
 596 
 597          /* Note that the loop adds 3 to dp and 4 to sp each time. */
 598          while (sp < ep)
 599          {
 600             *dp++ = *sp++; *dp++ = *sp++; *dp++ = *sp; sp += 2;
 601          }
 602 
 603          row_info->pixel_depth = 24;
 604       }
 605 
 606       else if (row_info->bit_depth == 16)
 607       {
 608          if (at_start != 0) /* Skip initial filler */
 609             sp += 2;
 610          else          /* Skip initial channels and, for sp, the filler */
 611          {
 612             sp += 8; dp += 6;
 613          }
 614 
 615          while (sp < ep)
 616          {
 617             /* Copy 6 bytes, skip 2 */
 618             *dp++ = *sp++; *dp++ = *sp++;
 619             *dp++ = *sp++; *dp++ = *sp++;
 620             *dp++ = *sp++; *dp++ = *sp; sp += 3;
 621          }
 622 
 623          row_info->pixel_depth = 48;
 624       }
 625 
 626       else
 627          return; /* bad bit depth */
 628 
 629       row_info->channels = 3;
 630 
 631       /* Finally fix the color type if it records an alpha channel */
 632       if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
 633          row_info->color_type = PNG_COLOR_TYPE_RGB;
 634    }
 635 
 636    else
 637       return; /* The filler channel has gone already */
 638 
 639    /* Fix the rowbytes value. */
 640    row_info->rowbytes = (size_t)(dp-row);
 641 }
 642 #endif
 643 
 644 #if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED)
 645 /* Swaps red and blue bytes within a pixel */
 646 void /* PRIVATE */
 647 png_do_bgr(png_row_infop row_info, png_bytep row)
 648 {
 649    png_debug(1, "in png_do_bgr");
 650 
 651    if ((row_info->color_type & PNG_COLOR_MASK_COLOR) != 0)
 652    {
 653       png_uint_32 row_width = row_info->width;
 654       if (row_info->bit_depth == 8)
 655       {
 656          if (row_info->color_type == PNG_COLOR_TYPE_RGB)
 657          {
 658             png_bytep rp;
 659             png_uint_32 i;
 660 
 661             for (i = 0, rp = row; i < row_width; i++, rp += 3)
 662             {
 663                png_byte save = *rp;
 664                *rp = *(rp + 2);
 665                *(rp + 2) = save;
 666             }
 667          }
 668 
 669          else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
 670          {
 671             png_bytep rp;
 672             png_uint_32 i;
 673 
 674             for (i = 0, rp = row; i < row_width; i++, rp += 4)
 675             {
 676                png_byte save = *rp;
 677                *rp = *(rp + 2);
 678                *(rp + 2) = save;
 679             }
 680          }
 681       }
 682 
 683 #ifdef PNG_16BIT_SUPPORTED
 684       else if (row_info->bit_depth == 16)
 685       {
 686          if (row_info->color_type == PNG_COLOR_TYPE_RGB)
 687          {
 688             png_bytep rp;
 689             png_uint_32 i;
 690 
 691             for (i = 0, rp = row; i < row_width; i++, rp += 6)
 692             {
 693                png_byte save = *rp;
 694                *rp = *(rp + 4);
 695                *(rp + 4) = save;
 696                save = *(rp + 1);
 697                *(rp + 1) = *(rp + 5);
 698                *(rp + 5) = save;
 699             }
 700          }
 701 
 702          else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
 703          {
 704             png_bytep rp;
 705             png_uint_32 i;
 706 
 707             for (i = 0, rp = row; i < row_width; i++, rp += 8)
 708             {
 709                png_byte save = *rp;
 710                *rp = *(rp + 4);
 711                *(rp + 4) = save;
 712                save = *(rp + 1);
 713                *(rp + 1) = *(rp + 5);
 714                *(rp + 5) = save;
 715             }
 716          }
 717       }
 718 #endif
 719    }
 720 }
 721 #endif /* READ_BGR || WRITE_BGR */
 722 
 723 #if defined(PNG_READ_CHECK_FOR_INVALID_INDEX_SUPPORTED) || \
 724     defined(PNG_WRITE_CHECK_FOR_INVALID_INDEX_SUPPORTED)
 725 /* Added at libpng-1.5.10 */
 726 void /* PRIVATE */
 727 png_do_check_palette_indexes(png_structrp png_ptr, png_row_infop row_info)
 728 {
 729    if (png_ptr->num_palette < (1 << row_info->bit_depth) &&
 730       png_ptr->num_palette > 0) /* num_palette can be 0 in MNG files */
 731    {
 732       /* Calculations moved outside switch in an attempt to stop different
 733        * compiler warnings.  'padding' is in *bits* within the last byte, it is
 734        * an 'int' because pixel_depth becomes an 'int' in the expression below,
 735        * and this calculation is used because it avoids warnings that other
 736        * forms produced on either GCC or MSVC.
 737        */
 738       int padding = PNG_PADBITS(row_info->pixel_depth, row_info->width);
 739       png_bytep rp = png_ptr->row_buf + row_info->rowbytes - 1;
 740 
 741       switch (row_info->bit_depth)
 742       {
 743          case 1:
 744          {
 745             /* in this case, all bytes must be 0 so we don't need
 746              * to unpack the pixels except for the rightmost one.
 747              */
 748             for (; rp > png_ptr->row_buf; rp--)
 749             {
 750               if ((*rp >> padding) != 0)
 751                  png_ptr->num_palette_max = 1;
 752               padding = 0;
 753             }
 754 
 755             break;
 756          }
 757 
 758          case 2:
 759          {
 760             for (; rp > png_ptr->row_buf; rp--)
 761             {
 762               int i = ((*rp >> padding) & 0x03);
 763 
 764               if (i > png_ptr->num_palette_max)
 765                  png_ptr->num_palette_max = i;
 766 
 767               i = (((*rp >> padding) >> 2) & 0x03);
 768 
 769               if (i > png_ptr->num_palette_max)
 770                  png_ptr->num_palette_max = i;
 771 
 772               i = (((*rp >> padding) >> 4) & 0x03);
 773 
 774               if (i > png_ptr->num_palette_max)
 775                  png_ptr->num_palette_max = i;
 776 
 777               i = (((*rp >> padding) >> 6) & 0x03);
 778 
 779               if (i > png_ptr->num_palette_max)
 780                  png_ptr->num_palette_max = i;
 781 
 782               padding = 0;
 783             }
 784 
 785             break;
 786          }
 787 
 788          case 4:
 789          {
 790             for (; rp > png_ptr->row_buf; rp--)
 791             {
 792               int i = ((*rp >> padding) & 0x0f);
 793 
 794               if (i > png_ptr->num_palette_max)
 795                  png_ptr->num_palette_max = i;
 796 
 797               i = (((*rp >> padding) >> 4) & 0x0f);
 798 
 799               if (i > png_ptr->num_palette_max)
 800                  png_ptr->num_palette_max = i;
 801 
 802               padding = 0;
 803             }
 804 
 805             break;
 806          }
 807 
 808          case 8:
 809          {
 810             for (; rp > png_ptr->row_buf; rp--)
 811             {
 812                if (*rp > png_ptr->num_palette_max)
 813                   png_ptr->num_palette_max = (int) *rp;
 814             }
 815 
 816             break;
 817          }
 818 
 819          default:
 820             break;
 821       }
 822    }
 823 }
 824 #endif /* CHECK_FOR_INVALID_INDEX */
 825 
 826 #if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \
 827     defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)
 828 #ifdef PNG_USER_TRANSFORM_PTR_SUPPORTED
 829 void PNGAPI
 830 png_set_user_transform_info(png_structrp png_ptr, png_voidp
 831    user_transform_ptr, int user_transform_depth, int user_transform_channels)
 832 {
 833    png_debug(1, "in png_set_user_transform_info");
 834 
 835    if (png_ptr == NULL)
 836       return;
 837 
 838 #ifdef PNG_READ_USER_TRANSFORM_SUPPORTED
 839    if ((png_ptr->mode & PNG_IS_READ_STRUCT) != 0 &&
 840       (png_ptr->flags & PNG_FLAG_ROW_INIT) != 0)
 841    {
 842       png_app_error(png_ptr,
 843           "info change after png_start_read_image or png_read_update_info");
 844       return;
 845    }
 846 #endif
 847 
 848    png_ptr->user_transform_ptr = user_transform_ptr;
 849    png_ptr->user_transform_depth = (png_byte)user_transform_depth;
 850    png_ptr->user_transform_channels = (png_byte)user_transform_channels;
 851 }
 852 #endif
 853 
 854 /* This function returns a pointer to the user_transform_ptr associated with
 855  * the user transform functions.  The application should free any memory
 856  * associated with this pointer before png_write_destroy and png_read_destroy
 857  * are called.
 858  */
 859 #ifdef PNG_USER_TRANSFORM_PTR_SUPPORTED
 860 png_voidp PNGAPI
 861 png_get_user_transform_ptr(png_const_structrp png_ptr)
 862 {
 863    if (png_ptr == NULL)
 864       return (NULL);
 865 
 866    return png_ptr->user_transform_ptr;
 867 }
 868 #endif
 869 
 870 #ifdef PNG_USER_TRANSFORM_INFO_SUPPORTED
 871 png_uint_32 PNGAPI
 872 png_get_current_row_number(png_const_structrp png_ptr)
 873 {
 874    /* See the comments in png.h - this is the sub-image row when reading an
 875     * interlaced image.
 876     */
 877    if (png_ptr != NULL)
 878       return png_ptr->row_number;
 879 
 880    return PNG_UINT_32_MAX; /* help the app not to fail silently */
 881 }
 882 
 883 png_byte PNGAPI
 884 png_get_current_pass_number(png_const_structrp png_ptr)
 885 {
 886    if (png_ptr != NULL)
 887       return png_ptr->pass;
 888    return 8; /* invalid */
 889 }
 890 #endif /* USER_TRANSFORM_INFO */
 891 #endif /* READ_USER_TRANSFORM || WRITE_USER_TRANSFORM */
 892 #endif /* READ || WRITE */
--- EOF ---