media/libpng/pngtrans.c

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