src/png/pngtrans.c


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