[wxWidgets.git] / src / png / pngtrans.c


/* pngtrans.c - transforms the data in a row (used by both readers and writers)
 *
 * Last changed in libpng 1.2.30 [August 15, 2008]
 * For conditions of distribution and use, see copyright notice in png.h
 * Copyright (c) 1998-2008 Glenn Randers-Pehrson
 * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
 * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
 */

#define PNG_INTERNAL
#include "png.h"
#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)

#if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED)
/* turn on BGR-to-RGB mapping */
void PNGAPI
png_set_bgr(png_structp png_ptr)
{
   png_debug(1, "in png_set_bgr");
   if (png_ptr == NULL) return;
   png_ptr->transformations |= PNG_BGR;
}
#endif

#if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED)
/* turn on 16 bit byte swapping */
void PNGAPI
png_set_swap(png_structp png_ptr)
{
   png_debug(1, "in png_set_swap");
   if (png_ptr == NULL) return;
   if (png_ptr->bit_depth == 16)
      png_ptr->transformations |= PNG_SWAP_BYTES;
}
#endif

#if defined(PNG_READ_PACK_SUPPORTED) || defined(PNG_WRITE_PACK_SUPPORTED)
/* turn on pixel packing */
void PNGAPI
png_set_packing(png_structp png_ptr)
{
   png_debug(1, "in png_set_packing");
   if (png_ptr == NULL) return;
   if (png_ptr->bit_depth < 8)
   {
      png_ptr->transformations |= PNG_PACK;
      png_ptr->usr_bit_depth = 8;
   }
}
#endif

#if defined(PNG_READ_PACKSWAP_SUPPORTED)||defined(PNG_WRITE_PACKSWAP_SUPPORTED)
/* turn on packed pixel swapping */
void PNGAPI
png_set_packswap(png_structp png_ptr)
{
   png_debug(1, "in png_set_packswap");
   if (png_ptr == NULL) return;
   if (png_ptr->bit_depth < 8)
      png_ptr->transformations |= PNG_PACKSWAP;
}
#endif

#if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED)
void PNGAPI
png_set_shift(png_structp png_ptr, png_color_8p true_bits)
{
   png_debug(1, "in png_set_shift");
   if (png_ptr == NULL) return;
   png_ptr->transformations |= PNG_SHIFT;
   png_ptr->shift = *true_bits;
}
#endif

#if defined(PNG_READ_INTERLACING_SUPPORTED) || \
    defined(PNG_WRITE_INTERLACING_SUPPORTED)
int PNGAPI
png_set_interlace_handling(png_structp png_ptr)
{
   png_debug(1, "in png_set_interlace handling");
   if (png_ptr && png_ptr->interlaced)
   {
      png_ptr->transformations |= PNG_INTERLACE;
      return (7);
   }

   return (1);
}
#endif

#if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED)
/* Add a filler byte on read, or remove a filler or alpha byte on write.
 * The filler type has changed in v0.95 to allow future 2-byte fillers
 * for 48-bit input data, as well as to avoid problems with some compilers
 * that don't like bytes as parameters.
 */
void PNGAPI
png_set_filler(png_structp png_ptr, png_uint_32 filler, int filler_loc)
{
   png_debug(1, "in png_set_filler");
   if (png_ptr == NULL) return;
   png_ptr->transformations |= PNG_FILLER;
   png_ptr->filler = (png_byte)filler;
   if (filler_loc == PNG_FILLER_AFTER)
      png_ptr->flags |= PNG_FLAG_FILLER_AFTER;
   else
      png_ptr->flags &= ~PNG_FLAG_FILLER_AFTER;

   /* This should probably go in the "do_read_filler" routine.
    * I attempted to do that in libpng-1.0.1a but that caused problems
    * so I restored it in libpng-1.0.2a
   */

   if (png_ptr->color_type == PNG_COLOR_TYPE_RGB)
   {
      png_ptr->usr_channels = 4;
   }

   /* Also I added this in libpng-1.0.2a (what happens when we expand
    * a less-than-8-bit grayscale to GA? */

   if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY && png_ptr->bit_depth >= 8)
   {
      png_ptr->usr_channels = 2;
   }
}

#if !defined(PNG_1_0_X)
/* Added to libpng-1.2.7 */
void PNGAPI
png_set_add_alpha(png_structp png_ptr, png_uint_32 filler, int filler_loc)
{
   png_debug(1, "in png_set_add_alpha");
   if (png_ptr == NULL) return;
   png_set_filler(png_ptr, filler, filler_loc);
   png_ptr->transformations |= PNG_ADD_ALPHA;
}
#endif

#endif

#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) || \
    defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED)
void PNGAPI
png_set_swap_alpha(png_structp png_ptr)
{
   png_debug(1, "in png_set_swap_alpha");
   if (png_ptr == NULL) return;
   png_ptr->transformations |= PNG_SWAP_ALPHA;
}
#endif

#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) || \
    defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED)
void PNGAPI
png_set_invert_alpha(png_structp png_ptr)
{
   png_debug(1, "in png_set_invert_alpha");
   if (png_ptr == NULL) return;
   png_ptr->transformations |= PNG_INVERT_ALPHA;
}
#endif

#if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED)
void PNGAPI
png_set_invert_mono(png_structp png_ptr)
{
   png_debug(1, "in png_set_invert_mono");
   if (png_ptr == NULL) return;
   png_ptr->transformations |= PNG_INVERT_MONO;
}

/* invert monochrome grayscale data */
void /* PRIVATE */
png_do_invert(png_row_infop row_info, png_bytep row)
{
   png_debug(1, "in png_do_invert");
  /* This test removed from libpng version 1.0.13 and 1.2.0:
   *   if (row_info->bit_depth == 1 &&
   */
#if defined(PNG_USELESS_TESTS_SUPPORTED)
   if (row == NULL || row_info == NULL)
     return;
#endif
   if (row_info->color_type == PNG_COLOR_TYPE_GRAY)
   {
      png_bytep rp = row;
      png_uint_32 i;
      png_uint_32 istop = row_info->rowbytes;

      for (i = 0; i < istop; i++)
      {
         *rp = (png_byte)(~(*rp));
         rp++;
      }
   }
   else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA &&
      row_info->bit_depth == 8)
   {
      png_bytep rp = row;
      png_uint_32 i;
      png_uint_32 istop = row_info->rowbytes;

      for (i = 0; i < istop; i+=2)
      {
         *rp = (png_byte)(~(*rp));
         rp+=2;
      }
   }
   else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA &&
      row_info->bit_depth == 16)
   {
      png_bytep rp = row;
      png_uint_32 i;
      png_uint_32 istop = row_info->rowbytes;

      for (i = 0; i < istop; i+=4)
      {
         *rp = (png_byte)(~(*rp));
         *(rp+1) = (png_byte)(~(*(rp+1)));
         rp+=4;
      }
   }
}
#endif

#if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED)
/* swaps byte order on 16 bit depth images */
void /* PRIVATE */
png_do_swap(png_row_infop row_info, png_bytep row)
{
   png_debug(1, "in png_do_swap");
   if (
#if defined(PNG_USELESS_TESTS_SUPPORTED)
       row != NULL && row_info != NULL &&
#endif
       row_info->bit_depth == 16)
   {
      png_bytep rp = row;
      png_uint_32 i;
      png_uint_32 istop= row_info->width * row_info->channels;

      for (i = 0; i < istop; i++, rp += 2)
      {
         png_byte t = *rp;
         *rp = *(rp + 1);
         *(rp + 1) = t;
      }
   }
}
#endif

#if defined(PNG_READ_PACKSWAP_SUPPORTED)||defined(PNG_WRITE_PACKSWAP_SUPPORTED)
static PNG_CONST png_byte onebppswaptable[256] = {
   0x00, 0x80, 0x40, 0xC0, 0x20, 0xA0, 0x60, 0xE0,
   0x10, 0x90, 0x50, 0xD0, 0x30, 0xB0, 0x70, 0xF0,
   0x08, 0x88, 0x48, 0xC8, 0x28, 0xA8, 0x68, 0xE8,
   0x18, 0x98, 0x58, 0xD8, 0x38, 0xB8, 0x78, 0xF8,
   0x04, 0x84, 0x44, 0xC4, 0x24, 0xA4, 0x64, 0xE4,
   0x14, 0x94, 0x54, 0xD4, 0x34, 0xB4, 0x74, 0xF4,
   0x0C, 0x8C, 0x4C, 0xCC, 0x2C, 0xAC, 0x6C, 0xEC,
   0x1C, 0x9C, 0x5C, 0xDC, 0x3C, 0xBC, 0x7C, 0xFC,
   0x02, 0x82, 0x42, 0xC2, 0x22, 0xA2, 0x62, 0xE2,
   0x12, 0x92, 0x52, 0xD2, 0x32, 0xB2, 0x72, 0xF2,
   0x0A, 0x8A, 0x4A, 0xCA, 0x2A, 0xAA, 0x6A, 0xEA,
   0x1A, 0x9A, 0x5A, 0xDA, 0x3A, 0xBA, 0x7A, 0xFA,
   0x06, 0x86, 0x46, 0xC6, 0x26, 0xA6, 0x66, 0xE6,
   0x16, 0x96, 0x56, 0xD6, 0x36, 0xB6, 0x76, 0xF6,
   0x0E, 0x8E, 0x4E, 0xCE, 0x2E, 0xAE, 0x6E, 0xEE,
   0x1E, 0x9E, 0x5E, 0xDE, 0x3E, 0xBE, 0x7E, 0xFE,
   0x01, 0x81, 0x41, 0xC1, 0x21, 0xA1, 0x61, 0xE1,
   0x11, 0x91, 0x51, 0xD1, 0x31, 0xB1, 0x71, 0xF1,
   0x09, 0x89, 0x49, 0xC9, 0x29, 0xA9, 0x69, 0xE9,
   0x19, 0x99, 0x59, 0xD9, 0x39, 0xB9, 0x79, 0xF9,
   0x05, 0x85, 0x45, 0xC5, 0x25, 0xA5, 0x65, 0xE5,
   0x15, 0x95, 0x55, 0xD5, 0x35, 0xB5, 0x75, 0xF5,
   0x0D, 0x8D, 0x4D, 0xCD, 0x2D, 0xAD, 0x6D, 0xED,
   0x1D, 0x9D, 0x5D, 0xDD, 0x3D, 0xBD, 0x7D, 0xFD,
   0x03, 0x83, 0x43, 0xC3, 0x23, 0xA3, 0x63, 0xE3,
   0x13, 0x93, 0x53, 0xD3, 0x33, 0xB3, 0x73, 0xF3,
   0x0B, 0x8B, 0x4B, 0xCB, 0x2B, 0xAB, 0x6B, 0xEB,
   0x1B, 0x9B, 0x5B, 0xDB, 0x3B, 0xBB, 0x7B, 0xFB,
   0x07, 0x87, 0x47, 0xC7, 0x27, 0xA7, 0x67, 0xE7,
   0x17, 0x97, 0x57, 0xD7, 0x37, 0xB7, 0x77, 0xF7,
   0x0F, 0x8F, 0x4F, 0xCF, 0x2F, 0xAF, 0x6F, 0xEF,
   0x1F, 0x9F, 0x5F, 0xDF, 0x3F, 0xBF, 0x7F, 0xFF
};

static PNG_CONST png_byte twobppswaptable[256] = {
   0x00, 0x40, 0x80, 0xC0, 0x10, 0x50, 0x90, 0xD0,
   0x20, 0x60, 0xA0, 0xE0, 0x30, 0x70, 0xB0, 0xF0,
   0x04, 0x44, 0x84, 0xC4, 0x14, 0x54, 0x94, 0xD4,
   0x24, 0x64, 0xA4, 0xE4, 0x34, 0x74, 0xB4, 0xF4,
   0x08, 0x48, 0x88, 0xC8, 0x18, 0x58, 0x98, 0xD8,
   0x28, 0x68, 0xA8, 0xE8, 0x38, 0x78, 0xB8, 0xF8,
   0x0C, 0x4C, 0x8C, 0xCC, 0x1C, 0x5C, 0x9C, 0xDC,
   0x2C, 0x6C, 0xAC, 0xEC, 0x3C, 0x7C, 0xBC, 0xFC,
   0x01, 0x41, 0x81, 0xC1, 0x11, 0x51, 0x91, 0xD1,
   0x21, 0x61, 0xA1, 0xE1, 0x31, 0x71, 0xB1, 0xF1,
   0x05, 0x45, 0x85, 0xC5, 0x15, 0x55, 0x95, 0xD5,
   0x25, 0x65, 0xA5, 0xE5, 0x35, 0x75, 0xB5, 0xF5,
   0x09, 0x49, 0x89, 0xC9, 0x19, 0x59, 0x99, 0xD9,
   0x29, 0x69, 0xA9, 0xE9, 0x39, 0x79, 0xB9, 0xF9,
   0x0D, 0x4D, 0x8D, 0xCD, 0x1D, 0x5D, 0x9D, 0xDD,
   0x2D, 0x6D, 0xAD, 0xED, 0x3D, 0x7D, 0xBD, 0xFD,
   0x02, 0x42, 0x82, 0xC2, 0x12, 0x52, 0x92, 0xD2,
   0x22, 0x62, 0xA2, 0xE2, 0x32, 0x72, 0xB2, 0xF2,
   0x06, 0x46, 0x86, 0xC6, 0x16, 0x56, 0x96, 0xD6,
   0x26, 0x66, 0xA6, 0xE6, 0x36, 0x76, 0xB6, 0xF6,
   0x0A, 0x4A, 0x8A, 0xCA, 0x1A, 0x5A, 0x9A, 0xDA,
   0x2A, 0x6A, 0xAA, 0xEA, 0x3A, 0x7A, 0xBA, 0xFA,
   0x0E, 0x4E, 0x8E, 0xCE, 0x1E, 0x5E, 0x9E, 0xDE,
   0x2E, 0x6E, 0xAE, 0xEE, 0x3E, 0x7E, 0xBE, 0xFE,
   0x03, 0x43, 0x83, 0xC3, 0x13, 0x53, 0x93, 0xD3,
   0x23, 0x63, 0xA3, 0xE3, 0x33, 0x73, 0xB3, 0xF3,
   0x07, 0x47, 0x87, 0xC7, 0x17, 0x57, 0x97, 0xD7,
   0x27, 0x67, 0xA7, 0xE7, 0x37, 0x77, 0xB7, 0xF7,
   0x0B, 0x4B, 0x8B, 0xCB, 0x1B, 0x5B, 0x9B, 0xDB,
   0x2B, 0x6B, 0xAB, 0xEB, 0x3B, 0x7B, 0xBB, 0xFB,
   0x0F, 0x4F, 0x8F, 0xCF, 0x1F, 0x5F, 0x9F, 0xDF,
   0x2F, 0x6F, 0xAF, 0xEF, 0x3F, 0x7F, 0xBF, 0xFF
};

static PNG_CONST png_byte fourbppswaptable[256] = {
   0x00, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70,
   0x80, 0x90, 0xA0, 0xB0, 0xC0, 0xD0, 0xE0, 0xF0,
   0x01, 0x11, 0x21, 0x31, 0x41, 0x51, 0x61, 0x71,
   0x81, 0x91, 0xA1, 0xB1, 0xC1, 0xD1, 0xE1, 0xF1,
   0x02, 0x12, 0x22, 0x32, 0x42, 0x52, 0x62, 0x72,
   0x82, 0x92, 0xA2, 0xB2, 0xC2, 0xD2, 0xE2, 0xF2,
   0x03, 0x13, 0x23, 0x33, 0x43, 0x53, 0x63, 0x73,
   0x83, 0x93, 0xA3, 0xB3, 0xC3, 0xD3, 0xE3, 0xF3,
   0x04, 0x14, 0x24, 0x34, 0x44, 0x54, 0x64, 0x74,
   0x84, 0x94, 0xA4, 0xB4, 0xC4, 0xD4, 0xE4, 0xF4,
   0x05, 0x15, 0x25, 0x35, 0x45, 0x55, 0x65, 0x75,
   0x85, 0x95, 0xA5, 0xB5, 0xC5, 0xD5, 0xE5, 0xF5,
   0x06, 0x16, 0x26, 0x36, 0x46, 0x56, 0x66, 0x76,
   0x86, 0x96, 0xA6, 0xB6, 0xC6, 0xD6, 0xE6, 0xF6,
   0x07, 0x17, 0x27, 0x37, 0x47, 0x57, 0x67, 0x77,
   0x87, 0x97, 0xA7, 0xB7, 0xC7, 0xD7, 0xE7, 0xF7,
   0x08, 0x18, 0x28, 0x38, 0x48, 0x58, 0x68, 0x78,
   0x88, 0x98, 0xA8, 0xB8, 0xC8, 0xD8, 0xE8, 0xF8,
   0x09, 0x19, 0x29, 0x39, 0x49, 0x59, 0x69, 0x79,
   0x89, 0x99, 0xA9, 0xB9, 0xC9, 0xD9, 0xE9, 0xF9,
   0x0A, 0x1A, 0x2A, 0x3A, 0x4A, 0x5A, 0x6A, 0x7A,
   0x8A, 0x9A, 0xAA, 0xBA, 0xCA, 0xDA, 0xEA, 0xFA,
   0x0B, 0x1B, 0x2B, 0x3B, 0x4B, 0x5B, 0x6B, 0x7B,
   0x8B, 0x9B, 0xAB, 0xBB, 0xCB, 0xDB, 0xEB, 0xFB,
   0x0C, 0x1C, 0x2C, 0x3C, 0x4C, 0x5C, 0x6C, 0x7C,
   0x8C, 0x9C, 0xAC, 0xBC, 0xCC, 0xDC, 0xEC, 0xFC,
   0x0D, 0x1D, 0x2D, 0x3D, 0x4D, 0x5D, 0x6D, 0x7D,
   0x8D, 0x9D, 0xAD, 0xBD, 0xCD, 0xDD, 0xED, 0xFD,
   0x0E, 0x1E, 0x2E, 0x3E, 0x4E, 0x5E, 0x6E, 0x7E,
   0x8E, 0x9E, 0xAE, 0xBE, 0xCE, 0xDE, 0xEE, 0xFE,
   0x0F, 0x1F, 0x2F, 0x3F, 0x4F, 0x5F, 0x6F, 0x7F,
   0x8F, 0x9F, 0xAF, 0xBF, 0xCF, 0xDF, 0xEF, 0xFF
};

/* swaps pixel packing order within bytes */
void /* PRIVATE */
png_do_packswap(png_row_infop row_info, png_bytep row)
{
   png_debug(1, "in png_do_packswap");
   if (
#if defined(PNG_USELESS_TESTS_SUPPORTED)
       row != NULL && row_info != NULL &&
#endif
       row_info->bit_depth < 8)
   {
      png_bytep rp, end, table;

      end = row + row_info->rowbytes;

      if (row_info->bit_depth == 1)
         table = (png_bytep)onebppswaptable;
      else if (row_info->bit_depth == 2)
         table = (png_bytep)twobppswaptable;
      else if (row_info->bit_depth == 4)
         table = (png_bytep)fourbppswaptable;
      else
         return;

      for (rp = row; rp < end; rp++)
         *rp = table[*rp];
   }
}
#endif /* PNG_READ_PACKSWAP_SUPPORTED or PNG_WRITE_PACKSWAP_SUPPORTED */

#if defined(PNG_WRITE_FILLER_SUPPORTED) || \
    defined(PNG_READ_STRIP_ALPHA_SUPPORTED)
/* remove filler or alpha byte(s) */
void /* PRIVATE */
png_do_strip_filler(png_row_infop row_info, png_bytep row, png_uint_32 flags)
{
   png_debug(1, "in png_do_strip_filler");
#if defined(PNG_USELESS_TESTS_SUPPORTED)
   if (row != NULL && row_info != NULL)
#endif
   {
      png_bytep sp=row;
      png_bytep dp=row;
      png_uint_32 row_width=row_info->width;
      png_uint_32 i;

      if ((row_info->color_type == PNG_COLOR_TYPE_RGB ||
         (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA &&
         (flags & PNG_FLAG_STRIP_ALPHA))) &&
         row_info->channels == 4)
      {
         if (row_info->bit_depth == 8)
         {
            /* This converts from RGBX or RGBA to RGB */
            if (flags & PNG_FLAG_FILLER_AFTER)
            {
               dp+=3; sp+=4;
               for (i = 1; i < row_width; i++)
               {
                  *dp++ = *sp++;
                  *dp++ = *sp++;
                  *dp++ = *sp++;
                  sp++;
               }
            }
            /* This converts from XRGB or ARGB to RGB */
            else
            {
               for (i = 0; i < row_width; i++)
               {
                  sp++;
                  *dp++ = *sp++;
                  *dp++ = *sp++;
                  *dp++ = *sp++;
               }
            }
            row_info->pixel_depth = 24;
            row_info->rowbytes = row_width * 3;
         }
         else /* if (row_info->bit_depth == 16) */
         {
            if (flags & PNG_FLAG_FILLER_AFTER)
            {
               /* This converts from RRGGBBXX or RRGGBBAA to RRGGBB */
               sp += 8; dp += 6;
               for (i = 1; i < row_width; i++)
               {
                  /* This could be (although png_memcpy is probably slower):
                  png_memcpy(dp, sp, 6);
                  sp += 8;
                  dp += 6;
                  */

                  *dp++ = *sp++;
                  *dp++ = *sp++;
                  *dp++ = *sp++;
                  *dp++ = *sp++;
                  *dp++ = *sp++;
                  *dp++ = *sp++;
                  sp += 2;
               }
            }
            else
            {
               /* This converts from XXRRGGBB or AARRGGBB to RRGGBB */
               for (i = 0; i < row_width; i++)
               {
                  /* This could be (although png_memcpy is probably slower):
                  png_memcpy(dp, sp, 6);
                  sp += 8;
                  dp += 6;
                  */

                  sp+=2;
                  *dp++ = *sp++;
                  *dp++ = *sp++;
                  *dp++ = *sp++;
                  *dp++ = *sp++;
                  *dp++ = *sp++;
                  *dp++ = *sp++;
               }
            }
            row_info->pixel_depth = 48;
            row_info->rowbytes = row_width * 6;
         }
         row_info->channels = 3;
      }
      else if ((row_info->color_type == PNG_COLOR_TYPE_GRAY ||
         (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA &&
         (flags & PNG_FLAG_STRIP_ALPHA))) &&
          row_info->channels == 2)
      {
         if (row_info->bit_depth == 8)
         {
            /* This converts from GX or GA to G */
            if (flags & PNG_FLAG_FILLER_AFTER)
            {
               for (i = 0; i < row_width; i++)
               {
                  *dp++ = *sp++;
                  sp++;
               }
            }
            /* This converts from XG or AG to G */
            else
            {
               for (i = 0; i < row_width; i++)
               {
                  sp++;
                  *dp++ = *sp++;
               }
            }
            row_info->pixel_depth = 8;
            row_info->rowbytes = row_width;
         }
         else /* if (row_info->bit_depth == 16) */
         {
            if (flags & PNG_FLAG_FILLER_AFTER)
            {
               /* This converts from GGXX or GGAA to GG */
               sp += 4; dp += 2;
               for (i = 1; i < row_width; i++)
               {
                  *dp++ = *sp++;
                  *dp++ = *sp++;
                  sp += 2;
               }
            }
            else
            {
               /* This converts from XXGG or AAGG to GG */
               for (i = 0; i < row_width; i++)
               {
                  sp += 2;
                  *dp++ = *sp++;
                  *dp++ = *sp++;
               }
            }
            row_info->pixel_depth = 16;
            row_info->rowbytes = row_width * 2;
         }
         row_info->channels = 1;
      }
      if (flags & PNG_FLAG_STRIP_ALPHA)
        row_info->color_type &= ~PNG_COLOR_MASK_ALPHA;
   }
}
#endif

#if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED)
/* swaps red and blue bytes within a pixel */
void /* PRIVATE */
png_do_bgr(png_row_infop row_info, png_bytep row)
{
   png_debug(1, "in png_do_bgr");
   if (
#if defined(PNG_USELESS_TESTS_SUPPORTED)
       row != NULL && row_info != NULL &&
#endif
       (row_info->color_type & PNG_COLOR_MASK_COLOR))
   {
      png_uint_32 row_width = row_info->width;
      if (row_info->bit_depth == 8)
      {
         if (row_info->color_type == PNG_COLOR_TYPE_RGB)
         {
            png_bytep rp;
            png_uint_32 i;

            for (i = 0, rp = row; i < row_width; i++, rp += 3)
            {
               png_byte save = *rp;
               *rp = *(rp + 2);
               *(rp + 2) = save;
            }
         }
         else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
         {
            png_bytep rp;
            png_uint_32 i;

            for (i = 0, rp = row; i < row_width; i++, rp += 4)
            {
               png_byte save = *rp;
               *rp = *(rp + 2);
               *(rp + 2) = save;
            }
         }
      }
      else if (row_info->bit_depth == 16)
      {
         if (row_info->color_type == PNG_COLOR_TYPE_RGB)
         {
            png_bytep rp;
            png_uint_32 i;

            for (i = 0, rp = row; i < row_width; i++, rp += 6)
            {
               png_byte save = *rp;
               *rp = *(rp + 4);
               *(rp + 4) = save;
               save = *(rp + 1);
               *(rp + 1) = *(rp + 5);
               *(rp + 5) = save;
            }
         }
         else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
         {
            png_bytep rp;
            png_uint_32 i;

            for (i = 0, rp = row; i < row_width; i++, rp += 8)
            {
               png_byte save = *rp;
               *rp = *(rp + 4);
               *(rp + 4) = save;
               save = *(rp + 1);
               *(rp + 1) = *(rp + 5);
               *(rp + 5) = save;
            }
         }
      }
   }
}
#endif /* PNG_READ_BGR_SUPPORTED or PNG_WRITE_BGR_SUPPORTED */

#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \
    defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) || \
    defined(PNG_LEGACY_SUPPORTED)
void PNGAPI
png_set_user_transform_info(png_structp png_ptr, png_voidp
   user_transform_ptr, int user_transform_depth, int user_transform_channels)
{
   png_debug(1, "in png_set_user_transform_info");
   if (png_ptr == NULL) return;
#if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED)
   png_ptr->user_transform_ptr = user_transform_ptr;
   png_ptr->user_transform_depth = (png_byte)user_transform_depth;
   png_ptr->user_transform_channels = (png_byte)user_transform_channels;
#else
   if (user_transform_ptr || user_transform_depth || user_transform_channels)
      png_warning(png_ptr,
        "This version of libpng does not support user transform info");
#endif
}
#endif

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